【C++】：函数重载，引用，内联函数，auto关键字，基于范围的for循环，nullptr关键字

目录

• 一，函数重载
• • 1.1 函数重载的定义
  • • 1.1.1.形参的类型不同
    • 1.1.2参数的个数不同
    • 1.1.3.参数的顺序不同
    • 1.1.4.有一个是缺省参数构成重载。但是调用时存在歧义
    • 1.1.5.返回值不同，不构成重载。因为返回值可接收，可不接受，调用函数产生歧义。
    • 1.2 C++支持函数重载的原理 -- 名字修饰
    • 二，引用
    • • 2.1 引用的概念
      • 2.2 引用的使用场景
      • • 2.2.1 引用做参数
        • 2.2.2 引用做返回值
        • 2.3 引用特性
        • 2.4 引用的权限问题
        • • 2.4.1 举例1
          • 2.4.2 举例2
          • 2.4.3 举例3
          • 2.4.4 总结
          • 2.5 常引用
          • • 2.5.1 类型转换时
            • 2.5.2 表达式运算时
            • 2.6 传值、传引用效率比较
            • 2.7 引用和指针的区别
            • 三，内联函数
            • • 3.1 内联函数的概念
              • 3.2 inline 关键字
              • 3.3 内联的特性
              • 四，auto关键字(C++11)
              • • 4.1 给类型取别名
                • 4.2 可由初始化自动推导类型
                • 4.3 auto不能推导的场景
                • 五，基于范围的for循环
                • • 5.1 范围for的语法
                  • 5.2 范围for的使用条件
                  • 六，nullptr关键字

                    一，函数重载

                    在C语言中，同名函数是不能出现在同一作用域的，但是在C++中却可以，但是要满足函数重载的规则。

                    那什么是函数重载呢？它的规则是什么呢？

                    1.1 函数重载的定义

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

                    举几个例子：

                    1.1.1.形参的类型不同

                    void Swap(int* pa, int* pb)
                    {
                    	cout 
                    	cout 
                    	int a = 0, b = 1;
                    	double c = 1.1, d = 2.2;
                    	Swap(&a, &b);
                    	Swap(&c, &d);
                    	return 0;
                    }
                    
                    	cout 
                    	cout 
                    	int a = 0, b = 1;
                    	double c = 1.1, d = 2.2;
                    	f(1,'c');
                    	f('d',3);
                    	return 0;
                    }
                    
                    	cout 
                    	cout 
                    	int a = 0, b = 1;
                    	double c = 1.1, d = 2.2;
                    	f();
                    	f(5);
                    	return 0;
                    }
                    
                    	return 0;
                    }
                    void f()
                    {
                    	cout 
                    	int a = 0, b = 1;
                    	double c = 1.1, d = 2.2;
                    	int ret = f();
                    	cout 
                    	int a = 1;
                    	//引用：&  b是a的别名
                    	int& b = a;
                    	//也可以给别名取别名
                    	int& c = b;
                    	//值相同，地址也相同
                    	cout 
                    	int tmp = a;
                    	a = b; 
                    	b = tmp;
                    }
                    int main()
                    {
                    	int x = 1;
                    	int y = 2;
                    	Swap(x, y);//这里就不用传地址过去了
                    	cout 
                    	int x = 0;
                    	int& y = x;//y是x的别名
                    	int z = 1;
                    	//这里y是z的别名，还是z赋值给y？
                    	//是赋值。引用一旦引用一个实体，就不能再改变指向了！
                    	y = z;
                    	cout 
                    	//这里权限放大了。m是只读，n变成m的别名后，可读可写。
                    	const int m = 0;
                    	
                    	//int& n = m; //err
                    	
                    	int p = m;//可以，不是权限的放大。
                                  //只是把m拷贝给p，p的修改不影响m。
                        //n也是只读的，权限的平移
                        const int& n = m;//可以
                        
                    	return 0;
                    }
                    
                    	const int m = 0;
                    	// 权限的放大
                    	//p1可以修改，*p1不行,const修饰的是p1指向的内容，即*p1。
                    	const int* p1 = &m;
                    	p1++;//可以
                    	//int* p2 = p1;//err. *p2是可以修改的，所以权限放大了。
                    		
                    	return 0;
                    }
                    
                    	//权限的缩小
                    	int x = 0; 
                    	int& y = x;
                    	const int& z = x;//可以
                    	y++;//x,z都会修改
                    	return 0;
                    }
                    
                    	double d = 3.24;
                    	//类型转换
                    	int i = d;
                    	//int& r = d;err 
                    	
                    	const int& r = d;//可以。加了const就相当于权限平移了。
                    	return 0;
                    }
                    	
                    	int x = 0, y = 1;
                    	//表达式运算也会生成临时变量
                    	//int& r2 = x + y; //err
                    	const int& r2 = x + y; //可以
                    	return 0;
                    }
                     int a[10000]; };
                    void TestFunc1(A a) {}
                    void TestFunc2(A& a) {}
                    void TestRefAndValue()
                    {
                    	A a;
                    	// 以值作为函数参数
                    	size_t begin1 = clock();
                    	for (size_t i = 0; i