C++基础知识点

一、命名空间
在C++中，我们可以使用关键字 namespace 加命名空间名字再加花括号来创建一个新的命名空间，一个命名空间相当与一个新的作用域，在该命名空间下的所有成员都仅局限于这个命名空间中。而且命名空间 namespace 可以嵌套使用。
我们来看一段代码：

namespace N1
{
    int a = 10;
    int b = 20;
    int c = a + b;
    namespace N2
    {
        int d = 40;
    }
}
int main()
{
    cout << a << endl;
    return 0;
}
上述代码编译器会报错，a 是未声明的标识符。也就是说，a 只能在命名空间 N1 中使用。
那么我们如何去使用命名空间中的成员呢。
使用命名空间名称加作用域限定符

namespace N1
{
    int a = 10;
    int b = 20;
    int c = a + b;
    namespace N2
    {
        int d = 40;
    }
}
int main()
{
    cout << N1::a << endl;
}

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

void TestFunc(int a = 0)
{
 cout<<a<<endl;
}
int main()
{
 TestFunc(); // 没有传参时，使用参数的默认值
 TestFunc(10); // 传参时，使用指定的实参
}
缺省参数分为两种：全缺省参数和半缺省参数。
1.全缺省参数,即所有参数都设定一个缺省值，函数调用时，没有指定的参数则使用缺省值。

void TestFunc(int a = 10, int b = 20, int c = 30)
{
 cout<<"a = "<<a<<endl;
 cout<<"b = "<<b<<endl;
 cout<<"c = "<<c<<endl;
}
int main()
{
    TestFunc();
}

// 注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个
缺省值
另外，缺省值必须是全局变量或者常量。  C语言不支持缺省值。

三、函数重载
是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。
 

namespace N1
{
    int add(int a, int b)
    {
        return a + b;
    }
    double add(double a, double b)
    {
        return a + b;
    }
}
using namespace N1;
int main()
{
    cout << add(1, 2) << endl;
    cout << add(1.1, 2.2) << endl;
}
上述代码执行后会出现输出结果
3
3.3
达到了我们预期的要求，那么，编译器是怎么知道我们具体想要调用的是哪个函数呢？
我们知道一个程序需要经过预处理，编译，汇编，链接这几个过程。编译器的进行编译过程中，会将函数根据函数名和参数（类型，数量，顺序）来重新修饰为一个在全局上唯一的函数名。这样，我们在调用重载函数时，不管我们调用的是哪一个同名的重载函数，在编译器那里都是一个唯一的名字，所以就会调用我们想要的重载函数。
那么是什么样的修饰规则呢？
对于C语言来说，在编译时，会对函数名前面加一个下划线 _ ，所以，在C语言中是不支持函数重载的。
而支持函数重载，所以修饰规则会非常复杂，需要根据函数名，以及参数列表来重新修饰函数名，这也就是为什么，函数重载时，必须要有不同的参数列表。因为要保证编译器在修饰后的函数名在全局上是唯一的。

我们在使用C++编译程序时，可以在函数前加上 extern "C"  表示使用C语言规则来编译。
列如：
 

extern "C" int Add(int left, int right);  //只有声明没有定义，程序在链接时会报错
int main()
{
 Add(1,2);
 return 0;
}
程序在链接时会报错：error LNK2019: 无法解析的外部符号_Add，该符号在函数 _main 中被引用。 我们可以看到，编译器已经将函数名修饰为 _Add 也就是说，使用了C语言的编译规则。

我们来看下面两个函数是否属于重载
 

short Add(short left, short right)
{
 return left+right;
}
int Add(short left, short right)
{
 return left+right;
}
答案是不属于，只改变了返回值，而返回值不作为编译器重新修饰函数名的因素。

四、引用
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。相当于给被引用的变量起了一个别名。
类型& 引用变量名(对象名) = 引用实体；
 

void TestRef()
{
 int a = 10;
 int& ra = a;//<====定义引用类型
 
 printf("%p\n", &a);
 printf("%p\n", &ra);
}
int main()
{
 TestRef();
}
程序运行结果：

我们可以看到，变量 a 和变量 a 的引用 ra 的地址都是一样的。
1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体
4.引用类型必须和引用实体是同一种类型。

常引用

void TestConstRef()
{
 const int a = 10;
 //int& ra = a; // 该语句编译时会出错，a为常量
 const int& ra = a;
 // int& b = 10; // 该语句编译时会出错，b为常量
 const int& b = 10;
 double d = 12.34;
 //int& rd = d; // 该语句编译时会出错，类型不同
 const int& rd = d;
我们来看一段代码：
 

int& Add(int a, int b)
{
 int c = a + b;
 return c;
}
int main()
{
 int& ret = Add(1, 2);
 Add(3, 4);
 cout << "Add(1, 2) is :"<< ret <<endl;
 return 0;
}
上述代码运行结果会是什么？答案是 7 。为什么呢？
如果函数返回时，离开函数作用域后，其栈上空间已经还给系统，因此不能用栈上的空间作为引用类型返回。如果以引用类型返回，返回值的生命周期必须不受函数的限制(即比函数生命周期长)。否则就不会达到预期的值。
上述代码可以这样改：
 

int c = 0;
int& Add(int a, int b)
{
    c = a + b;
    return c;
}
int main()
{
    int a = 1;
    int b = 2;
    int& ret = Add(1, 2);
    Add(3, 4);
    cout << "Add(1, 2) is :" << ret << endl;
    return 0;
}
输出结果为 3 。

值、指针和引用作为参数和返回值的效率比较：
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实
参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返
回值类型非常大时，效率就更低 。
那么指针和引用来比较呢？
引用和指针在作为传参以及返回值类型上效率几乎相同（不作证明）。

指针和引用的区别：

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

五、内联函数
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，
内联函数提升程序运行的效率。inline关键字必须和函数体定义放在一起才可以实现内联，仅仅将inline放在函数声明之前不起任何作用。inline是一个用于实现的关键字而不是一个用于声明的关键字。

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜
使用作为内联函数。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等
等，编译器优化时会忽略掉内联。
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会无法找到。

说到内联，我们可以简单的说一下宏。宏的优点是：挺高代码复用性，增强性能。缺点是： 1.不方便调试宏。（因为预编译阶段进行了替换）2.导致代码可读性差，可维护性差，容易误用。 3.没有类型安全的检查。
那么我们在C++中，有一些技术可以代替宏：常量定义——换用const ； 函数定义——换用内联。
程序运行结果如下：

为了考虑兼容性，C++11并没有消除常量0的二义性，C++11给出了全新的 nullptr 表示空值指针，即：nullptr代表一个指针空值常量。
nullptr是有类型的，其类型为nullptr_t，仅仅可以被隐式转化为指针类型，nullptr_t被定义在头文件中：
typedef decltype(nullptr) nullptr_t;

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr