C++入门

一、函数重载

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

1.形参类型不同

2.形参个数不同

3.形参顺序不同

注意：函数返回值不同并不能构成函数重载。

二、引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。

int main()
{
	int a = 0;
	int& b = a;
	int& c = a;
	return 0;
}

从调试可以看出&b 和 &c 和 a的地址都是相同的，验证了它和它的引用是公用一个地址，变量a也可以同时拥有多个别名。

比如：假如你叫李华，领导可以叫你小李，你同事叫你李华，你的好朋友叫你外号，这都是对同一个人的称呼。

注意：

• 一个变量可以有多个引用
• 引用在定义时必须初始化
• 引用一旦引用一个实体，再不能引用其他实体

引用的类型必须和引用实体的类型相同，不能用int&引用double类型。

1.引用的权限

• const常量

引用可以引用常量，但是必须加const修饰。

int a = 10;
	const int& b = 10;//引用可以引用常量，但是必须加const
	const int& c = a;//权限的缩小，只可读不可改

	const int d = 10;//只可读不可改

	int& f = c;//放大了权限，报错

结论：权限可以缩小，但是不可以放大。

• int 和 double 相互引用

刚刚我们说过用int&来引用double类型的变量，编译器会报错。

但是我们可以用const int& 来引用 double 的变量。

但是此时已经发生了变化。

原来的a是10.2,但是用int引用的b已经变成了10。

说明它们之间有发生隐式类型转换，

但是它们的地址是相同的。

2.引用的使用

函数传参

一般我们在写一个交换的函数时，我们都要使用传址调用。现在我们有了引用，我们就可以用引用来修改交换函数。

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	Swap(a, b);
	cout << a << endl << b << endl;
	return 0;
}

函数返回值

int& Count() //返回了n的空间，但是n的空间被销毁了
{            //所以在打印时会打印随机值
	int n = 0;
	n++;
	return n;
}

int& Count1()
{
	static int n = 0;//静态的n，空间没有被销毁
	n++;			 //正常返回n的空间
	return n;		 //打印n的值
}

效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，

因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

#include <time.h>
struct A 
{ 
	int a[100000]; 
};
void TestFunc1(A a) 
{

}
void TestFunc2(A& a) 
{

}
void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

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

可以看出花费的时间相差还是很大的。

引用作为参数的传参消耗都是很小的，传值的时候需要拷贝数据，所以会消耗更大。

在函数返回传参的时候，其实是先把返回值存放到寄存器eax中，而不是直接返回给main函数的变量。

而使用引用作为返回值的时候，就不需要用寄存器来接收临时变量，这时候就优化了函数返回的时间！

指针和引用的区别

我们在反汇编中发现，指针和引用是十分类似的。是因为C++的引用是用指针实现的。

不同：

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 引用的sizeof大小和引用对象相同；指针无论指向的谁，大小都是4/8
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

三、内联函数

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

这和我们当初C语言学习中的define很像，但是inline是展开，而define是替换。

内联函数的简单使用

#include <stdio.h>
#include <iostream>
using namespace std;

#define add(a,b) ((a)+(b))

inline int Add(int a, int b) {
	return a + b;
}

int main()
{
	int sum = add(1, 2);
	cout << sum << endl;

	int ret = Add(3, 4);
	cout << ret << endl;

	return 0;
}

通过反汇编，我们可以看出define是直接替换了函数。

这里我们发现为什么使用内联还是有调用栈帧呢？

编译器设置

原因是我们的编译器没有设置好，我们接下来设置编译器。

在设置好编译器后，我们再次进入反汇编。

内联函数Add确实是直接展开，并没有call调用栈帧了。

特性

因为define没有无法调试，且不能debug可读性不高，内联函数解决了这一缺点。

1.inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。

2.inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会自己忽略掉内联。

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

定义和声明分离后会报错，所以一般内联函数建议直接在头文件中直接完成。

四、auto关键字

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

1. 类型难于拼写
2. 含义不明确导致容易出错

于是C++出现了auto关键字。

1.基本使用

int TestAuto()
{
	return 10;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	return 0;
}

我们可以看到，编译器打印出了每一个变量的数据类型，auto自动判断并给这些变量赋予了数据类型。

特别的：

//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化

2.和指针、引用的使用

1. auto与指针和引用结合起来使用，用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&。

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

错误使用

1. auto不能作为数组的声明

2. auto不能用来作为函数的参数和返回值

int add(auto a, int b)//erro
{
	return a + b;
}

auto Add(int a, int b)//erro
{
	return a + b;
}

因为编译器无法对a的实际类型进行推导。

3.范围for

平时我们遍历一个数组通常是这样：

int main()
{
		int arr[] = { 1, 2, 3, 4, 5 };
		for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
		{
			cout << arr[i] << " ";
		}
		cout << endl;
	return 0;
}

在我们学会auto后，我们就可以快速便捷的写出auto范围for遍历。

如果我们想修改数组中的值，我们可以使用之前学过的引用。

注意：如果在for里面设置的e没有带&引用，数据内容的更改是不会改变源数组的。

4.范围for的使用条件

1. 使用范围for的时候，必须给定一个准确的范围

对于数组而言，就是数组中第一个元素和最后一个元素的范围；

对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

2. 迭代的对象要实现++和==的操作。(关于迭代器这个问题，以后会讲，现在大家了解一下就可以了)

五、nullptr

在C语言中NULL代表空指针。

但是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 << "void f1(int)" << endl;
}

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

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

比如在上面的函数重载代码中，编译器就不知道要调用哪一个函数了。

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。

于是，C++中就有了nullptr。

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

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

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