【C++学习手札】-引用与内联函数以及C++中对const拓展详解（超详细！）

                                      食用指南：本文在有C基础的情况下食用更佳

                                      这就不得不推荐此专栏了：C语言

                                      内联函数前置知识：宏函数

                                      ♈️今日夜电波：Episode 33—She Her Her Hers

                                                               1:11 ━━━━━━️──────── 4:17
                                                                           ◀️   ⏸   ▶️    ☰

                                     关注点赞收藏您的每一次鼓励都是对我莫大的支持

---

一、C++中的const

        C语言中的const

        1、const修饰全局变量num 变量名只读 内存空间在文字常量区（只读）、不能通过num的地址修改空间内容。
        2、const修饰局部变量data 变量名只读 内存空间栈区（可读可写），可以通过data地址 间接的修改空间内容。

        栗子：

extern const int num;//用于外部其他文件num的声明

const int sum = 100;//只读的全局变量 内存放在文字常量区（内存空间只读）

void text()
{
	const int dat = 100;//局部只读变量 内存在栈区（内存可读可写）

		//内存可读可写的例子：
	int* p = (int*) & dat;

	*p = 200;//此处就将dat修改为200
}

        C++中的const

        首先，我们先理解一个符号表的概念，符号表是一个用于存储程序中所有变量、函数和其他标识符信息的数据结构。它包含了每个标识符的名称、类型、作用域和存储位置等信息。他在编译和链接过程中起到了关键的作用。

        而我们在C++中使用const定义变量时，这个变量可以看成是一个常量，如果他是一个基础的类型，系统不会给他开辟空间而是会把先放入到符号表当中，在对这个数据取地址时，系统才会给他开辟空间。是不是很绕口？请看下面这个图你就明白了。

         对此，你对const定义的基础类型存放有了一定的了解，请继续看下面这个例子！

	//1、c++中 对于基础类型 系统不会给dat开辟空间 dat放到符号表中
	const int dat = 10;
	//dat = 100;//err 只读
	cout << "dat = " << dat << endl;
	//2、c++中当 对dat 取地址的时候 系统就会给dat开辟空间
	int* p = (int*)&dat;
	*p = 200;
	cout << "*p = " << *p << endl;//空间内容修改成功 200

	cout << "dat = " << dat << endl;//data 还是10为啥？

        很明显的看到，正如上面所写道的，改变*p并不会改变dat的值，改变的是所开辟的空间内存的值！

        注意：上面所述都是在const修饰为基础类型的情况下的！

        那在其他情况下又会如何呢？

        在C++中，当 以变量的形式 初始化 const修饰的变量 系统会为其开辟空间 或者 自定义数据类型(结构体、对象)  系统会分配空间！

        栗子：

struct Person
{
    int num;
	char name[32];
};

void test4()
 {
	
	//3、当以变量的形式 初始化 const修饰的变量 系统会为其开辟空间
	int b = 200;
	const int a = b;//系统直接为a开辟空间 而不会把a放入符号表中
	int *p = (int*)&a;
	* p = 3000;
	cout << "*p = " << *p << endl;//3000
	cout << "a = " << a << endl;//3000
	
	//4、const 自定义数据类型(结构体、对象) 系统会分配空间
	const Person per = { 100,"lucy" };
	//per.num = 1000;//err
	cout << "num = " << per.num << ", name = " << per.name << endl;//100 lucy
	Person * p1 = (Person*)&per;
	p1-> num = 2000;
	cout << "num = " << per.num << ", name = " << per.name << endl;//2000 lucy
}

---

二、引用 

        什么是引用？

        引用可以用于访问已存在的变量或对象。通过引用，可以通过不同的名称访问同一个变量，而不是创建副本。引用通常用于函数参数传递和函数返回值。说白了就是给已有变量取个别名。

        引用的结构：

        &和别名 结合 表示引用

         一个简单的栗子：

int num = 10;

int &a = num;

        注意：这里的&不是表示取地址，而是引用的标志。

        几个需要注意的规则：

                1、给某个变量取别名 就定义某个变量
                2、从上往下替换

                3、引用必须初始化
                4、引用一旦初始化 就不能再次修改别名

        栗子：

void test5()
{
	int a = 20;
	int& b = a;
	
	cout << "a=" << a << endl;
	b = 200;
	cout << "b= " << b << endl;

	cout << "a地址：" << &a << endl;
	cout << "b地址：" << &b << endl;

}

                        

        由此可见a就是b，b就是a，b只不过是a的另外一个名字。 

引用的定义模板（如有错误，请踢一脚作者）

要取别名的类型（ &（原来变量名的位置，直接替换别名））巴拉巴拉 = 要取别名的变量

        引用-数组

void test6()
 {
 int arr[5] = {10,20,30,40,50};
 //需求：给arr起个别名
 int (&my_arr)[5] = arr;//my_arr就是数组arr的别名

 int i=0;

 for(i=0;i<5;i++)
 {
  cout<

 引用在函数中的应用

        作为参数

void swap(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

void swap2(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}

void test7()
{
	int n1 = 114, n2 = 514;
	//swap(&n1, &n2);
	swap2(n1, n2);//swap==swap2

	cout << "n1=" << n1 << " n2=" << n2 << endl;//n1=514 n2=114
}

        作为返回值

//引用作为函数的返回值类型
 int& my_data(void)
 {
 int num = 100;
 return num;//err 函数返回啥变量 引用就是该变量的别名
 //函数的返回值是引用时 不要返回局部变量
 }

int& my_data1(void)
 {
 static int num = 200;
 return num;//ok
 }
 void test8()
 {
 //ret是别名 ret是num的别名
 int &ret = my_data();
 //cout<<"ret = "<常引用 
  
        ->常量的引用
 
  
void test9()
 {
 //给常量10取个别名 叫num
 //int &针对的是int ，10是const int类型
 //const int 针对的是const int, 10是const int类型
 const int &num = 10;

 cout<<"num = "<
 
  
引用的本质 
 
  
        引用的本质在 c++内部实现是一个指针常量。
 
  
        Type& ref = val; // Type* const ref =&val;
         c++编译器在编译过程中使用常指针作为引用的内部实现， 因此引用所占用的空间
 大小与指针相同， 只是这个过程是编译器内部实现， 用户不可见。
 
  
 
  
三、内联函数
 
  
         内联函数前置知识：宏函数
 
  
        宏函数（带参数的宏）的缺点：
         第一个在c中也会出现，宏看起来像一个函数调用，但是会有隐藏一些难以发现的错误。
 第二个问题是c++特有的，预处理器不允许访问类的成员，也就是说预处理器宏不能用作类
 的成员函数。
 
  

         内联函数：
 
  
        内联函数为了继承宏函数的效率，没有函数调用时开销，然后又可以像普通函数那样，可以进行参数，返回值类型的安全检查，又可以作为成员函数。内联函数是一个真正的函数。函数的替换 发生在编译阶段。
 
  
        任何在类内部定义的函数自动成为内联函数。
 
  
        注意：内联仅仅只是给编译器一个建议， 编译器不一定会接受这种建议， 如果你没有将函
 数声明为内联函数， 那么编译器也可能将此函数做内联编译。 一个好的编译器将会
 内联小的、 简单的函数。
 
  
        总的来说：内联函数是宏函数的优化！
 
  
        栗子：
 
  
 #define SUB(x,y) x-y

inline int sub(int x, int y) {
	return x - y;
}

void test10()
{
	cout << "(define)x-y= " << SUB(5, 1) << endl;//(define)x-y= 4

	cout << "(inline)x-y= " << sub(5, 1) << endl;//(inline)x-y= 4
}
 
  
        这样看起来内联函数是不是同宏函数一模一样呢？请看下面这个例子：
 
  
#define MUT(x,y) x*y

inline int mut(int x, int y) {
	return x * y;
}

void test10()
{
	cout << "(define)x-y= " << MUT(5-2, 2) << endl;// 5-2*2

	cout << "(inline)x-y= " << mut(5-2, 2) << endl;// 3*2
}
 
  
 
  
        实际上，我们是可以将内联函数看作普通的函数的，但是内联函数有以下几个限制条件：
  
 
  
不能是内联函数的情况
 
  
        1、 函数包含静态变量。
 
  
        2、for、while带有循环形式的函数。
 
  
        3.、递归调用本身的函数。
 
  
        4、包含复杂语句的函数。
 
  
        5、函数体不能过于庞大 不能对函数进行取址操作
 
  
        6、不能存在过多的条件判断语句。
  
 
  
 
  
                感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！
 
  
                             
 
  
                                                                给个三连再走嘛~