C++入门：从C到C++的改变（2）

在上一篇中，我们讲到我们祖师爷为了弥补C语言的不足，而做出的改变，其中有：命名空间，输入输出，缺省参数。下面我们要继续学习C到C++的改变。

一.函数重载

1.函数重载概念

函数重载：是指在同一个作用域内，可以定义多个函数具有相同函数名，但参数列表（参数个数或参数类型或参数类型顺序）不同的情况。

2.函数重载分类

1.参数类型不同

代码：

void f(int a,int b)
{
	cout << "f(int a,int b)" << endl;
}

void f(double c, double d)
{
	cout << "f(double c, int d)" << endl;
}

int main()
{
	f(1, 2);
	f(1.2, 2.2);

	return 0;
}

运行结果：

通过运行结果可看出函数名相同且参数类型不同时我们调用时可以自动找到所调用的函数。

2.参数个数不同 

代码：

void f(int a,int b)
{
	cout << "f(int a,int b)" << endl;
}

void f(int c)
{
	cout << "f(int c)" << endl;
}

int main()
{
	f(1, 2);
	f(1);

	return 0;
}

运行结果：

 通过运行结果可看出函数名相同且参数个数不同时我们调用时可以自动找到所调用的函数.

3.函数参数类型顺序不同

代码：

void f(int a, double b)
{
	cout << "f(int a, double b)" << endl;
}

void f(double c,int d)
{
	cout << "f(double c,int d)" << endl;
}

int main()
{
	f(1, 2.1);
	f(2.1,1);

	return 0;
}

运行结果：

 通过运行结果可看出函数名相同且参数类型顺序不同时我们调用时可以自动找到所调用的函数.

4.注意事项

1.必须在同一作用域中才有函数重载，因为在不同作用域中可以定义相同的函数名。

2.我们不能通过返回类型来确认是否是函数重载，比如说下面一段代码：

int f(int a)
{
	cout << "f(int a, double b)" << endl;
}

void f(int c)
{
	cout << "f(double c,int d)" << endl;
}

int main()
{
	f(1);
	int ret = f(2);
	return 0;
}

看这段代码，这里面int ret = f（2）,可以判断是调用第一个函数，但f(1)呢?  这就确认不了调用第一个还是第二个，因为他既可以接收返回值又可以不接受返回值，所以有返回值还是没有返回值是没办法区分，所以返回值不同不作为重载函数的条件。

3.我们也不能通过缺省参数来判断是否为重载函数，代码如下：

void f(int a = 10)
{
	cout << "f(int a, double b)" << endl;
}

void f(int c = 20)
{
	cout << "f(double c,int d)" << endl;
}

int main()
{
	f(1);
	
	return 0;
}

这里f(1)调用就有歧义了，不知道调谁，所以不能通过缺少参数来判断。

5.总结

函数重载本质上谈的都是形参的类型。

3.为什么C语言不支持函数重载，C++支持函数重载？

先说结论，C++支持函数重载是因为是直接用修饰后的函数名去查找，而C语言是直接用函数名进行查找，所以不支持函数重载。

现在我们要探讨一下为什么C++可以支持函数重载。

在讲这之前我们要知道，一个程序运行起来要经过一下几个阶段：预处理，编译，汇编，链接。

1. 实际项目通常是由多个头文件和多个源文件构成，而通过C语言阶段学习的编译链接，我们 可以知道，【当前Test.cpp中调用了Stack.cpp中定义的Add函数时】，编译后链接前，Test.o的目标 文件中没有Add的函数地址，因为Add是在Stack.cpp中定义的，所以Add的地址在Stack.o中。那么 怎么办呢？（如上图所示）

2. 所以链接阶段就是专门处理这种问题，链接器看到Test.o调用Add，但是没有Add的地址，就 会到Stack.o的符号表中找Add的地址，然后链接到一起。

3. 那么链接时，面对Add函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的 函数名修饰规则。

4. 由于Windows下vs的修饰规则过于复杂，而Linux下g++的修饰规则简单易懂，下面我们使用了g++演示了这个修饰后的名字。

5. 通过下面我们可以看出gcc(C语言)的函数修饰后名字不变。而g++(C++)的函数修饰后变成【_Z+函数长度 +函数名+类型首字母】。

 

 6. 通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修 饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

7. 如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办 法区分。

二.引用

引用，什么是引用，引用就是给已存在的变量取了个别名，就比如说你的名字在外面别人叫你的大名，在家父母可能就会叫你小名，但主体是同一个。这就是引用。

编译器不会给引用变量开辟内存空间，因为他和他引用的变量共用一块内存空间。

如何使用引用：

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

int main()
{
	int a = 10;
	int& b = a;

	cout << b << endl;

	cout << &a << endl;
	cout << &b << endl;
	return 0;
}

注意：引用类型必须和引用实体是同种类型的 ，不然就会报错。

 通过这个代码运行结果，可以看出a与b的地址是相同的，所以a与b指向同一个空间。

1.引用的特性

1.引用在定义时必须初始化；

2.一个变量可以有多个引用变量；

3.引用具有唯一性，一旦引用一个实体就不能再引用另一个实体；

4.引用也可以引用引用变量，什么意思呢？如下代码：

int main()
{
	int a = 10;

	int& b = a;
	int& d = b;
	cout << d << endl;
	return 0;
}

同时我们函数传地址时，我们也可以改为引用，如下代码：

就是可以做参数，

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

int main()
{
	int i = 1, j = 2;
	Swap(i, j);
	cout << "i = " << i << endl;
	cout << "j = " << j << endl;
	return 0;
}

 

 同时也可以作为返回值，代码所示：

int& add(int a, int b)
{
	static int c = a + b;
	return c;
}

int main()
{
	int& i = add(1, 2);
	cout << i << endl;
	return 0;
}

2.常引用 

常引用是指通过const关键字修饰的引用，用于表示引用的对象是常量(即不能通过该引用修改对象的值)。

int main()
{
	const int a = 10;
	int& b = a;//会编译报错，因为这里存在权限的放大
	const int& b = a;//当权限相同或者权限缩小时，不会编译报错。
	int c = 20;
	const int d = 20;//这里就是权限的缩小
	return 0;
}

int main()
{

	int& b = 10;//错误，这里b为常量，只能读不能修改
	const int& b = 10;

	return 0;
}

大家看下面代码觉得是否正确：

int main()
{
	const int& a = 10;
	int p = a;
	return 0;
}

大家不要被引用给绕进去了，这里是m拷贝给p，不是取别名。所以没问题。

3.传值，传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直 接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效 率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

1.以传参来对比：

#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

int main()
{
	TestReturnByRefOrValue();
	return 0;
}

这里就可以明显看出，用引用传参消耗的时间为零（小于1毫秒），传值传参有明显消耗，

2.返回值来对比：

#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

int main()
{
	TestReturnByRefOrValue();
	return 0;
}

使用根据返回值来对比，传引用效率更高。

4.引用和指针的区别

1.在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。上面我们也看了引用变量与其引用的实体共用一块空间。

2.在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
	int a = 10;
	int& ra = a;
	ra = 20;
	int* pa = &a;
	*pa = 20;
	return 0;
}

我们来看下引用和汇编代码的对比：

 根据汇编代码，我们可以看出引用和指针在底层上都是一样的，在底层，引用实际上是有空间的。

5.总结

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址；

2. 引用在定义时必须初始化，指针没有要求；

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何 一个同类型实体；

4. 没有NULL引用，但有NULL指针；

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32 位平台下占4个字节)；

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小；

7. 有多级指针，但是没有多级引用；

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理；

9. 引用比指针使用起来相对更安全。

三.内联函数

内联函数的出现是为了弥补C语言中，一个函数多次被调用时消耗过大，我们祖师爷创造了内联函数。

1.概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调 用建立栈帧的开销，内联函数提升程序运行的效率。

这里call就是查找add函数地址，所以在正常函数调用时，会有建立栈帧的开销。

 如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的 调用。

查看方式：

             1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add；

             2. 在debug模式下，需要对编译器进行设置，否则不会展开 (因为debug模式下，编译器默认不 会对代码进行优化,以下给出vs2022的设置方式)

 

 2.特性

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建 议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为 《C++prime》第五版关于inline的建议：

 3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址 了，链接就会找不到。

3.宏的优缺点？

优点： 1.增强代码的复用性。 2.提高性能。

缺点： 1.不方便调试宏。（因为预编译阶段进行了替换） 2.导致代码可读性差，可维护性差，容易误用。 3.没有类型安全的检查 。

C++有哪些技术替代宏？

1. 常量定义 换用const enum 2. 短小函数定义 换用内联函数。

四.auto关键字(C++11)

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在： 1. 类型难于拼写 2. 含义不明确导致容易出错.

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的 是一直没有人去使用它，大家可思考下为什么？

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一 个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

这样说可能难以理解，我们看下面一段代码：

int main()
{
	auto i = 10;
	return 0;
}

说白了，auto就是可以当作类型来使用，如上面代码，编译就会自动匹配为变量的实际类型。这种对复杂的类型很友好，可以避免类型出错。

注意：

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto 的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编 译期会将auto替换为变量实际的类型。

这里就是如果不初始化 ，就会编译错误。

1.auto使用细则

1. auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须 加&。

int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    *a = 20;
    cout << x << endl;
    *b = 30;
    cout << x << endl;

    c = 40;
    cout << x << endl;

    return 0;
}

 这里我们要引进一个新知识，typeid操作符，用于获取一个表达式的类型信息，头文件<typeinfo>，

2. 在同一行定义多个变量 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译 器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。 

2.auto不能使用场景

1.auto不能作为函数的参数；

2.auto不能直接声明数组；

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法 ；

4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有 lambda表达式等进行配合使用。 

五.基于范围的for循环(C++11)

最原始的for循环：

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因 此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范 围内用于迭代的变量，第二部分则表示被迭代的范围。 

int main()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for (auto& e : array)
        e *= 2;
    for (auto e : array)
        cout << e << " ";
    return 0;
}

这里auto& e : array，这里的意思就是从第一个元素开始自动读取array数组中元素，然后依次赋给变量e，

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

1.使用范围for循环条件

1. for循环迭代的范围必须是确定的

对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin和end的方法，begin和end就是for循环迭代的范围。

注意：以下代码就有问题，因为for的范围不确定

2. 迭代的对象要实现++和==的操作。

 六. 指针空值nullptr(C++11)

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何 种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦

void f(int)
{
 cout<<"f(int)"<<endl;
}
void f(int*)
{
 cout<<"f(int*)"<<endl;
}
int main()
{
 f(0);
 f(NULL);
 f((int*)NULL);
 return 0;
}

这里f(NULL)本意是调用f(int&*) ，我们看运行结果：

 这里就变成调用f(int)，就把NULL默认当成了0，因此就是有争议麻烦。

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器 默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。所以这样就有些麻烦，

在C++11中就引入关键字nullptr，只表示空。

注意：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入 的。 

2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

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