c++的引用
#include <iostream>

using namespace std;

//引用的本质就是同一个变量/空间的另一个名称,与它本来的名称代表的东西是完全一样的
//引用的本质是一个常指针,int *const p = NULL(常量化的变量一定要初始化
//引用的特点
//1.引用没有定义,是一种关系型声明,不分配内存,与被引用的变量有相同的地址
//2.引用声明的时候必须初始化,与一块空间绑定后,永不变更
//3.可以对引用再次引用,多次引用的结果就是某一变量具有多个别名,这些别名就是指这个变量
//4.&符号前有数据类型时才是引用(例int &a,char &b等),其他皆为取地址(&符号在等号左边且&符号左边有数据类型才是引用,const修饰看右边且只看一个对象,右边是谁就修饰谁)

void change_value1(int *p)//int *p = &a
{
    *p = 1000;
}

void change_value2(int &p)//int &p = a
{
    p = 10000;
}

void swap(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}

struct student
{
    char name[64];
    int id;
};
//引用传递比地址传递好,地址传递比值传递好
//地址传递
void my_copy1(student *t)//student *t = &t
{
    cout << t->name << " " << t->id << endl;
}
//引用传递
void my_copy2(student &t)//student &t = t
{
    cout << t.name << " " << t.id << endl;
}
//值传递
void my_copy3(student t)//student t = t
{
    cout << t.name << " " << t.id << endl;
}

//结构体的功能很强大,里面存储的是类型,可以取引用类型
struct A
{
    int &a;
};
struct B
{
    int *a;
};
void function1()
{
    
    cout << "A=" << sizeof(A) << endl;
    cout << "B=" << sizeof(B) << endl;
    //b为a的引用,求b变量大小即为求a的大小,即sizeof(a),所以结果为1
    char a = '1';
    char &b = a;
    cout << "&b=" << sizeof(b) << endl;
}

void motify1(int *const a)//int *const a = &a,常指针a的指向不可以改变,但指向的内容可以改变,常指针也是在常量区的,不是在栈区,但是常指针指向的内容可以是栈区,此时指向的内容时可以改变的,但常指针指向不可改变
{
    *a = 100;
    cout << "a=" << *a << endl;
}
void motify2(int &a)//int &a = a,这与上面是完全一样的,引用的本质就是常指针,当我们函数参数为引用时,编译器会帮我们取实参的地址,而不是值
{
    a = 1000;
    cout << "a=" << a << endl;
}

//函数返回值为引用或变量本身时,return的都是这个变量本身,只是在返回值类型的定义时有区别,其他完全相同
//函数返回值为局部变量的引用时
int &get_value1()
{
    int value = 300;
    return value;
}
//函数返回值为局部变量时
int get_value2()
{
    int value = 400;
    return value;
}
//函数返回值为静态变量/全局变量引用时,函数可以作为左值
int &get_value3()
{
    static int value = 1;//静态变量只初始化一次
    return value;
}

struct teacher
{
    char name[64];
    int id;
};
//函数参数为指针的引用(相当于二级常量指针),对tp操作就相当于对指针本身进行操作,即可以改变指针指向的地址
int get_memory(teacher * &tp)
{
    tp = (teacher *)malloc(sizeof(teacher));
    if (tp == NULL)
    {
        return -1;
    }
    //tp在这儿指的是指针的引用,指针的引用即为指针的别名,所以tp即为指针
    tp->id = 9;
    strcpy_s(tp->name, strlen("xuhaoxuan") +1, "xuhaoxuan");
    return 0;
}

//const修饰函数参数
//1.const修饰普通变量时,表示在这个函数作用域中,a的值不可以更改
int func1(const int a)
{
    return 0;
}
//2.const修饰引用时,表示在这个函数作用中,a的值不可更改(a代表的区域也不可以更改,其实也就是a为变量的别名)
int func2(const int &a)
{
    return 0;
}
//3.const修饰指针指向空间的内容,表示这个指针指向空间的内容不可以改变,但指针的指向可以改变
int func3(const int *a)
{
    int b = 1;
    a = &b;
    return 0;
}
//4.const修饰指针本身,即这个指针的指向不可以改变,但这个指针指向空间的内容可以改变
int func4(int *const a)
{
    *a = 20;
    return 0;
}

int main()
{
    int a = 10;
    int b = 20;

    //指针,是会为指针开辟一个空间,这个空间指向变量a,且可以对指向的空间进行操作
    int *p = &a;
    *p = 100;
    cout << "a=" << a << endl;

    //引用,不会为引用开辟一个空间,一个变量引用另一个变量,相当于为另一个变量取了一个别民,两个变量名都是指完全一样的空间,且对别名操作等同于对原始变量操作
    int &q = b;
    q = 200;
    cout << "b=" << b << endl;
    int &q1 = q;
    q1 = 2000;
    cout << "b=" << b << endl;

    change_value1(&a);
    cout << "a=" << a << endl;
    change_value2(a);
    cout << "a=" << a << endl;

    a = 10, b = 20;
    swap(a, b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;

    //结构体初始化时字符串可以直接赋值,后面如果需要对字符串赋值时需要运用拷贝函数
    student t = { "xuhaoxuan",16 };
    my_copy1(&t);
    my_copy2(t);
    my_copy3(t);

    function1();

    motify1(&a);
    motify2(a);

    int value;
    //1.当返回局部变量引用时,必须要用另外一个变量本身区接
    value = get_value1();
    //2.当用引用去接局部变量的引用时,是非常错误的,因为局部变量会消失,你引用的本身空间是不存在的
    //即不能去引用局部变量或局部变量的引用,即那些会销毁的局部区域
    //最好的避免方法即返回值不应为局部变量
    //int &value = get_value1();
    //int &value = get_value2();
    cout << "value=" << value << endl;

    get_value3() = 1000;
    cout << "get_value3()=" << get_value3() << endl;

    teacher *tp;
    get_memory(tp);

    //1.对一个常量进行引用,必须是一个const引用,因为常量是不可改变的,你用一般引用去引用常量,这个引用即为这个常量的别名,那通过这个引用别名就可以改变常量的值了,所以是错误的
    //也可以这样理解,首先int &re引用的本质即为常指针了,这只是说明引用指向的空间不可以改变,但指向空间的内容可以改变,所以再加一个const修饰引用指向空间的内容不可改变
    //错误例子:int &re1 = c;
    const int c = 1;
    const int &re1 = c;
    //2.对一个普通变量进行const引用却是可以的,首先引用本身时常指针,这说明re只能指向空间d,但用const修饰了引用,说明不可以通过引用改变d空间的内容,但可以通过d本身来改变d空间的内容
    int d = 2;
    const int &re2 = d;
    cout << "d=" << d << endl;
    cout << "re2=" << re2 << endl;
    d = 3;
    cout << "d=" << d << endl;
    cout << "re2=" << re2 << endl;
    
    int e = 10;
    func1(e);
    func2(e);
    func3(&e);
    return 0;
}
阅读更多
文章标签: c++
想对作者说点什么? 我来说一句

c++之十引用和拷贝构造函数

2010年04月25日 468KB 下载

C++_引用的作用和用法

2011年05月11日 191KB 下载

c++之指针&&引用

引用

xxpresent xxpresent

2016-09-24 16:03:36

阅读数:2798

没有更多推荐了,返回首页

不良信息举报

c++的引用

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭