引用高级

/* 引用高级 */

/* 引用一维数组 */
#include<iostream>
#include<stdlib.h>

void main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    int(& ra)[10](a);// 引用一维数组  引用就是给原来的变量取一个别名 同一个地址
    int i = 0;
    for (auto data : ra )
    {
        data = i + 5;
        std::cout << data << std::endl;
    }
    std::cout << a << " " << ra << std::endl;
    std::cout << &a << " " << &ra << std::endl;

    system("pause");
}


//----------------------------------------------------

/* 引用二维数组 */

void main()
{
    int a[2][5] = {1,2,3,4,5,6,7,8,9,10};
    int(&ra)[2][5](a);// 引用二维数组  
    
    for (int i=0; i<2; i++)
    {
        for (int j=0; j<5; j++)
        {
            std::cout << " " << ra[i][j];
        }
        std::cout << std::endl;
    }
    std::cout << a << " " << ra << std::endl;
    std::cout << &a << " " << &ra << std::endl;

    system("pause");
}

/* 引用一个函数指针 */

int jia(int a,int b)
{
    return a+b;
}

int jian(int a,int b)
{
    return a-b;
}

void main()
{
    int (*p)(int a,int b)(jia);
    std::cout << p(1,2) << std::endl;

    int (* &rp)(int a,int b)(p);// 引用一个函数指针
    rp = jian;// (),仅仅适用于初始化
    std::cout << p(1,2) << std::endl;
}

//----------------------------------------------------

int jian(int a,int b)
{
    return a-b;
}

void change(int(* & rp)(int,int))// 引用函数指针当作函数的参数
{
    rp = jian;
}



void main()
{
    int (*p)(int a,int b)(jia);
    std::cout << p(1,2) << std::endl;

    //int (* &rp)(int a,int b)(p);// 引用一个函数指针
    //rp = jian;// (),仅仅适用于初始化
    change(p);
    std::cout << p(1,2) << std::endl;
}

//----------------------------------------------------

/* 返回值是一个函数指针 */
int(*& changep(int(* & rp)(int,int)) )(int ,int ) // 函数指针当作函数的参数
{
    rp = jian;
    return rp;
}

void main()
{
    int (*p)(int a,int b)(jia);
    std::cout << p(1,2) << std::endl;
    
    p = changep(p);

    std::cout << p(1,2) << std::endl;
}

//----------------------------------------------------

/* 复杂引用 */


void main()
{
    //int *p[4];
    int a=1,b=2,c=3;
    int *px[3] = {&a,&b,&c}
    //int &p[4]={a,b,c};不可以
    // 引用数组是非法的
}

//----------------------------------------------------

struct mystr
{
    int a;
    int b;
    // 代码区的函数不计入结构体的sizeof
    void go()// 函数在代码区  函数区是公用的  
    {
        std::cout << "123456789" << std::endl; 
    }
};


class MyClass
{
    int a;
    int b;
    double h;
};

void main()
{
    int num = 10;
    int & rnum(num);
    double db = 10.9;
    double & rdb(db);// 直接作用引用的变量

    std::cout << sizeof(rnum) << std::endl;

    std::cout << sizeof(rdb) << std::endl;

    std::cout << sizeof(mystr) << std::endl;

    std::cout << sizeof(MyClass) << std::endl;
}

//----------------------------------------------------

/* 右值引用 */

int getdata(int && num)// 右值引用可以节约内存拷贝 内存优化所必需的
{
    std::cout << num << std::endl;
    num+=10;
    return num;
}

void main()
{
    int a = 5;
    int b = 4;
    std::cout << getdata(a+1) << std::endl;
}

 

/* 左值右值的转换 */

//左值  一般可以取地址就是左值
//右值  某些情况可以取地址有些情况不可以


int getdata(int && num)// 右值引用可以节约内存拷贝 内存优化所必需的
{
    std::cout << num << std::endl;
    num+=10;
    return num;
}

void main()
{
    int a = 3;
    int b = a+1;// 右值转左值
    std::cout << getdata(std::move(a)) << std::endl;
    // std::move(a) 将左值转换为右值  C++11 语法
}

//----------------------------------------------------

/* 常引用 */

void main()
{
    const int num(6);
    char str[10]("hello");// 限定字符串不被修改
    const char *pc(str);// 指向常量的指针限定了指向的数据无法修改 +1，+2，都不行
    str[3] = 'x';// 可以
    pc[3] = 'y';//不可以
    pc = "word";// 可以
}


void main()
{
    char str[10]("hello");
    const (&rstr)[10](str);// 常量引用
    const char(&rrstr)[10](rstr);// 引用可以给另一个引用初始化
    str[4] = 'X';
    rstr[4] = 'Y';// 不可以
}

//----------------------------------------------------

/* 引用函数指针限定不被修改 */

void main()
{
    int (*p)(int a,int b)(jia);
    std::cout << p(1,2) << std::endl;
    int (* const &rp)(int a,int b)(p);// 引用一个函数指针
    rp = jian;// 不可以，限定了函数指针不可以修改
}