C++入门

一、缺省参数

c++中，定义函数的时候可以让最右边的连续若干个参数有缺省值，在调用函数的时候，如果不写相应位置的参数，则调用的参数就为缺省值。

函数缺省参数的作用在于提高程序的可扩充性。比如某个以及写好的函数需要添加新的参数，而原先调用函数的的那些语句未必需要新增加的参数，为了避免对原来所有调用该函数的地方进行修改，就可以使用函数缺省参数了。

缺省参数：有传参则用传入参数，无传参则用默认参数

1.全缺省

#include
using namespace std;


// 全缺省
void Func(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << endl;
}

int main()
{
	// 使用缺省值，必须从右往左连续使用
	Func(1, 2, 3);
	Func(1, 2);
	Func(1);
	Func();

	//Func(,2,);
	//Func(, , 3);

	return 0;
}

2.半缺省

半缺省指的是参数中有一部分为缺省参数，有一部分为非缺省参数。

值得注意的是，缺省参数只能为最右边的若干个。

#include
using namespace std;
// 半缺省
// 必须从右往左连续缺省
void Func(int a, int b = 10, int c = 20)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

//如果声明和定义分离，那么缺省参数在声明里缺省，不能同时缺省

int main()
{
	// <<流插入
	cout << "hello world" << endl;
	int temp;
	// >>流提取，特点是自动识别类型，无需像c语言scanf函数
	cin >> temp;
	cout << temp << endl;
	system("pause");
	return 0;
}

在多文件变成中，函数的声明与定义分离，缺省值只能在声明里缺省。因为编译时会把头文件中函数和源文件中函数结合起来，将其变成一个文件处理。在一个文件当中，只能为形参指定默认值一次

二、函数重载

c语言不允许重名函数存在，因此各个函数的名称必须不同

函数重载：是函数的一种特殊情况，C++允许在 同一作用域 中声明几个功能类似的 同名函数

这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

函数重载并不影响运行效率，函数重载只影响编译速度不影响运行速度

1.允许的函数重载

函数重载的前提：返回值，函数名，作用域必须一样

函数重载仅在参数类型不同，参数个数不同、参数类型顺序不同时可以发生

#include
using namespace std;

//1.参数类型不同
int Add(int a, int b)
{
	return a + b;
}

double Add(double a, double b)
{
	return a + b;
}

//2.参数个数不同
void print()
{
	cout << "the first" << endl;
}

void print(int i)
{
	cout << "the second" << endl;
}

//3.参数类型顺序不同
void show(char a, int b)
{
	cout << "show1" << endl;
}

void show(int a, char b)
{
	cout << "show2" << endl;
}

int main()
{
	show('a', 1);
	show(1, 'a');
	return 0;
}

2.不允许的函数重载

不能作为函数重载的条件：函数返回值类型的不同；成员函数名称以及参数完全相同，仅仅其中一个是static成员函数；

函数返回值类型不同：两个同名同参数仅返回值不同的函数，同时在主函数中调用，编译器无法分别应该返回哪一种类型，造成二义性

函数参数仅仅是指针与数组的差别：函数差别仅在于参数类型，其中一个是函数类型，另一个是相同类型的函数指针。这样实际上是相等的，也间接证明了函数当参数的时候会退化为指针

#include
using namespace std;
//函数不能重载的情况
//1.函数返回值不同，在主函数调用时，编译器无法判别返回什么类型，造成二义性
/*int ret()
{
	return 10;
}

char ret()
{
	return 'a';
}*/

//2.仅函数作用域不同
class test
{
public:
	static void func(int i)
	{

	}
	void func(int i)
	{

	}

};

//3.参数仅指针与数组的差别
void func1(int* ptr);
void func1(int ptr[]);//相当于重声明

int main()
{
	test t1;
	t1.func(1);
	t1.func(2);
	return 0;
}

三、引用

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

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

引用类型必须和引用实体是同种类型的

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

是否使用引用返回：①引用返回，如果已经还给系统了，则必须使用传值返回②如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用。

引用返回的好处：①引用可以将函数传值返回改变为传引用返回，不产生临时变量②引用返回可以减少拷贝，同时引用作为返回值可以使使用者修改返回对象数据

1.值和引用做返回值类型的性能比较

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

// 值和引用的作为返回值类型的性能比较
#include 
struct A { int a[100000]; };
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;
}

2.引用权限问题

//引用权限问题
void permission()
{
	//指针和引用，赋值/初始化 权限可以缩小，但是不能放大

	//权限放大 不允许
	//const int c = 5;
	//int& d = c;

	//const int* a = NULL;
	//int* b = a;

	//权限保持 允许
	const int e = 6;
	const int& f = e;

	const int* o = NULL;
	const int* p = o;

	//权限缩小 允许
	int x = 1;
	const int& y = x;

	int* m = NULL;
	const int* n = m;
}

3.指针与引用的异同

 如图可以看出，引用的地址相同，而赋值的地址不同

相同点：在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用一块空间。底层实现上是开辟空间的，因为引用是按照指针的方式来实现的，需要开辟临时变量

不同点：

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

四、内联函数

c++推荐：使用const和enum替代宏常量，用inline替代宏函数

宏缺点：①不能调试，直接展开②没有类型安全的检查③部分场景下非常复杂,容易出错，不容易掌握

比如一个ADD的宏函数
#define ADD(x,y) ((x)+(y))
这个函数带括号的原因，是为了避免出现ADD(1,2)*3与ADD(a|b,a&b)等情况的出现，因为宏是直接替换

函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开
没有函数调用建立栈帧的开销，内联函数提升程序运行的效率

#include
using namespace std;

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

int main()
{
	int ret = Add(1 , 2);
	return ret;
}

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会
用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运
行效率。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同
一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性
也就是说原来的调用是跳转，内联函数是展开。在可执行程序中，跳转需要的资源为函数行数+调用次数；展开需要的资源为函数行数*调用次数
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

五、auto

用于自动推断变量的类型

auto不能做形参，也不能用于声明数组 

auto使用环境：非关键中间变量类型完全取决于上下变量类型

一般用于迭代器自动推断变量类型，c++后续的迭代器类型很长不便于输入，使用auto可以提高编程效率

#include
using namespace std;

void test()
{
	int a[] = {4,5,6,8,9,3,6};
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;

	//范围for---语法糖
	//自动取数组a中的元素赋值给array，并自动判断结束
	for (auto array : a)
	{
		cout << array << " ";
	}
	cout << endl;
}



int main()
{
	int a = 0;
	auto b = a;
	auto& c = a;
	auto d = &a;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;

	test();
	return 0;
}