C++入门2

1.函数重载

1.1概念

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

1.2示例 

#include<iostream>
using namespace std;

//参数类型不同
int Mul(int a, int b)
{
	cout << "int Mul(int a, int b)" << endl;
	return a * b;
}

double Mul(double a, double b)
{
	cout << "double Mul(double a, double b)" << endl;
	return a * b;
}

//参数个数不同
void Func(int a)
{
	cout << "Func(int a)" << endl;
}

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

//参数顺序不同
void f(double a, char b)
{
	cout << "f(double a, char b)" << endl;
}

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

int main()
{
	Mul(1, 2);
	Mul(2.3, 4.5);

	Func(5);
	Func(5, 6);

	f(5.6, 'e');
	f('e', 5.6);

	return 0;
}

1.3特别注意！

• 返回值不同，无法区分，返回值不是重载的条件
• 虽构成重载，但会引起歧义

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

因为C++运行的时候有函数名修饰，但C语言直接用的函数名，所以无法区分。

C++： 

C语言：

2.引用 

2.1概念

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

比如： 

a是我们定义的变量，b是a引用的变量，也就是a的别名，会发现a和b的使用空间是相同的。同时改变b的值也会改变a的值。 

---

 2.2格式

类型& 引用变量名=引用实体；

void TestRef()
{
    int a = 10;
    int& ra = a;//<====定义引用类型(a的别名)
    int& c = ra;//也可以给别名取别名
}

注意：引用类型必须和引用实体是同一种类型！

2.3引用特性 

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

   int main()
   {
   
   	int a = 1;
   	int c = 2;
   	//int& b;报错->没有初始化
   	int& b = a;
   	//&b = c;报错->表达式必须是可修改的左值	
   }

 2.4常引用

const int a = 10;
//int& ra = a;   // 该语句编译时会出错，a为常量

1.权限放大，a是只读，ra为a的别名，ra是可读可写的，所以报错。

---

2.但是权限的缩小是没问题的

void test()
{
	int x = 0;
	int& y = x;
	const int& z = x;
}

---

那么这种情况是不是权限的放大呢？

const int m = 0;
int p = m;

答案是不是，两者的地址不同，这只是把m的值拷贝给p，p的值的改变并不会影响m。

---

int main()
{
    double d = 3.14;
    //类型转换
    int i = d;
    int& r = d;
    return 0;//报错：无法从“double”转换为“int&”
}

3.从代码可以看出，这是类型转换，在类型转换中会存在临时变量，临时变量具有常性，所以要用const修饰。

int main()
{
    double d = 3.14;
    int i = d;
    //int& r = d;//报错：无法从“double”转换为“int&”
    const int& r = d;
    return 0;
}

3.引用和指针 

3.1共同点

在语法概念上引用就是一个别名，没有独立空间，和其引用实体公用同一块空间。这底层实现上实际是有空间的，因为 引用是按照指针方式来实现的。

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

我们看上面代码的引用和指针汇编代码对比：

所以我们以前用的指针可以用引用代替，比如：

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

---

再提一点，也可以给指针变量取别名：

void test4()
{
	int x = 0;
	int* p = &x;
	int*& q = p;
	q = NULL;//p、q都为空
}

 3.2不同点

1. 引用概念上定义一个变量的别名，指针存储一个变量地址
2. 引用在定义是必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类实体
4. 没有NULL引用，但有NULL指针（但是以下情况是可以的：）

   int main()
   {
   	int* p = NULL;
   	int*& pq = p;
   	cout << pq << endl;
   }

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位占4个字节）
6. 引用自加即引用实体加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但没多级引用

 4.内联函数

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

inline int Add(int x, int y)
{
	return x + y;
}

int main()
{
	
	int ret = Add(3, 5);
	cout << ret << endl;
}

普通函数：

 

 4.1特性

1. 内联函数是以空间换空间的做法。
2. 内联函数用于函数规模较小，不是递归、且频繁调用
3. 内联函数声明和定义不建议分开，会导致错误

 5.auto关键字

5.1auto的特性

auto在定义变量时，可以由编译器自动识别类型。

5.2auto使用规则

1. 用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;
       *b = 30;
        c = 40;
       return 0;
   }

2. 当在同一行声明多个变量时，这些变量必须是相同类型。

   void TestAuto()
   {
       auto a = 1, b = 2; 
       auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
   }

5.3auto不能使用的场景 

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

   // 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
   void TestAuto(auto a)
   {}

2. auto不能直接声明数组

   void TestAuto()
   {
       int a[] = {1,2,3};
       auto b[] = {4，5，6};//报错
   }

6.C++->范围for 

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

void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
//使用auto会自动取数组中的值赋给e，自动++，自动判断结束。
for(auto& e : array)
     e *= 2;
for(auto e : array)
     cout << e << " ";
return 0;
}