C++函数重载、引用、内联函数总结

函数重载

1、概念：C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数、类型、顺序）必须不同，常用来处理实现功能类似数据类型不同的问题。

//函数重载的应用                                                                                
//在同一个定义域：1.函数名字相同                                                                
//              2.参数列表必须不同(个数，类型，次序)                                          

int Add(int a, int b)
{
    return a + b;
}
double Add(double a, double b)
{
    return a + b;
}
int main()
{
     //缺省函数的引用:根据参数列表来确定调用哪种函数
     cout<<Add(1,2)<<endl;
     cout<<Add(1.0,2.0)<<endl;
     return 0;
}

2、C语言中为什么不支持函数重载？C++函数重载在底层是怎么实现的？
原因：名称修饰
C语言的名称修饰规则非常简单，只是在函数名称前添加一个下划线。
C++中，编译器在使用的函数名称是被重新修饰过的一个复杂的名字，被重新修饰后的名字包含了：函数的名字+参数类型，参数列表的不同保证了在底层的函数名字不同，因此可以重载。
3、C++是否可以将一个函数按照C语言的风格编译？
可以：extern “C”

引用

1、概念：给已存在的变量取一个别名，编译器不会为引用变量开辟内存空间，引用变量与原变量共用同一块内存空间。
2、类型& 引用变量名（对象名）=引用实体；
注意：引用类型必须和引用实体是相同类型的；
3、引用特性：
1）引用在定义时必须初始化；
2）一个变量可以有多个别名；
3）引用一旦引用一个实体，再不能引用其他实体（直接&可能会被看成取地址）
4、常引用，数组引用
const万能引用（普通变量和const变量都可以引用）

//引用特性，常引用
int main()
{
        int a = 10;
        int &ra = a;
        //引用变量和实体占用同一块地址空间                        
        cout << &a << endl;
        cout << &ra << endl;//地址相同
          ra=20;
          cout << a << endl;//20
        cout << ra << endl;//20
        //常引用
        const int a = 10;
        int &ra = a;//出错，a为常量不可以被引用
        //引用加const的用法
        //1、
        int a = 10;
        const int& ra = a;
          //定义实体为常量，需常引用
        const int a = 10;
        const int& ra = a;

        double d = 12.34;
        const int& rd = d;//编译器创建了一个临时空间将d放进去，ra为临时空间的别名，因此rd为12。
        //可以通过编译，但不在同一块地址空间了
        double c = 12.34;
        const int& rc = c;//rc不是c的别名，而是地址空间（临时变量）的别名，因此rc的值不会改变                     
        //数组的引用
        int arr1[10];//数组的类型为：int[10]类型 
        int(&rarr1)[10] = arr1;
        rarr1[0] = 10;
        cout << rarr1[0] << endl;
        cout << &rarr1 << endl;
        cout << &arr1 << endl;
        return 0;
}

5、指针和引用的区别
1）初始化；
2）不能再引用其他实体；
3）没有NULL引用；
4）在sizeof中含义不同；
5）无多级引用；
6）引用自加即引用实体自加；
7）访问实体不同；
8）引用比指针使用起来更安全；

//引用和指针的区别
int main()
{
//1、引用在定义时必须初始化，指针没有要求
//2、引用在初始化时引用一个实体后，就不能再引用其他实体，指针在任何时候可以随便指向一个变量
//3、没有空引用，但有空指针

        char c = 'c';
        char* pc = &c;
        char& rc = c;
//4、在sizeof中的含义不同，指针始终是地址空间所占大小，引用结果为引用类型的大小
        cout << sizeof(pc) << endl;//4
        cout << sizeof(rc) << endl;//1
//5、++、--不同，给引用自加就是给值加一，指针自加是偏移一个类型的大小
        int a = 10;
        int& ra = a;
        ++ra;
        cout << ra << endl;//11
        int*pa = &a;
        cout << pa << endl;//CC
        ++pa;
        cout << pa << endl;//D0
//6、有多级指针，但没有多级引用
//7、访问实体方式不同：指针要显式解引用（手动寻址），引用编译器自己处理
//8、引用比指针使用起来相对更安全
        system("pause");
        return 0;
}

6、使用场景：
1）作函数形参

1、作形参
//传值，不能实现交换
void Swap(int a, int b)
{
        int tmp = a;
        a = b;
        b = tmp;
}
//传址
void Swap(int *a, int *b)
{
        int tmp = *a;
        *a = *b;
        *b = tmp;
}
//引用做函数的形参                              
void Swap(int &a, int &b)
{
        int tmp = a;
        a = b;
        b = tmp;
}

 可以达到传值，又可以达到传址的效果，都可以通过形参改变实参的大小，那传址和传引用的效率哪个更高呢？

#include<Windows.h>
struct A
{
        int arr[1000];
        int b;
};
void TestFunc1(A& a)//传引用
{}
void TestFunc2(A* a)//传地址
{}
void TestRefPtr1()
{
        A a;
        //起始时间
        size_t begin = GetTickCount();//该函数获取运行时间
        for (size_t i = 0; i < 1000000; i++)
        {
               TestFunc1(a);
        }
        size_t end = GetTickCount();//结束时间
        cout << "传引用:" << endl;
        cout << end - begin << endl;//得到以上循环所用时间
}
void TestRefPtr2()
{
        A a;
        //起始时间
        size_t begin = GetTickCount();//该函数获取运行时间
        for (size_t i = 0; i < 1000000; i++)
        {
               TestFunc2(&a);
        }
        size_t end = GetTickCount();//结束时间
        cout << "传地址:" << endl;
        cout << end - begin << endl;//得到以上循环所用时间
}
int main()
{
        TestRefPtr1();
        TestRefPtr2();
        system("pause");
        return 0;
}

运行结果：说明引用和指针在传参的效率是上几乎相同。

说明：

在底层，指针和引用的处理方式是一样的，都是按照指针的方式来实现的：
T&就相当于T*const；
const T& 相对于const T* const；

2）引用作返回值

//一般情况下只能返回一个值
int &TestFunc1()
{
    int a=10;
    return a;
}
int &TestFunc2(int &a)
{
    return a;
}
int main()

{
    int& ra=TestFunc1();
    cout<<ra<<endl;//10
    //出了函数的作用域，函数栈上的空间已经没有了
    cout<<ra<<endl;//随机值

    int b=20;
    TestFunc(b);//使得b的生命周期加长
}

内联函数

引入：
宏：宏常量

#define PI 3.14
int main()
{
        cout << PI * 2 * 2 << endl;//不会对宏进行类型检测
        //C++中const定义的常量具有于宏常量的性质(在预处理阶段进行替换)，尽量用const代替宏常量
        const double Pi = 3.14;
        const int a = 10;
        int *pa = (int *)&a;//pa=&a
        *pa = 100;// -> *pa=a，在预处理阶段将a的值改为100
        cout << a << endl;//10,在编译阶段已经替换为10
        cout << *pa << endl;//100，应该打印10
        system("pause");
        return 0;
}

宏函数：

#define MAX(a,b) ((a)>(b)?(a):(b))

int main()
{
        int a = 10;
        int b = 20;
        cout << MAX(a, b) << endl;
        cout << MAX(a, ++b) << endl;//输出22，宏函数的缺陷，函数不会出现

        system("pause");
        return 0;
}

宏的优缺点：

• 宏优点：
  1.增强代码的复用性。
  2.提高性能
• 缺点：
  1.不方便调试宏。（因为预编译阶段进行了替换）
  2.导致代码可读性差，可维护性差，容易误用。
  3.没有类型安全的检查

C++使用内联函数来代替宏函数，来解决宏函数的缺陷：
1、概念：以inline修饰的函数叫做内联函数， 编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。

inline int Add(int a, int b)
{
        return a + b;
}
int main()
{
        int a = 10;
        int b = 20;
        //引入内联函数：以inline修饰的函数，编译时C++程序将内联函数在调用函数地方展开
        //使用内联函数的好处:没有函数压栈的开销，内联函数提升程序运行的效率。
        cout << Add(a, b) << endl;
        //查看方式：
        //1、在release模式下，查看编译器生成的汇编代码中是否存在call Add
        //2、在debug模式下，需要对编译器进行设置，否则不会展开
        system("pause");
        return 0;
}

2、特性：具有宏函数替换特性

1) inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用。
2) inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。

3、内联函数与宏函数的区别？

• 1.内联函数在运行时可调试，而宏定义不可以;
• 2.编译器会对内联函数的参数类型做安全检查或自动类型转换（同普通函数），而宏定义则不会；
• 3.内联函数可以访问类的成员变量，宏定义则不能；
• 4.在类中声明同时定义的成员函数，自动转化为内联函数。

4、C++中有哪些技术可以替换C++中的宏？
1. 常量定义 换用const
2. 函数定义 换用内联函数
3. 类型重定义 换用 typedef