C/C++学习之路: C++对C的扩展

1 ::作用域运算符

  1. 通常情况下，如果有两个同名变量，一个是全局变量，另一个是局部变量，那么局部变量在其作用域内具有较高的优先权，它将屏蔽全局变量。
  1. int a = 10; //全局变量
  2. void test(){
  3.     int a = 20; //局部变量
  4.     //全局a被隐藏
  5.     cout << "a:" << a << endl; //a:20
  6. }
  7. 123456
  1. 作用域运算符可以用来解决局部变量与全局变量的重名问题
  1. int a = 10; //全局变量
  2. //1. 局部变量和全局变量同名
  3. void test(){
  4.     int a = 20;
  5.     //打印局部变量a
  6.     cout << "局部变量a:" << a << endl; // 局部变量a:20
  7.     //打印全局变量a
  8.     cout << "全局变量a:" << ::a << endl; // 局部变量a:10
  9. }
  10. 123456789
  1. 可以看出，作用域运算符可以用来解决局部变量与全局变量的重名问题，即在局部变量的作用域内，可用::对被屏蔽的同名的全局变量进行访问。

2. 名字控制

  1. 创建名字是程序设计过程中一项最基本的活动，当一个项目很大时，它会不可避免地包含大量名字。c++允许我们对名字的产生和名字的可见性进行控制。
  2. c语言可以通过static关键字来使得名字只得在本编译单元内可见，在c++中将通过一种通过命名空间来控制对名字的访问。

1. C++命名空间(namespace)

  1. 在c++中，名称（name）可以是符号常量、变量、函数、结构、枚举、类和对象等等。工程越大，名称互相冲突性的可能性越大。另外使用多个厂商的类库时，也可能导致名称冲突。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突，标准C++引入关键字namespace（命名空间/名字空间/名称空间），可以更好地控制标识符的作用域。

2. 命名空间使用语法

  1. 命名空间只能全局范围内定义
  2. 命名空间可嵌套命名空间
  3. 命名空间是开放的，即可以随时把新的成员加入已有的命名空间中
  4. 声明和实现可分离
  5. 无名命名空间，意味着命名空间中的标识符只能在本文件内访问，相当于给这个标识符加上了static，使得其可以作为内部连接
  6. 可以有命名空间别名
  7. 当引入一个全局的using编译指令时，就为该文件打开了该命名空间，它不会影响任何其他的文件，所以可以在每一个实现文件中调整对命名空间的控制。
  8. 比如，如果发现某一个实现文件中有太多的using指令而产生的命名冲突，就要对该文件做个简单的改变，通过明确的限定或者using声明来消除名字冲突，这样不需要修改其他的实现文件。
  1. namespace A { // 创建一个命名空间
  2.     int a = 10;
  3.     namespace C { // 命名空间可嵌套命名空间
  4.         int c = 20;
  5.     }
  7.     void func1(); // 声明和实现可分离
  8. }
  10. void A::func1() {
  11.     cout << "MySpace::func1" << endl;
  12. }
  14. namespace A { // 命名空间是开放的，即可以随时把新的成员加入已有的命名空间中
  15.     void func() {
  16.         cout << "hello namespace!" << endl;
  17.     }
  18. }
  20. namespace B {
  21.     int a = 20;
  22. }
  24. namespace { // 无名命名空间，意味着命名空间中的标识符只能在本文件内访问，相当于给这个标识符加上了static，使得其可以作为内部连接
  25.     int a = 10;
  27.     void func() { cout << "hello namespace" << endl; }
  28. }
  30. void test() {
  31.     namespace A{  //错误：命名空间只能全局范围内定义
  32.         int a = 10;
  33.     }
  34.     cout << "A::a : " << A::a << endl;
  35.     cout << "B::a : " << B::a << endl;
  37.     cout << "a : " << a << endl;
  38.     func();
  40.     namespace shortName = B; // 命名空间别名
  41.     cout << "veryLongName::a : " << shortName::a << endl;
  42. }
  43. 123456789101112131415161718192021222324252627282930313233343536373839404142

3. using声明

  1. using声明可使得指定的标识符可用。
  2. 如果命名空间包含一组用相同名字重载的函数，using声明就声明了这个重载函数的所有集合。
  1. namespace A {
  2.     int paramA = 20;
  3.     int paramB = 30;
  5.     void funcA() { cout << "hello funcA" << endl; }
  7.     void funcB() { cout << "hello funcA" << endl; }
  9.     void func() {} // using声明碰到函数重载
  10.     void func(int x) {}
  12.     int func(int x, int y) {}
  14. }
  16. void test() {
  17.     //1. 通过命名空间域运算符
  18.     cout << A::paramA << endl;
  19.     A::funcA();
  20.     //2. using声明
  21.     using A::paramA; // using声明可使得指定的标识符可用
  22.     using A::funcA;
  23.     cout << paramA << endl;
  24.     //cout << paramB << endl; //不可直接访问
  25.     funcA();
  26.     //3. 同名冲突
  27.     //int paramA = 20; //相同作用域注意同名冲突
  29.     using A::func; // using声明碰到函数重载，如果命名空间包含一组用相同名字重载的函数，using声明就声明了这个重载函数的所有集合。
  30.     func();
  31.     func(10);
  32.     func(10, 20);
  33. }
  34. 123456789101112131415161718192021222324252627282930313233

4. using编译指令

  1. using编译指令使整个命名空间标识符可用.
  2. 使用using声明或using编译指令会增加命名冲突的可能性。如果有名称空间，并在代码中使用作用域解析运算符，则不会出现二义性。
  1. namespace A {
  2.     int paramA = 20;
  3.     int paramB = 30;
  5.     void funcA() { cout << "hello funcA" << endl; }
  7.     void funcB() { cout << "hello funcB" << endl; }
  8. }
  10. namespace B {
  11.     int paramA = 20;
  12.     int paramB = 30;
  14.     void funcA() { cout << "hello funcA" << endl; }
  16.     void funcB() { cout << "hello funcB" << endl; }
  17. }
  19. void test01() {
  20.     using namespace A;
  21.     cout << paramA << endl;
  22.     cout << paramB << endl;
  23.     funcA();
  24.     funcB();
  26.     //不会产生二义性
  27.     int paramA = 30;
  28.     cout << paramA << endl;
  30.     using namespace B;
  31.     //二义性产生，不知道调用A还是B的paramA
  32.     //cout << paramA << endl; //使用using声明或using编译指令会增加命名冲突的可能性。如果有名称空间，并在代码中使用作用域解析运算符，则不会出现二义性。
  33. }
  34. 123456789101112131415161718192021222324252627282930313233

3. struct类型加强

  1. c中定义结构体变量需要加上struct关键字，c++不需要。
  2. c中的结构体只能定义成员变量，不能定义成员函数。c++即可以定义成员变量，也可以定义成员函数。
  1. //1. 结构体中即可以定义成员变量，也可以定义成员函数
  2. struct Student {
  3.     string mName;
  4.     int mAge;
  6.     void setName(string name) { mName = name; }
  8.     void setAge(int age) { mAge = age; }
  10.     void showStudent() {
  11.         cout << "Name:" << mName << " Age:" << mAge << endl;
  12.     }
  13. };
  15. //2. c++中定义结构体变量不需要加struct关键字
  16. void test01() {
  17.     Student student;
  18.     student.setName("John");
  19.     student.setAge(20);
  20.     student.showStudent();
  21. }
  22. 123456789101112131415161718192021

4. 更严格的类型转换

  1. 在C++，不同类型的变量一般是不能直接赋值的，需要相应的强转。
  2. c语言代码：
  1. typedef enum COLOR{ GREEN, RED, YELLOW } color;
  2. int main(){
  3.     color mycolor = GREEN;
  4.     mycolor = 10;
  5.     printf("mycolor:%d\n", mycolor);
  6.     char* p = malloc(10);
  7.     return EXIT_SUCCESS;
  8. }
  9. 12345678
  1. 以上c代码c编译器编译可通过，c++编译器无法编译通过。

5. 三目运算符功能增强

  1. c语言三目运算表达式返回值为数据值，为右值，不能赋值。
  2. c++语言三目运算表达式返回值为变量本身(引用)，为左值，可以赋值。
  3. 左值和右值概念:
    1. 在c++中可以放在赋值操作符左边的是左值，可以放到赋值操作符右面的是右值。
    2. 有些变量即可以当左值，也可以当右值。
    3. 左值为Lvalue，L代表Location，表示内存可以寻址，可以赋值。
    4. 右值为Rvalue，R代表Read,就是可以知道它的值。
    5. 比如:int temp = 10; temp在内存中有地址，10没有，但是可以Read到它的值。
  1. int a = 10;
  2. int b = 20;
  3. printf("ret:%d\n", a > b ? a : b); 
  5. cout << "b:" << b << endl;
  6. //返回的是左值，变量的引用
  7. (a > b ? a : b) = 100;//返回的是左值，变量的引用
  8. cout << "b:" << b << endl;
  9. 12345678

6. C/C++中的const

1. const概述

const单词字面意思为常数，不变的。它是c/c++中的一个关键字，是一个限定符，它用来限定一个变量不允许改变，它将一个对象转换成一个常量。

  1. const int a = 10;
  2. A = 100; //编译错误,const是一个常量，不可修改
  3. 12

2. C/C++中const的区别

1. C中的const

  1. c中的const理解为”一个不能改变的普通变量”，也就是认为const应该是一个只读变量，既然是变量那么就会给const分配内存，并且在c中const是一个全局只读变量，c语言中const修饰的只读变量是外部连接的。
  2. 如果这么写:
  1. const int arrSize = 10;
  2. int arr[arrSize];
  3. 12
  1. 看似是一件合理的编码，但是这将得出一个错误。 因为arrSize占用某块内存，所以C编译器不知道它在编译时的值是多少.

2. C++中的const

  1. 在c++中，一个const不必创建内存空间，而在c中，一个const总是需要一块内存空间。
  2. 在c++中，是否为const常量分配内存空间依赖于如何使用。一般说来，如果一个const仅仅用来把一个名字用一个值代替(就像使用#define一样)，那么该存储局空间就不必创建。
  3. 如果存储空间没有分配内存的话，在进行完数据类型检查后，为了代码更加有效，值也许会折叠到代码中。
  4. 不过，取一个const地址, 或者把它定义为extern，则会为该const创建内存空间。
  5. 在c++中，出现在所有函数之外的const作用于整个文件(也就是说它在该文件外不可见)，默认为内部连接，c++中其他的标识符一般默认为外部连接。

3. C/C++中const异同总结

  1. c语言全局const会被存储到只读数据段。c++中全局const当声明extern或者对变量取地址时，编译器会分配存储地址，变量存储在只读数据段。两个都受到了只读数据段的保护，不可修改。
  1. const int constA = 10;
  3. int main() {
  4.     int *p = (int *) &constA;
  5.     *p = 200;
  6.     cout << *p << endl;
  7. }
  8. 1234567

  1. 以上代码在c/c++中编译通过，在运行期，修改constA的值时，发生写入错误。原因是修改只读数据段的数据。

  2. c语言中局部const存储在堆栈区，只是不能通过变量直接修改const只读变量的值，但是可以跳过编译器的检查，通过指针间接修改const值。

  3. c++中对于局部的const变量要区别对待：

    1. 对于基础数据类型，也就是const int a = 10这种，编译器会进行优化，将值替换到访问的位置。
    2. 对于基础数据类型，如果用一个变量初始化const变量，如果const int a = b,那么也是会给a分配内存。
    3. 对于自定数据类型，比如类对象，那么也会分配内存。
  1. const int constA = 10;
  2. int *q = (int *) &constA;
  3. *q = 300;
  4. printf("constA:%d\n", constA);
  5. printf("*p:%d\n", *q);
  7. int b = 10;
  8. const int constB = b;
  9. int *p = (int *) &constB;
  10. *p = 300;
  11. cout << "constB:" << constB << endl;
  12. cout << "*p:" << *p << endl;
  14. // 为person分配了内存，所以我们可以通过指针的间接赋值修改person对象。
  15. const Person person; //未初始化age
  16. //person.age = 50; //不可修改
  17. Person *pPerson = (Person *) &person; 
  18. //指针间接修改
  19. pPerson->age = 100;
  20. cout << "pPerson->age:" << pPerson->age << endl;
  21. pPerson->age = 200;
  22. cout << "pPerson->age:" << pPerson->age << endl;
  23. 12345678910111213141516171819202122
  1. c中const默认为外部连接，c++中const默认为内部连接.当c语言两个文件中都有const int a的时候，编译器会报重定义的错误。而在c++中，则不会，因为c++中的const默认是内部连接的。如果想让c++中的const具有外部连接，必须显示声明为: extern const int a = 10;
  2. 扩展：能否用变量定义数组
    1. 在支持c99标准的编译器中，可以使用变量定义数组。vs2013编译器不支持c99，Linux GCC支持c99。

3. 尽量以const替换#define

  1. 在旧版本C中，如果想建立一个常量，必须使用预处理器

define MAX 1024;// const int max = 1024

  1. 我们定义的宏MAX从未被编译器看到过，因为在预处理阶段，所有的MAX已经被替换为了1024，于是MAX并没有将其加入到符号表中。但我们使用这个常量获得一个编译错误信息时，可能会带来一些困惑，因为这个信息可能会提到1024，但是并没有提到MAX。如果MAX被定义在一个不是你写的头文件中，你可能并不知道1024代表什么，也许解决这个问题要花费很长时间。
  2. 解决办法就是用一个常量替换上面的宏。

const int max= 1024;

  1. const和#define区别总结:

    1. const有类型，可进行编译器类型安全检查。#define无类型，不可进行类型检查.
    2. const有作用域，而#define不重视作用域，默认定义处到文件结尾.如果定义在指定作用域下有效的常量，那么#define就不能用。
  2. 宏常量没有类型，所以调用了int类型重载的函数。const有类型，所以调用short类型重载的函数
  1. #define PARAM 128
  2. const short param = 128;
  4. void func(short a) {
  5.     cout << "short" << endl;
  6. }
  8. void func(int a) {
  9.     cout << "int" << endl;
  10. }
  11. 12345678910
  1. 宏常量不重视作用域
  1. void func1() {
  2.     const int a = 10;
  3. #define A 20
  4.     //#undef A  //卸载宏常量A
  5. }
  7. void func2() {
  8.     //cout << "a:" << a << endl; //不可访问，超出了const int a作用域
  9.     cout << "A:" << A << endl; //#define作用域从定义到文件结束或者到#undef，可访问
  10. }
  11. 12345678910
  1. 宏常量可以有命名空间
  1. namespace MySpace{
  2.     #define num 1024
  3. }
  5. void test(){
  6.     //cout << MySpace::NUM << endl; //错误
  7.     //int num = 100; //命名冲突
  8.     cout << num << endl;
  9. }
  10. 123456789

7. 引用(reference)

1. 引用基本用法

  1. 引用是c++对c的重要扩充。在c/c++中指针的作用基本都是一样的，但是c++增加了另外一种给函数传递地址的途径，这就是按引用传递(pass-by-reference)

    1. 变量名实质上是一段连续内存空间的别名，是一个标号(门牌号)
    2. 程序中通过变量来申请并命名内存空间
    3. 通过变量的名字可以使用存储空间

  2. c++中新增了引用的概念，引用可以作为一个已定义变量的别名。

  3. 基本语法:

  1. Type& ref = val;
  2. 1
  1. 注意事项：
    1. &在此不是求地址运算，而是起标识作用。
    2. 类型标识符是指目标变量的类型
    3. 必须在声明引用变量时进行初始化。
    4. 引用初始化之后不能改变。
    5. 不能有NULL引用。必须确保引用是和一块合法的存储单元关联。
    6. 建立对数组的引用。
  1. void test01(){
  2.     int a = 10;
  3.     //给变量a取一个别名b
  4.     int& b = a;
  5.     cout << "a:" << a << endl;
  6.     cout << "b:" << b << endl;
  7.     cout << "------------" << endl;
  8.     //操作b就相当于操作a本身
  9.     b = 100;
  10.     cout << "a:" << a << endl;
  11.     cout << "b:" << b << endl;
  12.     cout << "------------" << endl;
  13.     //一个变量可以有n个别名
  14.     int& c = a;
  15.     c = 200;
  16.     cout << "a:" << a << endl;
  17.     cout << "b:" << b << endl;
  18.     cout << "c:" << c << endl;
  19.     cout << "------------" << endl;
  20.     //a,b,c的地址都是相同的
  21.     cout << "a:" << &a << endl;
  22.     cout << "b:" << &b << endl;
  23.     cout << "c:" << &c << endl;
  24. }
  26. void test02() {
  27.     //1) 引用必须初始化
  28.     //int& ref; //报错:必须初始化引用
  29.     //2) 引用一旦初始化，不能改变引用
  30.     int a = 10;
  31.     int b = 20;
  32.     int &ref = a;
  33.     ref = b; //不能改变引用
  34. }
  35. 12345678910111213141516171819202122232425262728293031323334
  1. 建立数组引用:
  1. void test02() {
  2.     //1. 建立数组引用方法一
  3.     typedef int ArrRef[10];
  4.     int arr[10];
  5.     ArrRef &aRef = arr;
  6.     for (int i = 0; i < 10; i++) {
  7.         aRef[i] = i + 1;
  8.     }
  9.     for (int i = 0; i < 10; i++) {
  10.         cout << arr[i] << " ";
  11.     }
  12.     cout << endl;
  13.     //2. 建立数组引用方法二
  14.     int(&f)[10] = arr;
  15.     for (int i = 0; i < 10; i++) {
  16.         f[i] = i + 10;
  17.     }
  18.     for (int i = 0; i < 10; i++) {
  19.         cout << arr[i] << " ";
  20.     }
  21.     cout << endl;
  22. }
  23. 12345678910111213141516171819202122

2. 引用的本质

  1. 引用的本质在c++内部实现是一个常指针.
    Type& ref = val; // Type* const ref = &val;

  2. c++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同，只是这个过程是编译器内部实现，用户不可见。

  1. //发现是引用，转换为 int* const ref = &a;
  2. void testFunc(int& ref){
  3.     ref = 100; // ref是引用，转换为*ref = 100
  4. }
  5. int main(){
  6.     int a = 10;
  7.     int& aRef = a; //自动转换为int* const aRef = &a;这也能说明引用为什么必须初始化
  8.     aRef = 20; //内部发现aRef是引用，自动帮我们转换为: *aRef = 20;
  9.     cout << "a:" << a << endl;
  10.     cout << "aRef:" << aRef << endl;
  11.     testFunc(a);
  12.     return EXIT_SUCCESS;
  13. }
  14. 12345678910111213

3. 指针引用

  1. 在c语言中如果想改变一个指针的指向而不是它所指向的内容，函数声明可能这样:
  1. void fun(int**);
  2. 1
  1. 给指针变量取一个别名。
  1. Type* pointer = NULL;  
  2. Type*& = pointer;
  3. 12
  1. struct Teacher{
  2.     int mAge;
  3. };
  4. //指针间接修改teacher的年龄
  5. void AllocateAndInitByPointer(Teacher** teacher){
  6.     *teacher = (Teacher*)malloc(sizeof(Teacher));
  7.     (*teacher)->mAge = 200;  
  8. }
  9. //引用修改teacher年龄
  10. void AllocateAndInitByReference(Teacher*& teacher){
  11.     teacher->mAge = 300;
  12. }
  13. void test(){
  14.     //创建Teacher
  15.     Teacher* teacher = NULL;
  16.     //指针间接赋值
  17.     AllocateAndInitByPointer(&teacher);
  18.     cout << "AllocateAndInitByPointer:" << teacher->mAge << endl;
  19.     //引用赋值,将teacher本身传到ChangeAgeByReference函数中
  20.     AllocateAndInitByReference(teacher);
  21.     cout << "AllocateAndInitByReference:" << teacher->mAge << endl;
  22.     free(teacher);
  23. }
  24. 1234567891011121314151617181920212223
  1. 对于c++中的定义那个，语法清晰多了。函数参数变成指针的引用，用不着取得指针的地址。

4. 常量引用

  1. 常量引用的定义格式:
  1. const Type& ref = val;
  2. 1
  1. 常量引用注意：
    1. 字面量不能赋给引用，但是可以赋给const引用
    2. const修饰的引用，不能修改。
  1. void test01(){
  2.     int a = 100;
  3.     const int& aRef = a; //此时aRef就是a
  4.     //aRef = 200; 不能通过aRef的值
  5.     a = 100; //OK
  6.     cout << "a:" << a << endl;
  7.     cout << "aRef:" << aRef << endl;
  8. }
  9. void test02(){
  10.     //不能把一个字面量赋给引用
  11.     //int& ref = 100;
  12.     //但是可以把一个字面量赋给常引用
  13.     const int& ref = 100; //int temp = 200; const int& ret = temp;
  14. }
  15. 1234567891011121314

5. 引用使用场景

  1. 常量引用主要用在函数的形参，尤其是类的拷贝/复制构造函数。
  2. 将函数的形参定义为常量引用的好处:
    1. 引用不产生新的变量，减少形参与实参传递时的开销。
    2. 由于引用可能导致实参随形参改变而改变，将其定义为常量引用可以消除这种副作用。
  3. 如果希望实参随着形参的改变而改变，那么使用一般的引用，如果不希望实参随着形参改变，那么使用常引用。

//const int& param防止函数中意外修改数据
void ShowVal(const int& param){
cout << “param:” << param << endl;
}

1. 引用使用中注意点

  1. 最常见看见引用的地方是在函数参数和返回值中。当引用被用作函数参数的时，在函数内对任何引用的修改，将对还函数外的参数产生改变。当然，可以通过传递一个指针来做相同的事情，但引用具有更清晰的语法。
  2. 如果从函数中返回一个引用，必须像从函数中返回一个指针一样对待。当函数返回值时，引用关联的内存一定要存在。
  1. //值传递
  2. void ValueSwap(int m,int n){
  3.     int temp = m;
  4.     m = n;
  5.     n = temp;
  6. }
  7. //地址传递
  8. void PointerSwap(int* m,int* n){
  9.     int temp = *m;
  10.     *m = *n;
  11.     *n = temp;
  12. }
  13. //引用传递
  14. void ReferenceSwap(int& m,int& n){
  15.     int temp = m;
  16.     m = n;
  17.     n = temp;
  18. }
  19. void test(){
  20.     int a = 10;
  21.     int b = 20;
  22.     //值传递
  23.     ValueSwap(a, b);
  24.     cout << "a:" << a << " b:" << b << endl;
  25.     //地址传递
  26.     PointerSwap(&a, &b);
  27.     cout << "a:" << a << " b:" << b << endl;
  28.     //引用传递
  29.     ReferenceSwap(a, b);
  30.     cout << "a:" << a << " b:" << b << endl;
  31. }
  32. 12345678910111213141516171819202122232425262728293031
  1. 通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单：
    1. 函数调用时传递的实参不必加“&”符
    2. 在被调函数中不必在参数前加“*”符
  2. 引用作为其它变量的别名而存在，因此在一些场合可以代替指针。C++主张用引用传递取代地址传递的方式，因为引用语法容易且不易出错。
  1. //返回局部变量引用
  2. int& TestFun01(){
  3.     int a = 10; //局部变量
  4.     return a;
  5. }
  6. //返回静态变量引用
  7. int& TestFunc02(){    
  8.     static int a = 20;
  9.     cout << "static int a : " << a << endl;
  10.     return a;
  11. }
  12. int main(){
  13.     //不能返回局部变量的引用
  14.     int& ret01 = TestFun01();
  15.     //如果函数做左值，那么必须返回引用
  16.     TestFunc02();
  17.     TestFunc02() = 100;
  18.     TestFunc02();
  20.     return EXIT_SUCCESS;
  21. }
  22. 123456789101112131415161718192021

8. 内联函数(inline function)

1. 内联函数的引出

  1. 在c中经常把一些短并且执行频繁的计算写成宏，而不是函数，这样做的理由是为了执行效率，宏可以避免函数调用的开销，这些都由预处理来完成。

  2. 但是在c++出现之后，使用预处理宏会出现两个问题：

    1. 第一个在c中也会出现，宏看起来像一个函数调用，但是会有隐藏一些难以发现的错误。
    2. 第二个问题是c++特有的，预处理器不允许访问类的成员，也就是说预处理器宏不能用作类类的成员函数。

  3. 为了保持预处理宏的效率又增加安全性，而且还能像一般成员函数那样可以在类里访问自如，c++引入了内联函数(inline function).

  4. 内联函数为了继承宏函数的效率，没有函数调用时开销，然后又可以像普通函数那样，可以进行参数，返回值类型的安全检查，又可以作为成员函数。

2. 预处理宏的缺陷

  1. 预处理器宏存在问题的关键是我们可能认为预处理器的行为和编译器的行为是一样的。当然也是由于宏函数调用和函数调用在外表看起来是一样的，因为也容易被混淆。但是其中也会有一些微妙的问题出现:
  1. #define ADD(x,y) x+y
  2. inline int Add(int x,int y){
  3.     return x + y;
  4. }
  5. void test(){
  6.     int ret1 = ADD(10, 20) * 10; //希望的结果是300
  7.     int ret2 = Add(10, 20) * 10; //希望结果也是300
  8.     cout << "ret1:" << ret1 << endl; //210
  9.     cout << "ret2:" << ret2 << endl; //300
  10. }
  12. #define COMPARE(x,y) ((x) < (y) ? (x) : (y))
  13. int Compare(int x,int y){
  14.     return x < y ? x : y;
  15. }
  16. void test02(){
  17.     int a = 1;
  18.     int b = 3;
  19.     //cout << "COMPARE(++a, b):" << COMPARE(++a, b) << endl; // 3
  20.     cout << "Compare(int x,int y):" << Compare(++a, b) << endl; //2
  21. }
  22. 123456789101112131415161718192021
  1. 预定义宏函数没有作用域概念，无法作为一个类的成员函数，也就是说预定义宏没有办法表示类的范围。

3. 内联函数

1. 内联函数基本概念

  1. 在c++中，预定义宏的概念是用内联函数来实现的，而内联函数本身也是一个真正的函数。内联函数具有普通函数的所有行为。唯一不同之处在于内联函数会在适当的地方像预定义宏一样展开，所以不需要函数调用的开销。因此应该不使用宏，使用内联函数。
    1. 在普通函数(非成员函数)函数前面加上inline关键字使之成为内联函数。但是必须注意必须函数体和声明结合在一起，否则编译器将它作为普通函数来对待。
  1. inline void func(int a);
  2. 1
  1. 以上写法没有任何效果，仅仅是声明函数，应该如下方式来做:
  1. inline int func(int a){return a++;}
  2. 1
  1. 注意: 编译器将会检查函数参数列表使用是否正确，并返回值(进行必要的转换)。这些事预处理器无法完成的。
  2. 内联函数的确占用空间，但是内联函数相对于普通函数的优势只是省去了函数调用时候的压栈，跳转，返回的开销。我们可以理解为内联函数是以空间换时间。

2. 类内部的内联函数

  1. 为了定义内联函数，通常必须在函数定义前面放一个inline关键字。但是在类内部定义内联函数时并不是必须的。任何在类内部定义的函数自动成为内联函数。
  1. class Person{
  2. public:
  3.     Person(){ cout << "构造函数!" << endl; }
  4.     void PrintPerson(){ cout << "输出Person!" << endl; }
  5. }
  6. 12345
  1. 构造函数Person，成员函数PrintPerson在类的内部定义，自动成为内联函数。

3. 内联函数和编译器

  1. 内联函数并不是何时何地都有效，为了理解内联函数何时有效，应该要知道编译器碰到内联函数会怎么处理？

  2. 对于任何类型的函数，编译器会将函数类型(包括函数名字，参数类型，返回值类型)放入到符号表中。

  3. 同样，当编译器看到内联函数，并且对内联函数体进行分析没有发现错误时，也会将内联函数放入符号表。

  4. 当调用一个内联函数的时候，编译器首先确保传入参数类型是正确匹配的，或者如果类型不正完全匹配，但是可以将其转换为正确类型，并且返回值在目标表达式里匹配正确类型，或者可以转换为目标类型，内联函数就会直接替换函数调用，这就消除了函数调用的开销。

  5. 假如内联函数是成员函数，对象this指针也会被放入合适位置。

  6. 类型检查和类型转换、包括在合适位置放入对象this指针这些都是预处理器不能完成的。

  7. 但是c++内联编译会有一些限制，以下情况编译器可能考虑不会将函数进行内联编译：

    1. 不能存在任何形式的循环语句
    2. 不能存在过多的条件判断语句
    3. 函数体不能过于庞大
    4. 不能对函数进行取址操作
  8. 内联仅仅只是给编译器一个建议，编译器不一定会接受这种建议，如果你没有将函数声明为内联函数，那么编译器也可能将此函数做内联编译。一个好的编译器将会内联小的、简单的函数。

9. 函数的默认参数

  1. c++在声明函数原型的时可为一个或者多个参数指定默认(缺省)的参数值，当函数调用的时候如果没有指定这个值，编译器会自动用默认值代替。

void TestFunc01(int a = 10, int b = 20){
cout << “a + b = “ << a + b << endl;
}

//1. 形参b设置默认参数值，那么后面位置的形参c也需要设置默认参数
void TestFunc02(int a,int b = 10,int c = 10){}
//2. 如果函数声明和函数定义分开，函数声明设置了默认参数，函数定义不能再设置默认参数
void TestFunc03(int a = 0,int b = 0);
void TestFunc03(int a, int b){}

int main(){
//1.如果没有传参数，那么使用默认参数
TestFunc01();
//2. 如果传一个参数，那么第二个参数使用默认参数
TestFunc01(100);
//3. 如果传入两个参数，那么两个参数都使用我们传入的参数
TestFunc01(100, 200);

  1. return EXIT_SUCCESS;
  2. 1

}

10. 函数的占位参数

  1. c++在声明函数时，可以设置占位参数。占位参数只有参数类型声明，而没有参数名声明。一般情况下，在函数体内部无法使用占位参数。
  1. void TestFunc01(int a,int b,int){
  2.     //函数内部无法使用占位参数
  3.     cout << "a + b = " << a + b << endl;
  4. }
  5. //占位参数也可以设置默认值
  6. void TestFunc02(int a, int b, int = 20){
  7.     //函数内部依旧无法使用占位参数
  8.     cout << "a + b = " << a + b << endl;
  9. }
  10. int main(){
  12.     //错误调用，占位参数也是参数，必须传参数
  13.     //TestFunc01(10,20); 
  14.     //正确调用
  15.     TestFunc01(10,20,30);
  16.     //正确调用
  17.     TestFunc02(10,20);
  18.     //正确调用
  19.     TestFunc02(10, 20, 30);
  21.     return EXIT_SUCCESS;
  22. }
  23. 12345678910111213141516171819202122
  1. 在后面操作符重载的后置++要用到这个

11. 函数重载(overload)

1 函数重载概述

  1. 在c++中同一个函数名在不同场景下可以具有不同的含义。
  2. 在传统c语言中，函数名必须是唯一的，程序中不允许出现同名的函数。在c++中是允许出现同名的函数，这种现象称为函数重载。
    函数重载的目的就是为了方便的使用函数名。

2. 函数重载

1. 函数重载基本语法

  1. 实现函数重载的条件：
    1. 同一个作用域
    2. 参数个数不同
    3. 参数类型不同
    4. 参数顺序不同
  1. //1. 函数重载条件
  2. namespace A{
  3.     void MyFunc(){ cout << "无参数!" << endl; }
  4.     void MyFunc(int a){ cout << "a: " << a << endl; }
  5.     void MyFunc(string b){ cout << "b: " << b << endl; }
  6.     void MyFunc(int a, string b){ cout << "a: " << a << " b:" << b << endl;}
  7.     void MyFunc(string b, int a){cout << "a: " << a << " b:" << b << endl;}
  8. }
  9. //2.返回值不作为函数重载依据
  10. namespace B{
  11.     void MyFunc(string b, int a){}
  12.     //int MyFunc(string b, int a){} //无法重载仅按返回值区分的函数
  13. }
  14. 12345678910111213
  1. 注意: 函数重载和默认参数一起使用，需要额外注意二义性问题的产生。
  1. void MyFunc(string b){
  2.     cout << "b: " << b << endl;
  3. }
  4. //函数重载碰上默认参数
  5. void MyFunc(string b, int a = 10){
  6.     cout << "a: " << a << " b:" << b << endl;
  7. }
  8. int main(){
  9.     MyFunc("hello"); //这时，两个函数都能匹配调用，产生二义性
  10.     return 0;
  11. }
  12. 1234567891011
  1. 为什么函数返回值不作为重载条件呢？
    1. 当编译器能从上下文中确定唯一的函数的时，如int ret = func(),这个当然是没有问题的。然而，我们在编写程序过程中可以忽略他的返回值。
    2. 那么这个时候,假如一个函数为 void func(int x);另一个为int func(int x);
    3. 当我们直接调用func(10),这个时候编译器就不确定调用那个函数。所以在c++中禁止使用返回值作为重载的条件。

2. 函数重载实现原理

  1. 编译器为了实现函数重载，编译器用不同的参数类型来修饰不同的函数名，比如void func(); 编译器可能会将函数名修饰成_func，当编译器碰到void func(int x),编译器可能将函数名修饰为func_int,当编译器碰到void func(int x,char c),编译器可能会将函数名修饰为_func_int_char
  2. 不同的编译器可能会产生不同的内部名。
  1. void func(){}
  2. void func(int x){}
  3. void func(int x,char y){}
  4. 123
  1. 以上三个函数在linux下生成的编译之后的函数名为:
  1. _Z4funcv //v 代表void,无参数
  2. _Z4funci //i 代表参数为int类型
  3. _Z4funcic //i 代表第一个参数为int类型，第二个参数为char类型
  4. 123

3. extern “C”浅析

  1. 以下在Linux下测试:

    1. c函数: void MyFunc(){} ,被编译成函数: MyFunc
    2. c++函数: void MyFunc(){} ,被编译成函数: _Z6Myfuncv

  2. 由于c++中需要支持函数重载，所以c和c++中对同一个函数经过编译后生成的函数名是不相同的，这就导致了一个问题.

  3. 如果在c++中调用一个使用c语言编写模块中的某个函数，那么c++是根据c++的名称修饰方式来查找并链接这个函数，那么就会发生链接错误，以上例，c++中调用MyFunc函数，在链接阶段会去找Z6Myfuncv，结果是没有找到的，因为这个MyFunc函数是c语言编写的，生成的符号是MyFunc。

  4. 那么如果想在c++调用c的函数怎么办？

    1. extern “C”的主要作用就是为了实现c++代码能够调用其他c语言代码。加上extern “C”后，这部分代码编译器按c语言的方式进行编译和链接，而不是按c++的方式。