C++引用和引用变量_C

引用和引用变量变量必须初始化，且必须引用一块合法内存

int &c;//错误
但在类里面，可以这么定义，要用构造函数初始化
int a = 10;
int &c = a;//合法
int &c = 10;//非法，必须引用一块合法内存
const int &c = 10;//合法,不可修改c的值

常量引用

const int &c = 10;//合法,但不可修改c的值-->int temp = 10; const int &c = temp;
void test(const int& v) //防止修改入参
{}

一旦引用一个实体，再不能引用其他实体

int a = 10, b = 20;
int &c = a;
c = b;//合法，但这是赋值 *** 作,a和c都变为20

一个变量可以有多个引用

int a = 10;
int &c = a;
int &b = a;

引用的本质-指针常量

int &ref = a;
-->
int * const ref = &a; //const修饰指针ref，表示指针的指向是固定的

引用做函数的返回值不要返回局部变量的引用

int & retA()
{
    int a = 10;
    return a;  //编译器可能会保留a的数据，但是函数结束后a的内存释放，再 *** 作这块内存是非法的
}

函数调用可以作为左值

如果函数返回值为引用，则函数返回值可以作为左值

int & retA()
{
    static int a = 10; //合法，全局数据区，可以返回它的引用
    return a;
}
int main()
{
    int &ref = retA();
    cout<

 
引用变量作为类成员变量 
引用成员变量 并不为这个变量新辟空间，必须提供构造函数，且要用初始化列表，形参也须是引用类型
 常量变量：必须通过构造函数参数列表进行初始化。
 引用变量：必须通过构造函数参数列表进行初始化。
 普通静态变量：要在类外通过"::“初始化。
 静态整型常量：可以直接在定义的时候初始化。
 静态非整型常量：不能直接在定义的时候初始化。要在类外通过”::"初始化。 
#include 
using namespace std;
class A {
public:
	A(int &x1,int z1) :x(x1), y(z), z(z1) {}  //x,y仅能在初始化列表中进行初始化；
	void print() { printf("[%d,%d,%d]\n", x, y, z); }
 
	int &getx() { return x; }
	void setx(int &x1) { x = x1; }
 
	int &gety() { return y; }
	void sety(int &y1) { y = y1; } //初始化列表里，y是z的引用，改变y就是改变z
 
	int getz() { return z; }
	void setz(int z1) { z = z1; } //改变z也是改变y
private:
	int &x;
	int &y;
	int z;
};
 
int main() {
	int x = 10, y = 20, z = 30;
	int x1 = 1, y1 = 2, z1 = 3;
	int &b1 = x1, &b2 = y1;
 
	A a(x,z);
	a.print();                 //[10,30,30]
	
	a.setx(b1);
	printf("x=%d\n",a.getx()); //x = 1
	a.print();                 //[1, 30, 30]
	
	a.sety(b2);                //y = 2
	printf("y=%d\n", a.gety());//[1, 2, 2] 
	a.print();
	
	a.setz(z1);                //z = 3
	printf("z=%d\n", a.getz());//[1, 3, 3]
	a.print();
}
 
interesting 
struct Foo
{
	int a;
	int b;
	int c;
};

struct Bar
{
	Foo& foo;
}; 
void test2()
{
	cout<<"sizeof(Foo) = "<欢迎分享，转载请注明来源：内存溢出
原文地址:https://54852.com/langs/921564.html

C++引用和引用变量

`发表评论`

`评论列表（0条）`