【C++】C++入门

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

这篇文章是我们C++系列文章的开始，这里先了解一些C++的入门知识，希望大家喜欢这个系列。

---

一、C++关键字

C++总计63的关键字，C语言一共32个关键字

ps：下面我们看一下C++有哪些关键字，现在不做了解，等我们以后学到了再详细讲解。

二、命名空间

 在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称都是存在于全局作用域中，很容易产生冲突。所以就产生了命名空间，namespace就是应对这种情况。

命名空间的核心目的：

• 防止名称冲突：隔离不同模块的标识符
• 提升代码组织性：将相关功能分组，是结构更清晰
• 增强可维护性：便于扩展和重构代码。

2.1 命名空间的定义

定义命名空间需要使用到namespace关键字，后面跟着命名空间的名称，然后接一对 {} 即可，{} 中即是命名空间中的成员。

namespace my
{// 命名空间中的成员可以是变量，函数和类int strlen = 10;int Add(int a, int b) {return a + b;}struct node {int a;int b;};
}

命名空间还可以嵌套使用：

namespace n1
{int a;int b;int add(int x, int y) {return x + y;}namespace n2{int c;int d;int add(int x, int y) {return x + y;}}
}

 在同一个工程中允许存在多个相同名称的命名空间，编译器最后会合并为同一个命名空间。

namespace n1
{int a;int b;int add(int x, int y) {return x + y;}namespace n2{int c;int d;int add(int x, int y) {return x + y;}}
}namespace n1
{int c;int d;
}

注意：一个命名空间就定义了一个新的作用域，命名空间中所有内容都局限于该命名空间中。 

2.2 命名空间的使用 

现在我们知道如何定义一个命名空间了，那么应该如何使用命名空间里的成员呢？

namespace my
{// 命名空间中的成员可以是变量，函数和类int c = 10;int d = 66;int Add(int a, int b) {return a + b;}struct node {int a;int b;};
}int main()
{// 这里变量d就会显示未定义的标识符，导致编译报错printf("%d", d);return 0;
}

 命名空间的使用有三种方式：

1. 加命名空间名称和作用域限定符

int main()
{printf("%d", my::d);return 0;
}

2. 使用using将命名空间中某个成员引入 

using my::d;
int main()
{printf("%d", d);return 0;
}

 3. 使用 using namespace 命名空间名称 将整个命名空间引入

using namespace my;
int main()
{printf("%d", d);return 0;
}

三、C++输入&输出

每个新生儿都会以自己独特的方式向这个世界打招呼，C++刚出来，也是一个新事物。那么C++会以怎么样的方式来向这个世界打招呼呢？我们来看一下C++是如何进行问候的：

#include<iostream>
// std是C++标准库的命名空间的名称，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{cout << "Hello world!!!" << endl;return 0;
}

说明：

1. 使用cout标准输出对象（控制台）和cin标准输入对象（键盘）时，必须包含 <iostream> 头文件以及按命名空间使用方法使用std。
2. cout和cin是全局的流对象，endl是特殊的C++符号， 表示换行输出，它们都包含在 <iostream> 这个头文件中。
3. << 是流插入运算符，>> 是流提取运算符。
4. 使用C++输入输出更加方便，不需要像使用printf和scanf输入输出时那样，需要手动控制格式，C++的输入输出可以自动识别变量类型。
5. 实际上cout和cin分别是ostream和istream类型的对象，<<和>>跟运算符重载有关，这个我们在后面具体了解。

#include<iostream>
// std是C++标准库的命名空间的名称，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{int a = 1;float b = 3.3;char c = 'c';// 可以自动识别变量类型，输入endl会换行cout << a << endl;cout << b << endl;cout << c << endl;return 0;
}

 cout和cin还有很多其他用法，例如控制浮点数精度，控制整型输出进制格式等等，这里更推荐使用printf使用去控制更加方便。

四、缺省参数

4.1 缺省参数的概念

缺省参数是声明或定义函数时为函数的参数在指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

int Add(int a, int b = 10)
{return a + b;
}int main()
{int a = 5;int b = 9;cout << Add(a) << endl;    // 第二个参数没有传参，使用参数的默认值cout << Add(a, b) << endl; // 第二个参数有实参，使用实参return 0;
}

4.2 缺省参数的分类

1. 全缺省参数

// 全缺省参数就是函数里所有参数都有一个缺省值
void Func(int a = 3, int b = 6, int c = 9)
{cout << a << endl;cout << b << endl;cout << c << endl;
}

2. 半缺省参数 

// 半缺省参数就是函数里不是所有参数都有一个缺省值
void Func(int a, int b, int c = 9)
{cout << a << endl;cout << b << endl;cout << c << endl;
}

注意：

 1. 半缺省参数必须从右至左依次给，不能间隔给

 2. 缺省参数不能再函数声明和定义时同时出现，这会导致出现重定义默认参数错误

void Func(int a, int b, int c = 10);
void Func(int a, int b, int c = 9)
{cout << a << endl;cout << b << endl;cout << c << endl;
}

3. 缺省参数必须是常量或者全局变量

4. C语言不支持（编译器不支持） 

五、函数重载

在自然语言中，一个词可以有多重含义，我们会通过上下文语境来判断这个词的真实含义，也就是这个词被重载了。

5.1 函数重载的概念

函数重载：函数中一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数种类，参数个数和参数类型顺序）不同，常用来处理实现功能类似但数据类型不同的问题。

// 参数类型不同
int func1(int a, int b)
{return a + b;
}double func1(double a, double b)
{return a + b;
}// 参数个数不同
void func2(int a)
{cout << a << endl;
}void func2(int a, int b)
{cout << a << endl;cout << b << endl;
}// 参数顺序不同
void func3(int a, char b)
{cout << a << endl;cout << b << endl;
}void func3(char a, int b)
{cout << a << endl;cout << b << endl;
}

5.2 C++支持函数重载的原理------名字修饰

那么为什么C++支持函数重载，但是C语言不支持函数重载呢？

这其中关键就是C语言和C++对于函数的命名规则不一样，我们来看看C语言和C++同一个函数在汇编中的名字是什么。

在C/C++中，一个项目要运行起来，需要经历一下几个阶段：预处理，编译，汇编，链接。

1. 就像图中的sum.c中定义了main.c中需要使用的函数sum，编译后链接前，main.o的目标文件中没有sum函数的地址，因为sum在sum.c中定义，所以地址在sum.c中，那么怎么办呢？
2. 链接就是用来处理这个问题，链接器看到main.o调用sum，但是没有sum的地址，就会到sum.o的符号表中找sum的地址，然后链接在一起。
3. 那么链接时，面对sum函数，链接器会使用哪个名字取寻找呢？这里不同的编译器有自己的函数命名规则。
4. 这里我们使用Linux下的g++演示这个修饰过的名字。
5. 采用C语言编译器编译的结果 结论：gcc编译完成后，函数名字修饰没有发生改变
6. 采用C++编译器编译的结果结论：g++编译完成后，函数名字的修饰发生了改变，编译器将函数参数类型信息添加到函数名字中
7. 通过这个，我们就能知道C语言没办法支持函数重载，因为同名函数没办法区分，而C++通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不同，就可以做到函数重载
8. 当然，如果两个函数名字和参数都相同，但是返回值不相同，这样是无法做到函数重载的，编译器无法区分这两个函数

六、引用

6.1 引用的概念

引用不是新定义一个变量，而是给已存在的一个变量去了一个别名，编译器不会为了引用变量开辟内存空间，它和它引用的变量共用同一块空间。

在日常生活中，我们有一个自己身份证上的名字，还可能会有多个别人为我们取的名字。

用法：类型& 引用变量名(对象名) = 引用实体;

int main()
{int a = 10;int& b = a; // a是引用实体，b是引用变量名，b就是a的别名// 我们可以通过这两个变量的地址看出共用同一块空间printf("&a = %p\n", &a);printf("&b = %p\n", &b);return 0;
}

 

注意：引用类型必须和引用实体是同一种类型。 

6.2 引用的特性

1. 引用在定义时必须要初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

int main()
{int a = 10;int& b = a;int& c = a; // 一个变量可以有多个引用cout << c << endl;int d = 20;c = d;  // 一个引用只能引用一个实体，这里是将d当做20赋值给c，所以a的值也发生了改变cout << c << endl;cout << a << endl;return 0;
}

 

6.3 常引用

int main()
{const int a = 9;// int& ra = a;    // 该语句编译会报错，a为常量const int& ra = a;// int& rb = 6;    // 10是常量，同样会报错const int& rb = 6;return 0;
}

6.4 使用场景

1. 做参数

void Swap(int& a, int& b)
{int tmp = a;a = b;b = tmp;
}

2. 做返回值

int& Count()
{static int c = 0;c++;return c;
}

注意：如果函数返回时，出了函数作用域，如果返回对象还在（还没有还给系统），则可以使用引用返回，如果已经还给了系统，就只能传值返回。 

6.5 传值，传引用效率比较

以值作为参数或者返回类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时拷贝，因此用值作为参数或者返回值类型，效率非常低下，尤其当参数或者返回值类型非常大时，效率更加低下。

#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{A a;// 以值作为函数参数size_t begin1 = clock();for (size_t i = 0; i < 10000; ++i)TestFunc1(a);size_t end1 = clock();// 以引用作为函数参数size_t begin2 = clock();for (size_t i = 0; i < 10000; ++i)TestFunc2(a);size_t end2 = clock();// 分别计算两个函数运行结束后的时间cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

 

值和引用作为返回值类型的性能比较：

 

#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{// 以值作为函数的返回值类型size_t begin1 = clock();for (size_t i = 0; i < 100000; ++i)TestFunc1();size_t end1 = clock();// 以引用作为函数的返回值类型size_t begin2 = clock();for (size_t i = 0; i < 100000; ++i)TestFunc2();size_t end2 = clock();// 计算两个函数运算完成之后的时间cout << "TestFunc1 time:" << end1 - begin1 << endl;cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

 

我们通过上面能够看到，传值和引用在作为参数和返回类型上效率相差很大。 

6.6 引用和指针的区别

指针和引用的不同点：

1. 引用概念上定义一个变量的别名，指针存储一个变量的地址。
2. 引用在定义时必须初始化，指针没有要求。
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型的实体。
4. 没有NULL引用，但有NULL指针。
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32平台下4字节，64平台下8字节）。
6. 引用++即引用实体增加1，指针++即指针向后偏移一个类型的大小。
7. 有多级指针，但没有多级引用。
8. 访问实体方式不同，指针需要显示解引用，引用由编译器处理。
9. 引用比指针使用起来更安全。 

七、内联函数

7.1 内联函数的概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数可以提升程序运行的效率。

如果上面函数前加了inline关键字将其变为内联函数，在编译期间编译器会使用函数体替换函数调用。

 

7.2 内联函数的特性

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段会用函数体替换函数调用。
2. 缺陷：可能会使目标文件变大；优势：少了函数调用开销，提高运行效率。
3. inline对于编译器而言只是一个建议，不同编译器关于inline的实现机制可能不同，一般建议：将函数规模较小（即函数不是很长，没有明确的说法，取决于编译器内部实现）、不是递归却频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
4. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，没有函数地址了，链接就无法找到。

八、auto关键字（C++11）

8.1 类型别名思考

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

1. 类型难于拼写
2. 含义不明确导致容易出错

#include <string>
#include <vector>
#include <unordered_map>int main()
{std::unordered_map<std::string, std::vector<std::string>> um;um.insert({ "have", {"有", "吃"} });std::unordered_map<std::string, std::vector<std::string>>::iterator it = um.begin();while (it != um.end()){// ...}return 0;
}

 std::unordered_map<std::string, std::vector<std::string>>是一个类型，但是这个类型太长了，特别容易写错。聪明的大家可能想到了使用typedef取个别名，比如：

#include <string>
#include <vector>
#include <unordered_map>typedef std::unordered_map<std::string, std::vector<std::string>> un_map;
int main()
{un_map um;um.insert({ "have", {"有", "吃"} });un_map::iterator it = um.begin();while (it != um.end()){// ...}return 0;
}

使用typedef给类型取别名确实可以简化代码，但也会有新的问题：

typedef char* pc;
int main()
{const pc c;   // 编译成功还是失败？const pc* cc; // 编译成功还是失败？return 0;
}

在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量是清楚地知道表达式的类型。然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义。 

8.2 auto的简介

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有多少人去使用它，因为局部变量默认具有自动存储期（栈分配），无需显式标注。

C++11中，标准委员会赋予了auto全新的含义：auto不再是一个存储类型的指示符，而是作为一个新的类型的指示符来指示编译器，auto声明的变量必须由编译器在编译期间推导而得。

double Add(double a, double b)
{return a + b;
}int main()
{int a = 3;auto b = a;auto c = 'c';auto d = Add(3.33, 6.66);cout << typeid(b).name() << endl;cout << typeid(c).name() << endl;cout << typeid(d).name() << endl;return 0;
}

 

注意：使用auto定义变量时必须对其进行初始化，在编译阶段编译器要根据初始化表达式来推导出auto的实际类型， 因此auto并不是一种类型的声明，而是一个类型声明时的占位符，编译器会在编译期将auto替换成变量实际类型。

8.3 auto的使用细则

1. auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时必须加&

int main()
{int a = 3;auto b = &a;auto* c = &a;auto& d = a;cout << typeid(b).name() << endl;cout << typeid(c).name() << endl;cout << typeid(d).name() << endl;return 0;
}

2. 在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同类型，否则编译器将会报错，因为编译器实际只对第一个变量类型进行推导，然后用推导出来的类型定义其他变量。 

int main()
{auto a = 1, b = 2;auto c = 'a', d = 5;return 0;
}

 

8.4 auto不能推导的场景 

1. auto不能作为函数的参数

// 这里会编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void Func(auto a)
{cout << a;
}

2. auto不能直接用来声明数组

 

3. 为了避免与C++98中auto发生混淆，C++11只保留了auto作为类型指示符的用法 

九、基于范围的for循环（C++11）

9.1 范围for的使用语法

在C++98中，如果要遍历一个数组，可以按照以下方式进行：

int main()
{int array[] = { 1,2,3,4,5,6,7,8,9 };for (int i = 0; i < sizeof(array) / sizeof(int); i++) cout << array[i];for (int* p = array; p < array + sizeof(array) / sizeof(int); p++)cout << *p;return 0;
}

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时还会容易犯错。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“  ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。 

int main()
{int array[] = { 1,2,3,4,5,6,7,8,9 };for (auto& a : array) a += 3;for (auto a : array) cout << a << ' ';return 0;
}

 

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。 

9.2 范围for的使用条件 

1. for循环迭代的范围必须是确定的

对于数组而言，就是第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是循环的范围。

void Print(int array[])
{for (auto a : array) cout << a;
}

上面这个函数中的范围for就是没有明确的范围，出现了错误。

2.  迭代的对象要能去遍历，也就是实现++和==的操作。

十、指针空值------nullptr（C++11）

我们对于指针的初始化，如果没有一个合适的指向，基本上是按照下面方法初始化：

int* p = NULL;
int* p1 = 0;

NULL实际是一个宏，在传统的C头文件<stddef.h>中，有下面的定义：

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

从上面可以看到，NULL可能被定义为字面常量0，也可能被定义为无类型指针（void*）变量，这样会导致我们使用空值指针时遇到麻烦：

void Func(int)
{cout << 0 << endl;
}
void Func(int*)
{cout << "NULL" << endl;
}int main()
{Func(0);Func(NULL);Func((int*)NULL);return 0;
}

 这里我们想通过NULL去调用（int*）的函数，但由于NULL被定义为0，因此无法做到。

在C++98中，字面常量0既可以是整型变量，也可以是无类型的指针(void*)变量，但是编译器默认情况下将其看成一个整型变量，要按指针方式使用就必须要强转。因此C++11引入了nullptr这个关键字，表示指针空值。

注意：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是作为关键字引入的
2. 在C++11中，sizeof(nullptr)和sizeof((void*)0)所占的字节数相同
3. 为了提高代码的健壮性，后续表示指针空值时建议使用nullptr 

---

总结

这篇文章我们了解了很多很杂的内容，希望能够帮助大家对C++有个简单的入门了解。