c++引用总结

引用做函数参数

struct Teacher
{
    char name[64];
    int age ;
};

void printfT(Teacher *pT)
{
    cout<<pT->age<<endl;
}

//pT是t1的别名 ,相当于修改了t1
void printfT2(Teacher &pT)
{
    //cout<<pT.age<<endl;
    pT.age = 33;
}

//pT和t1的是两个不同的变量
void printfT3(Teacher pT)
{
    cout<<pT.age<<endl;
    pT.age = 45; //只会修改pT变量 ,不会修改t1变量
}
void main()
{
    Teacher t1;
    t1.age = 35;

    printfT(&t1);

    printfT2(t1); //pT是t1的别名
    printf("t1.age:%d \n", t1.age); //33

    printfT3(t1) ;// pT是形参 ,t1 copy一份数据 给pT     //---> pT = t1
    printf("t1.age:%d \n", t1.age); //35

    cout<<"hello..."<<endl;    
    system("pause");
    return ;
}

引用的本质

struct Teacer {
    int &a; //4个字节，类似指针
    int &b;
};
int main()
{
    printf("sizeof(Teacher) %d\n", sizeof(Teacer));
    system("pause");
    return 0;
}

1）引用在C++中的内部实现是一个常指针Type& name ==Type* const name
2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。
3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏。当实参传给形参引用的时候，只不过是c++编译器帮手工取了一个实参地址，传给了形参引用（常量指针）

函数返回值是引用

int getAA1()
{
    int a;
    a = 10;
    return a;
}

//基础类型a返回的时候，也会有一个副本
int& getAA2()
{
    int a;
    a = 10;
    return a;
}

int* getAA3()
{
    int a;
    a = 10;
    return &a;
}

指针引用

#include <iostream>
using namespace std;

namespace namespaceA {
    int a = 20;
}

namespace namespaceB {
    int a = 10;
    namespace namespaceC { //命名空间嵌套
        struct Teacher {
            string name;
            int age;
        };
    }
}

struct Teacher {
    string name;
    int age;
};

void OperatorTeacher(Teacher * const p) { //指针不能被修改

}
void OperatorTeacher(const Teacher *  p) {//指针指向的数据不能被修改

}
void swap(int &a, int &b){  //引用交换，c++编译器用常指针实现，* const
    int c;
    c = a;
    a = b;
    b = c;
}

void getTeacher(Teacher **p) {    //*p=pT
    Teacher *tmp = NULL;
    tmp = (Teacher *)malloc(sizeof(Teacher)); 
    tmp->age = 50;
    *p = tmp;
}

void getTeacher2(Teacher* &p) {   //p是pT的别名
    Teacher *tmp = NULL;
    tmp = (Teacher*)malloc(sizeof(Teacher));
    tmp->age = 60;
    p = tmp;
}
int main() {
    //using namespace namespaceB::namespaceC;
    cout << "hello" << endl;
    //cout << namespaceB::a << endl;

    int a = 0;
    int &b = a;  //引用,b是a别名 
    const int &c = a;//常引用，不能变数值
    //cout << b << endl;

    int x = 1, y = 2;
    swap(x, y);
    //cout << x << endl << y << endl;


    Teacher *pT = NULL;
    getTeacher(&pT);   //通过指针方式获取数据，子函数内产生数据

    getTeacher2(pT);   //通过引用方式获取数据，子函数内产生数据
    cout << pT->age << endl;

    return 0;
}

常引用

void main()
{
    //普通引用
    int a = 10;
    int &b = a;
    //常量引用 ：让变量引用只读属性
    const int &c = a;  

    //常量引用初始化 分为两种
    //1 用变量 初始化 常量引用
    {
        int x = 20;
        const int& y = x;
        printf("y:%d \n", y);
    }

    //2 用常量 初始化 常量引用
    {
        //int &m = 10; //引用是内存空间的别名 字面量10没有内存空间 没有方法做引用
        const int &m = 10; //当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名
    }
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}