• 【探索C++】C++对C语言的扩展

    一、 引用

    1. 变量名         

            变量名本质上就是一段连续内存空间的名字，相当于一个标记，可以用变量名来申请并命名内存空间，可以借助变量名来使用这个空间。

    int a = 10; // 声明一个整数变量a，分配内存空间

    2. 引用的概念

            变量名本身为一块内存的引用，C++中的引用其实就是给一个已有的变量再取一个别名（alias）。

    int x = 5; int &y = x; // 创建y作为x的引用

    3. 语法格式

    变量名
类型 &引用名 = 变量名

float f = 3.14;
//取别名的方式，给变量f取一个别名叫a
float &a = f;

    4. 规则

            （1）引用没有定义，只是一种关系类型声明，所以不分配内存，声明它和原有某一变量的关系，所以类型要保持一致；

            （2）声明时必须初始化，一经声明，不可更改；

            （3）可以对引用再次进行引用；

            （4）只有&前面有类型时，是引用，若没有类型，则是其他意思。

    5. 引用作为函数参数

            普通引用在声明的时候必须用其他变量进行初始化，但是作为函数形参的时候，不需要进行初始化（因为这个初始化过程在函数调用的时候）实参给形参做初始化。

    1. void func(int &a)
    2. {
    3.     cout << "a = " << a << endl;
    4. }

    6. 引用作为函数返回

            引用作为函数返回的时候，可以将这个函数作为赋值运算的左值（结果为赋值运算的值），需要保证函数返回的引用空间在函数退出的时候，没有被释放（全局变量，堆空间数据，静态局部变量，传入的指针数据）。

    1. int &func(int &a)
    2. {
    3.     return a;
    4. }
    5.  
    6. int main(int argc, char const *argv[])
    7. {
    8.     int a = 200;
    9.     int b = func(a);
    10.     //int b = func(a) = 300;  //可以作为左值
    11.     cout << b << endl;
    12.     
    13.     return 0;
    14. }

    7. 引用的意义

            （1）在很多时候引用可以代替指针使用；

            （2）引用在函数传参的使用中对于指针具有更好的可读性和实用性。

    8. 引用的本质         

            引用在C++中的内部实现是一个常指针：type &name <====> type * const name。

            C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。 从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间，这是C++为了实用性而做出的细节隐藏。

    9. 指针引用

    1. void func1(int *&a)
    2. {
    3.     a[2] = a[0] + a[4];
    4.  
    5. }
    6.  
    7.  
    8.  
    9. int main(int argc, char const *argv[])
    10. {
    11.     int *p = new int[5]{10,20,30,40,50};
    12.     
    13.     func1(p);
    14.     
    15.     for (int i = 0; i < 5; ++i)
    16.     {
    17.         cout << p[i] << " ";
    18.     }
    19.     cout << endl;
    20.     
    21.     return 0;
    22. }

    10. const引用

    const引用的特征

    • const引用有较多使用，它可以防止对象的值被随意更改。
    • const对象的引用必须是const的，将普通引用绑定到const对象是不合法的。
    1. const int a = 20;
    2. // int &b = a;    //不合法的
    3. const int &b = a;
    • const引用可以使用相关类型的对象（常量，非同类型的变量或表达式）初始化，这个是const引用与普通引用最大的区别。
    1. int &m = 20;    //不合法的
    2. const int &m = 20;

    （1）const引用的原理：        

            const引用的目的是禁止通过修改引用的值来改变被引用的对象。const引用的初始化特性较为微妙，可以看如下代码：

    1. double d = 20.34;
    2. const int &a = d;
    3. double &b = d;
    4.  
    5. cout << a << " " << b << endl;
    6. d = 23.34;
    7. cout << a << " " << b << endl;

            输出结果为：

    1. 20 20.34
    2. 20 23.34

            实际上，const引用使用相关类型对象初始化时发生如下过程：

    1. double d = 20.34;
    2. const int &a = d;
    3. //int tmp = d;
    4. //const int &a = tmp;

    二、 默认参数和占位参数

    1. 默认参数

            通常情况下，函数在调用的时候，形参从实参那里取得值，对于多次调用同一函数同一实参时，C++给出了更简单的处理方法，给形参给默认值，这样就不用从实参哪里取值了。

    默认参数规则：

            （1）只有参数列表的后面部分才可以提供默认参数（从右往左依次带默认参数）。

            （2）一旦在一个函数调用中开始使用默认参数值，那么这个参数后的所有参数都必须使用默认参数值。

    1. //int add(int a = 10, int b, int c = 100)    //语法错误，不能跳着带默认参
    2. //int add(int a = 10, int b, int c)    //语法错误，不能从左开始带默认参
    3. int add(int a, int b, int c = 100)    //形参带默认参数
    4. {
    5.     return a+b+c;    
    6. }
    7.  
    8.  
    9. int main(int argc, char const *argv[])
    10. {
    11.     cout << add(10, 20, 30) << endl;
    12.     
    13.     return 0;
    14. }

    2. 占位参数

            占位参数只有类型声明，没有参数名声明。占位参数在函数里面不能使用，为了以后函数做拓展留下线索。

    1. /占位参数在函数里面能不能使用？不能使用
    2. //占位参数为了以后函数做拓展留下线索
    3. int add(int a, int b, int c, int = 0)    //形参带占位参数，占位参数还带有默认参数
    4. {
    5.     
    6.     return a+b+c;
    7. }
    8.  
    9. //int add(int a, int b, int = 0, int c = 0)
    10. //占位参数，占位参数可以跟默认参数一起结合使用，前提是默认参要从右到左依次赋值
    11.  
    12. //int add(int a, int b, int, int c)
    13. //占位参数可以放在任意位置
    14.  
    15.  
    16.  
    17. int main(int argc, char const *argv[])
    18. {
    19.     cout << add(10, 20, 30, 40) << endl;
    20.     
    21.     return 0;
    22. }

    三、C++函数重载

    1. 函数重载

            函数重载是C++中一种允许你使用相同的函数名定义多个不同参数列表的函数的机制。函数重载的规则如下：

    • 函数名相同；
    • 参数列表不同，可以通过参数个数、参数类型和参数顺序的不同来区分；
    • 返回类型不同的函数不能构成重载。

    以下是一些函数重载的示例（这些函数都具有相同的名称func，但参数列表不同，因此构成了函数重载）：

            void func(int a) {}

            void func(float f) {}

            void func(int a, float f) {}

            void func(float a, float f) {}

            void func(float a, int f) {}

            void func(double a, char f) {}

            void func(float a, char f, int m) {}

            int func(char a, char f) {}

    2. 调用准则

            当调用重载函数时，编译器会根据传递的参数选择最匹配的函数。它会按照以下准则来寻找可行的候选函数：

            （1）严格匹配，找到则调用；

            （2）通过隐式类型转换技术寻找匹配的函数，找到则调用；

            （3）一个函数不能即做重载，又作默认参数的函数，当你少写一个参数时，系统无法确认是重载函数默认参数。

    3. 函数重载与函数指针结合

            函数指针可以指向不同参数列表的函数，但在赋值时要注意确保参数匹配。示例：

    1. typedef void (*FUNC1)(int, int, int);
    2. typedef void (*FUNC2)(int, int);
    3.  
    4. int main() {
    5.     FUNC1 p1 = func; // 调用func(int, int, int)
    6.     FUNC2 p2 = func; // 调用func(int, int)
    7.     
    8.     p1(10, 20, 30);
    9.     p2(10, 20);
    10.     
    11.     return 0;
    12. }

    4. 函数重载总结

            函数重载是C++中的一种强大机制，它允许定义多个具有相同名称但参数列表不同的函数。以下是一些函数重载的总结：

    • 函数名相同，参数列表不同即可构成重载；
    • 函数返回值不能作为函数重载的依据；
    • 编译器根据传递的参数选择最匹配的函数。

    四、运算符重载

            运算符重载是C++中另一个强大的特性，它允许你自定义数据类型的运算符行为。通过运算符重载，你可以使自定义类型像内置类型一样参与各种运算。

    1. 运算符重载的基本原理

            运算符重载的基本原理是为自定义类型定义与运算符相关的函数。例如，如果你想要为自定义的Complex类实现+运算符，可以这样做：

    1. class Complex {
    2. public:
    3.     Complex operator+(const Complex& other) {
    4.         Complex result;
    5.         result.real = this->real + other.real;
    6.         result.imag = this->imag + other.imag;
    7.         return result;
    8.     }
    9. private:
    10.     double real;
    11.     double imag;
    12. };

    2. 运算符重载的示例

    1. class Complex {
    2. public:
    3.     Complex operator+(const Complex& other) {
    4.         Complex result;
    5.         result.real = this->real + other.real;
    6.         result.imag = this->imag + other.imag;
    7.         return result;
    8.     }
    9.     
    10.     bool operator==(const Complex& other) {
    11.         return (this->real == other.real) && (this->imag == other.imag);
    12.     }
    13.     
    14.     Complex operator*(const Complex& other) {
    15.         Complex result;
    16.         result.real = this->real * other.real - this->imag * other.imag;
    17.         result.imag = this->real * other.imag + this->imag * other.real;
    18.         return result;
    19.     }
    20.     
    21.     // 其他运算符重载也可以类似定义
    22. private:
    23.     double real;
    24.     double imag;
    25. };

    3. 运算符重载的使用

            运算符重载使自定义类型的对象可以像内置类型一样使用运算符。例如：

    1. Complex c1(1.0, 2.0);
    2. Complex c2(3.0, 4.0);
    3. Complex c3 = c1 + c2; // 使用+运算符重载
    4. bool isEqual = (c1 == c2); // 使用==运算符重载
    5. Complex c4 = c1 * c2; // 使用*运算符重载

    五、命名空间

    1.概念

            所谓namespace，是指标识符的各种可见范围，C++标准程序库当中所有的标识符都被定义在一个名为std的namespace中。

    （1）和

            格式不一样，前者没有后缀，实际上，在你的编译器include文件夹里面可以看到，二者是两个文件，打开文件就会发现，里面的代码是不一样的，后缀为.h的头文件C++标准已经明确提出不支持了，早些的实现将标准库功能定义在全局空间里，声明在带.h的后缀文件里，C++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h，因此：

            当使用时，相当于在C中调用库函数，使用的是全局命名空间；

            当使用时，该文件没有定义全局命名空间，必须使用using namespace std；这样才能正确使用cin，cout。

    （2）由于namespace的概念，使用C++标准程序库中的任何标识符是，可以有三种选择：

    用法1：在用的时候加上std:: 比较麻烦

            int a; std::cin >> a; // std::cout << a << std::endl; //

    用法2：用的时候打开一部分，建议用的，安全性，命名空间的污染度不高

            using std::cin; using std::cout; using std::endl;

    用法3：直接打开全部的，不安全，容易造成命名空间污染，出现重复定义，多次引用，解释如下：

            using namespace std;

            因为标准库非常的庞大，所以程序员在选择的类的名称或函数名 时就很有可能和标准库中的某个名字相同。所以为了避免这种情况所造成的名字冲突，就把标准库中的一切都被放在名字空间std中。但这又会带来了一个新问 题。无数原有的C++代码都依赖于使用了多年的伪标准库中的功能，他们都是在全局空间下的。所以就有了 和等等这样的头文件，一个是为了兼容以前的C++代码，一个是为了支持新的标准。命名空间std封装的是标准程序库的名称，标准程序库为了和以前的头文件区别，一般不加".h"

    2. C++命名空间定义以及使用方法


            在C++中，名称可以是符号常量，变量，宏，函数，枚举，类和对象等等，为了避免在大规模程序的设计中，以及在程序员在使用各种的C++库时，这些标识符的命名发生冲突。
            标准C++引入了关键字namespace（命名空间/名字空间/名称空间/名域），可以更好地控制标识符的作用域。
            std是C++标准命名空间，C++标准程序库中所有标识符都被定义在std中，比如标准库中的类iostream、vector、map等都定义在该命名空间中，使用时要加上using声明（using namespace std）或者using指示（using std::cin using std::cout using std::endl using std::vector  std::map...）

    C中的命名空间：
            在C语言中只有一个命名空间，全局作用域
            C语言中所有的全局标识符共享同一个作用域
            标识符之间可能发生冲突
    C++中的命名空间：
            命名空间将全局作用域分成不同的部分
            不同命名空间中的标识符可以同名而且不会发生冲突
            命名空间可以相互嵌套
            全局作用域也叫做默认命名空间

    （1）C++命名空间的定义
    1. namespace name {...}
    2. namespace {...}        //匿名命名空间，里面的内容只能在当前文件使用
    （2）C++命名空间的使用
    1. namespace A{int n;}
    2. 1、直接全部（打开）放出来       using namespace A;
    3. 2、只打开一部分                using A::n;
    4. 3、用到谁就使用谁              A::n;
    5.  
    6. namespace {int n}
    7. 使用默认匿名空间里面的变量      ::n
    8. 默认情况下，可以直接使用默认命名空间里面的所有标识符

    3. C++命名空间代码实现

    1. #include <iostream>
    2.  
    3. using namespace std;
    4.  
    5. namespace A
    6. {
    7.     int a;
    8. }
    9.  
    10. namespace B
    11. {    
    12.     int a;
    13.     int b;
    14.     int c;
    15.     namespace C     //可以嵌套命名空间
    16.     {
    17.         char name[20];
    18.     }
    19.     struct Stu         //可以嵌套结构体
    20.     {
    21.         int num;
    22.     }d;
    23.     void func(){cout << "123456" << endl;}        //可以嵌套函数
    24. }
    25.  
    26. namespace     //匿名命名空间，简单点来讲就是全局命名空间
    27. {
    28.     int a;
    29.     int b;
    30. }
    31.  
    32. namespace     //匿名命名空间可以定义两个，但是里面不用出现相同的标识符
    33. {    
    34.     int d;    
    35. }
    36.  
    37. //1、直接全部打开，全部裸露出来，但是会造成命名空间污染，不建议
    38. // using namespace B;
    39. // using namespace B::C;
    40.  
    41. //2、只放出一部分
    42. using B::c;
    43. // using B::C::name;
    44.  
    45. int main(int argc, char const *argv[])
    46. {
    47.     a = 200;    //默认情况下，可以直接使用默认命名空间里面的所有标识符
    48.     cout << "a = " << a << endl;
    49.     
    50.     ::b = 300;    //使用匿名命名空间里面的标识符
    51.     cout << "b = " << ::b <<  endl;
    52.     
    53.     c = 300;
    54.     cout << "c = " << c << endl;
    55.     
    56.     //3、直接用命名空间::成员名
    57.     B::func();
    58.     
    59.     cin >> B::C::name;
    60.     cout << B::C::name << endl;
    61.         
    62.     return 0;
    63. }

    4. 总结

            引入命名空间：在使用某个命名空间中的成员之前，通常需要引入该命名空间。可以使用 using namespace name 来引入整个命名空间，也可以使用 using name::member 来引入特定的成员。

            命名空间的使用：在C++中，等标准库头文件通常没有定义在全局命名空间中，因此使用其中的成员时，需要使用 using namespace std; 或者在使用时前缀以 std::，例如 std::cout。

            头文件命名规范：为了与C语言区分开，C++标准规定头文件不使用后缀 .h，而是直接使用不带后缀的文件名。

            命名空间的定义：命名空间的定义使用 namespace name {...} 的形式，其中 name 是命名空间的名称，而 {...} 内包含了该命名空间的成员。

            命名空间的嵌套：C++允许嵌套命名空间，这意味着你可以在一个命名空间内再定义另一个命名空间，从而更好地组织和管理代码。

            命名空间是C++中用于避免命名冲突和组织代码的有用工具，它有助于将代码模块化，使代码更具可维护性和可读性。熟练掌握命名空间的使用是C++编程的重要一步。

    六、内敛函数

            C++提供了内联函数（inline functions）这一重要特性，它可以帮助程序员优化代码执行效率，减少函数调用的开销。本文将详细介绍内联函数的特点、使用场景以及与宏替换的区别，帮助你更好地理解和利用这一功能，从而实现了真正的内嵌。

    1. #include <iostream>
    2.  
    3. using namespace std;
    4.  
    5. inline void func(int a)    //内敛函数   
    6. {
    7.     cout << "a = " << a << endl;
    8. }
    9.  
    10. int main(int argc, char const *argv[])
    11. {
    12.     func(100);    //调用函数有 保护现场 和 恢复现场 这两个过程
    13.     // {
    14.     //     cout << "a = " << a << endl;
    15.     // }
    16.     
    17.     return 0;
    18. }

    1.内联函数特点

            （1）内联函数使用 inline 关键字声明，通常与函数定义结合在一起；
            （2）内联函数的代码被编译器直接插入到函数调用的地方，类似于宏替换，减少了函数调用的开销；
            （3）内联函数具有普通函数的特征，包括参数检查和返回类型。


    2. 内联函数的优点

            （1）提高程序运行效率，减少了函数调用时的入栈和出栈操作；
            （2）内联函数可以作为类的成员函数，可以访问所在类的保护成员和私有成员。


    3. 内联函数的限制

            （1）内联函数的函数体应该相对较小，避免过于复杂的代码；
            （2）不适合包含循环或大量条件判断的函数体；
            （3）不能对内联函数进行取址操作。


    4.内联函数与宏替换的区别

            （1）内联在编绎时展开，宏在预编译时展开。 展开的时间不同。

            （2）编译内联函数可以嵌入到目标代码，宏只是简单文本替换。

            （3）内联会做类型，语法检查，而宏不具这样功能。

            （4）宏不是函数，inline函数是函数

            （5）宏定义小心处理宏参数（一般参数要括号起来），否则易出现二义性，而内联定义不会出现。

    1. #include <iostream>
    2.  
    3. using namespace std;
    4.  
    5. #define SQ(x) ((x)*(x))
    6.  
    7. inline int sq(int x)
    8. {
    9.     return x*x;
    10. }
    11.  
    12.  
    13. int main(int argc, char const *argv[])
    14. {
    15.     int i = 0;
    16.     for (int i = 0; i < 5; ++i)
    17.     {
    18.         // cout << sq(i+1) << endl;//1 4 9 16 25
    19.         cout << SQ(i+1) << endl;// 1 4 9 16 25
    20.     }
    21.     
    22.     return 0;
    23. }


    5.适用场景

            （1）内联函数适用于函数体相对简单且被频繁调用的情况；
            （2）当函数体较大或包含复杂的逻辑时，内联可能不会带来明显的性能提升；
            内联函数是C++中一种用于提高程序性能的重要技术，但需要注意适用场景和代码复杂度，以充分发挥其优势。熟练使用内联函数可以有效地减少函数调用带来的开销，提高程序的运行效率。

    七、C++头文件和extern "C"

    （1）标准C++的头文件引用

    #include //C++的标准输入输出头文件

    （2）如果要在C++程序里面用标准C的头文件

    1. //#include <stdio.h>
    2. //#include <stdlib.h>
    3. #include  <cstdio>
    4. #include  <cstdlib>

            注意：不是所有的.h的头文件都是以c开头，去.h尾。

    （3）使用C语言的相关函数的时候，头文件的引用方式

    1. extern "C"
    2. {
    3.     #include     
    4.     #include       
    5.     #include 
    6.     #include 
    7.     #include 
    8. }

            写一个练习吧：设计一个计算圆柱体体积的函数，表面积函数，P值和圆柱体的高都有默认参数。

    1. #include <iostream>
    2.  
    3. using namespace std;
    4.  
    5. void func1(int r, int h = 10, float PI = 3.14)	//计算圆柱体体积
    6. {
    7. 	cout << "圆柱体的体积：" << r*r*PI*h << endl;
    8. }
    9.  
    10. void func2(int r, int h = 10, float PI = 3.14)	//计算圆柱体表面积
    11. {
    12. 	cout << "圆柱体的表面积：" << (2*r*r*PI)+(2*PI*r*h) << endl;
    13. }
    14.  
    15. int main(int argc, char const *argv[])
    16. {
    17. 	cout << "输入圆柱体的半径跟高" << endl;
    18. 	int r, h;
    19. 	cin >> r >> h;
    20. 	if (h > 0)
    21. 	{
    22. 		func1(r, h);
    23. 		func2(r, h);
    24. 	}
    25. 	else
    26. 	{
    27. 		func1(r);
    28. 		func2(r);
    29. 	}
    30.  
    31. 	return 0;
    32. }

            更多C/C++语言、Linux系统、数据结构和ARM板实战相关文章，关注专栏：

       手撕C语言

                玩转linux

                        脚踢数据结构

                                系统、网络编程

                                         探索C++

                                                 6818（ARM）开发板实战

    📢写在最后

    • 今天的分享就到这啦~
    • 觉得博主写的还不错的烦劳 一键三连喔~
    • 🎉🎉🎉感谢关注🎉🎉🎉
  • 相关阅读:
    Linux网络编程：详解https协议
    基于低代码平台的疫情管理系统，源码交付更放心
    10 个解放双手的 IDEA插件，少些冤枉代码（第三弹）
    中台深入剖析和实现技巧
    硅芯思见：SystemVerilog中枚举类型的一些“不正经”用法
    3个月测试员自述：4个影响我职业生涯的重要技能
    人工智能--机器学习概述、motplotlib的使用-折线图、散点图、柱状图、饼图
    vue3使用tsx自定义弹窗组件
    用Rust开发一个类似SQL Server的数据库系统的步骤和关键技术
    C++ Reference: Standard C++ Library reference: C Library: cstdio: ungetc
  • 原文地址：https://blog.csdn.net/qq_64928278/article/details/133044833