C++引用、内联函数、宏函数、auto关键字

1.引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间
类型& 引用变量名(对象名) = 引用实体；
注意：引用类型必须和引用实体是同种类型的
void TestRef()
{
int a = 10;
int& ra = a;//<====定义引用类型
printf(“%p\n”, &a);//10
printf(“%p\n”, &ra);//10
}
特性：

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

//做参数：
#include<iostream>

void swap(int& x1, int& x2)//x1就是x的别名，x2就是y的别名
{
    int tmp = x1;
    x1 = x2;
    x2 = tmp;
}

int main()
{
 
    int x = 0, y = 1;
    swap(x, y);

    return 0;
}

//做返回值：
//传值返回
int Count()
{
static int n = 0;
n++;
// ...
return n;
}
int main()
{
    int ret=Count();//返回的是n的临时拷贝
    return 0;
}
//引用返回，返回n的别名，类似野指针;错误示范
#include<iostream>
using namespace std;
int& Count()
{
    int n = 0;


    return n;
}
int main()
{
    int ret=Count();//返回的是n的别名
    cout<<ret<<endl;
    return 0;
}

注意：如果函数返回时，出了函数作用域，如果回对象还在(还没还给系统)，则可以使用引用返回，
如果已经还给系统了，则必须使用传值返回。
传引用传参（任何时候都可以用）
1、提高效率
2、输出型参数（形参的修改，影响的实参）

传引用返回（出了函数作用域对象还在才可以用）
1、提高效率
2、修改返回对象
传引用传参和传引用返回的应用：

#include<iostream>
#include<assert.h>
using namespace std;

struct SeqList
{
    int a[10];
    int size;
};

//C的接口设计
//读取第i个位置的值
int SLAT(struct SeqList* ps, int i)
{
    assert(i < ps->size);
    // ...
    return ps->a[i];
}
// 修改第i个位置的值
void SLModify(struct SeqList* ps, int i, int x)
{
    assert(i < ps->size);

    // ...
    ps->a[i] = x;
}

//CPP接口设计
//读 or 修改第i个位置的值
int& SLAT(struct SeqList& ps, int i)
{
    assert(i < ps.size);
    // ...
    return (ps.a[i]);
}

int main()
{
    struct SeqList s;
    s.size = 3;
    // ...
    SLAT(s, 0) = 10;
    SLAT(s, 1) = 20;
    SLAT(s, 2) = 30;
    cout << SLAT(s, 0) << endl;
    cout << SLAT(s, 1) << endl;
    cout << SLAT(s, 2) << endl;

    return 0;
}

1.1常引用

// 在引用的过程中； 权限可以平移； 权限可以缩小； 权限不能放大
//赋值拷贝不影响

int func()
{
    int a = 0;

    return a;
}

int main()
{
    const int& ret = func();

    const int a = 0;
 


// int& b = a;
// 权限的放大
    //int b = a; 可以的，因为这里是赋值拷贝，b修改不影响a

    // 权限的平移
    const int& c = a;

    // 权限的缩小
    int x = 0;
    const int& y = x;
 
    int i = 0;
 double& d = i;//不可以，类型转变会产生临时变量，临时变量具有常性
    const double& d = i;

    return 0;
}

1.2. 引用和指针的区别

引用和指针的不同点:

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

2.内联函数

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

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

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

inline int func()
{
    int x1 = 0;
    int x2 = 0;
    int x3 = 0;
    int x4 = 0;
    int ret = 0;
    ret += x1;
    return ret;
}

3.宏函数

宏：直接替换
缺点是什么?
1、容易出错，语法坑很多
2、不能调试；在预处理阶段就替换了
3、没有类型安全的检查
宏函数的优点
1、没有的类型的严格限制
2、针对频繁调用小函数，不需要再建立栈帧，提高了效率

// 实现一个ADD的宏函数
#define ADD(x, y) ((x)+(y))//宏函数的实现
int main()
{
    ADD(1, 2);
    printf("%d\n", ADD(1, 2));
    printf("%d\n", ADD(1, 2)*3);

    int a = 1, b = 2;
    ADD(a | b, a & b); // (a|b + a&b)会有问题
 return 0;
 }

4.auto关键字(C++11)

自动识别变量类型
使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类
型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为
变量实际的类型。
//typeid();查看变量类型

int main()
{
    int a = 0;
 auto b = a;//int b = a;
    auto c = &a;
    auto& d = a;

    // 普通场景没有什么价值
    // 类型很长，就有价值，简化代码
//std::vector<std::string> v;
 std::vector<std::string>::iterator it = v.begin();
    auto it = v.begin();
 //typeid();查看变量类型

cout << typeid(c).name() << endl;//int*
cout << typeid(d).name() << endl;//int
cout << typeid(it).name() << endl;//

    return 0;
}

1. auto不能作为函数的参数，因为编译器无法对参数的实际类型进行推导
2. auto不能直接用来声明数组

总结

初学C++，希望所得知识对你有所帮助，且相关知识可能理解有误或不够深入，若有错误，望大佬指正，望共同进步。