【C ++】C++入门知识（二）

ゞ浴缸里的玫瑰 2024-03-26 12:45 19阅读 0赞

## C++入门（二） ##

> 作者：小卢  
> 专栏：《C++》  
> **喜欢的话：世间因为少年的挺身而出，而更加瑰丽。 ——《人民日报》**

### 1.引用 ###

#### 1.1.引用的概念及应用 ####

引用（&）

引用不是新定义一个变量，而是给已存在变量取了一个别名

它和它引用的变量共用同一块内存空间

**类型& 引用变量名(对象名) = 引用实体；**

**引用在定义时，必须初始化**

**一个变量可以多次引用**

#### 1.2.传值返回和传址返回和传引用返回的底层原理： ####

int Cout()
    {
        
    	int n = 0;
    	n++;
    	return n;
    }
    int main()
    {
        
    	int ret = Cout();
    	return 0;
    }

n是如何传给ret的呢？

因为这里的n没有用static修饰，为临时变量，Cout函数调用时开辟了一段栈帧，n存在于这段栈帧内。但函数调用结束后，栈帧销毁。

n可以传过去是因为，函数栈帧结束前用了一个临时变量=n，然后用这个临时变量来作为返回值给ret。

这个临时变量应该内存比较小的时候，是用寄存器。

int Cout()
    {
        
    	static int n = 0;
    	n++;
    	return n;
    }
    int main()
    {
        
    	int ret = Cout();
    	return 0;
    }

这种情况下，n在静态区，这里n还是用一个临时变量来作为中间段，来进行返回值。

**这种情况有优化的空间：**

这种返回类型为传值返回。那如果用传引用返回呢？

这种就是利用一些变量出了作用域过后还存在的情况，例如：引用，malloc…

int& Cout()
    {
        
    	static int n = 0;
    	n++;
    	return n;
    }
    int main()
    {
        
    	int ret = Cout();
    	return 0;
    }

引用返回的好处：  
**1.减少拷贝**  
**2.调用者可以修改返回对象**

//引用返回
    //1.减少拷贝
    //2.调用者可以修改返回对象
    #define N 10
    typedef struct Array
    {
        
    	int a[N];
    	int size;
    }AY;
    int& PostAt(AY& ay, int i)
    {
        
    	assert(i < N);
    	return ay.a[i];
    }
    int main()
    {
        
    	//int ret = Cout();
    	AY ay;
    	for (int i = 0; i < N; i++)
    	{
        
    		PostAt(ay, i) = i * 10;
    	}
    	for (int i = 0; i < N; i++)
    	{
        
    		cout << PostAt(ay, i) << " ";
    	}
    	cout << endl;
    	return 0;
    }

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;
    	//ret为随机值
    	return 0;
    }

这里ret为随机值，这里c返回的是一个别名，相当于返回的是一个c的别名，ret就是c的别名。

int main()
    {
    	int a = 1;
    	int& b = a;
    	//指针和引用，赋值/初始化，权限可以缩小，但不可以放大
    	const int c = 2;
    	int& d = c;
    	return 0;
    }

**指针和引用，赋值/初始化，权限可以缩小，但不可以放大**

#### 1.3.指针和引用的区别： ####

**从语法角度：引用是不开辟空间的，指针需要开辟空间**

**从底层角度：两种都是一样的**

### 2.内联函数 ###

#### 2.1.宏的缺点： ####

**1.不能调试**

**2.没有类型安全的检查**

**3.有些场景下非常复杂**

#define ADD(x,y) ((x)*(y))//正确的宏函数
    	//宏不是传参，而是替换
    #define ADD(x,y) (x)*(y)///((a | b)* (a & b)),错误
    #define ADD(x,y) (x*y)///(5+10*6+20)，错误
    #define ADD(x,y) x*y
    //5+10*6+20=85，错误，替换可能会造成运算过程出错
    int main()
    {
        
    	ADD(1, 2);
    	//宏不是传参，而是替换
    	int a = 1, b = 2;
    	ADD(a| b, a & b); ///(a | b* a & b)
    	return 0;
    
    }

这里宏是替换而不是传值，它不会检查替换的值，像(a | b+ a & b)就会错误

**使用宏函数，需要尽量加括号，很容易错。**

#### 2.2.内联函数 ####

inline int Add(int x, int y)
    {
        
    	int z = x + y;
    	return z;
    }
    int main()
    {
        
    	int ret = Add(1, 2);
    	cout << ret << endl;
    	return 0;
    }

![在这里插入图片描述][bb153858fc284f228056852c5f5c0bfb.png]

release中没有call Add，减少了函数调用时栈帧的开辟

效率提高，并且可以调试，很好的替代了宏

inline内联函数是一种以空间换时间的情况，这里的空间指的是编译的指令，不是内存

// F.h
    #include <iostream>
    using namespace std;
    inline void f(int i);
    // F.cpp
    #include "F.h"
    void f(int i)
    {
        
    cout << i << endl;
    }
    // main.cpp
    #include "F.h"
    int main()
    {
        
    f(10);
    return 0;
    }

这里会出现链接错误：  
![在这里插入图片描述][9a08a64bf4524d3eb26278546d37e5da.png]

**内联函数不建议定义和实现分离！**

当定义和实现分别在.c文件和.h文件中时：程序运行时，当程序运行时，main函数编译到f（10）的地方，会优先编译函数定义并不会链接，而在链接过程中，通过头文件找到函数调用

当f为内联函数时，内联函数是在编译过程完成编译的，因此系统就会认为f（）是一个内联函数，所以不会将其链接，所以就会出现链接错误。

### 3.auto关键字 ###

#include <iostream>
    using namespace std;
    int main()
    {
        
    	int a = 0;
    	auto b = a;
    	auto c = &a;
    	//typeid(变量名).name()可以获取变量的实际类型
    	cout << typeid(b).name() << endl;//int
    	cout << typeid(c).name() << endl;//int*
    	return 0;
    }

#### 3.1auto的好处 ####

std::map<std::string, std::string>dict;
    	std::map<std::string, std::string>dit=dict;
    	//上一行和下一行是一样的，这就是auto的实际好处
    	auto dit = dict.begin();

#### 3.2typedef的缺点： ####

typedef char* pstring;
    int main()
    {
        
    	const pstring p1;//编译是否成功
    	const pstring* p2;//编译是否成功
    	//p1失败，p2成功
    	return 0;
    }

p1：实际上使用typedef后，const pstring p1会变成char\* const p1

这里const修饰的是p1，而这样的p1只有一次初始化的机会，因此必须初始化。

### 4.范围for ###

自动依次取数组中数据赋值给e对象，自动判断结束

for循环后的括号由冒号“ ：”分为两部分：

第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

int array[] = {
         1,2,3,4,5,6,6,4 };
    	for (int i = 0; i < sizeof(array) / sizeof(int); i++)
    	{
        
    		cout << array[i] << " ";
    	}
    	cout << endl;
    	//范围for --语法糖
    	for (auto e : array)
    	{
        
    		cout << e << " ";
    	}//两种结果一样
    	cout << endl;

### 5.nullptr ###

void f(int)
    {
        
    	cout << "f(int)" << endl;
    }
    void f(int*)
    {
        
    	cout << "f(int*)" << endl;
    }//这里函数重载，但结果都是f（int）
    //C++中，NULL被定义为0，这也不知道为什么是个错误不太好
    int main()
    {
        
    	f(0);
    	f(NULL);
    	return 0;
    }

因此，C++11中打了一个补丁，用nullptr来代替NULL。

注意：

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

[bb153858fc284f228056852c5f5c0bfb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9e15ce4b58424c0c99deedc52fd3e4df.png
[9a08a64bf4524d3eb26278546d37e5da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ac4d7b6fe175456f89ac5066036d9d38.png