【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; //errint 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; //errconst 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