C++笔记

引用的使用

• 引用必须有值，不能为空
• 引用是变量的别名，指针的值是地址

#include <iostream>
//标准命名空间（包含很多标准定义）
using namespace std;

const double PI = 3.14;

//圆
class MyCircle
{
private:
	//半径
	double m_r;
	//面积
	double m_s;

public:
	//设置半径
	void setR(double r)
	{
		m_r = r;		
	}
	//获取圆的面积
	double getS()
	{
		m_s = PI * m_r * m_r;
		return m_s;
	}
};

void main()
{
	MyCircle c1;
	c1.setR(4);
	cout<<"圆的面积："<<c1.getS()<<endl;
	system("pause");
}


//命名空间提供了更小范围的作用域
namespace NSP_A
{
	int a = 9;
}

namespace NSP_B
{
	int a = 12;
	//命名空间嵌套
	namespace NSP_C
	{
		struct  Teacher
		{
			char name[20];
			int age;
		};
	}
}

void main()
{
	//使用命名空间
	using namespace NSP_A;
	using namespace NSP_B;
	cout << NSP_A::a << endl;
	cout << NSP_B::a << endl;
	//system.out.println() line

	using NSP_B::NSP_C::Teacher;
	Teacher t1;
	t1.age = 12;
	

	system("pause");
}


//类
class MyTeacher
{
private:
public:
protected:

};

//结构体
struct  MySuperTeacher
{
private:
	char name[20];
	int age;
public:
	void say()
	{
		cout << "说话" << endl;
	}
};


void main()
{
	MySuperTeacher t1;
	t1.say();
	system("pause");
}


void main()
{
	//为 1（true） 或者 0（false）
	bool isSingle = -17;
	cout << isSingle << endl;
	cout << sizeof(bool) << endl;
	system("pause");
}


void main()
{
	int a = 10;
	int b = 20;
	//找到两个数中较大的数，重新赋值为30
	//((a > b) ? a : b) = 30;
	//通过C完成给三元运算的结果赋值
	*((a > b) ? &a : &b) = 30;

	printf("%d,%d\n",a,b);

	system("pause");
}


//引用
void main()
{
	int a = 10; //门牌号(内存空间的别名，可不可以有多个名字？) 
	//C语言正常语法 &表示：取地址
	//C++ &表示：引用
	int &b = a; //b实际上就是另外一个别名

	//引用必须要初始化
	//int &c;

	cout << b << endl;
	system("pause");
}


//指针交换值
void swap1(int *a, int *b)
{
	int c = 0;
	c = *a;
	*a = *b;
	*b = c;
}

//引用交换
void swap2(int &a, int &b)
{
	int c = 0;
	c = a;
	a = b;
	b = c;
}


void main()
{
	int x = 10;
	int y = 38;
	printf("%d,%d\n", x, y);
	//swap1(&x,&y);
	//a 成了x的别名， b 成了y的别名 
	swap2(x,y);
	printf("%d,%d\n",x,y);
	system("pause");
}



//复杂类型的引用
struct Teacher
{
	char name[20];
	int age;
};

void myprint_0(Teacher p)
{
	//p只是t1的拷贝，并不会影响t1
	cout << p.age << endl;
	p.age = 25;
}

void myprint_1(Teacher *p)
{
	cout << p->age << endl;
	p->age = 35;
}

void myprint_2(Teacher &p)
{
	cout << p.age << endl;
	p.age = 45;
}

void main()
{
	Teacher t1;
	t1.age = 20;
	myprint_0(t1);
	cout << t1.age << endl;

	myprint_1(&t1);

	cout << t1.age << endl;

	myprint_2(t1);

	cout << t1.age << endl;

	system("pause");
}


//引用的探索发现

struct Teacher
{
	char &a;
	int &b;
};

void main()
{
	int a = 10;
	//int &b; //必须要赋值，很像常量
	//const MAX;
	int &b = a;
	//引用的大小，很像指针
	Teacher t1;
	cout << sizeof(t1.a) << endl;
	system("pause");
}

//引用的本质是：指针常量
void modifyA(int &a)
{
	a = 100;
}

void modifyB(int * const a)
{
	*a = 150;
}

void main()
{
	int a = 10;
	int b = 20;
	//指针常量（这个指针所保存的地址不能改变）
	int * const p1 = &a;
	//p1 = &b; //不能改变
	

	int x = 5;
	cout << x << endl;
	modifyA(x);
	cout << x << endl;
	modifyB(&x);
	cout << x << endl;

	//int &c = a;
	//c = b;

	system("pause");
}

//函数的返回值为引用
/*
int& get1()
{
	int a = 10;	//如果返回内存栈上的数据引用，程序是有隐患
	return a;
}

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

void main()
{
	cout << get1() << endl;
	int &a = get1(); //仍然不行 有隐患
	
	cout << (*get2()) << endl; //有隐患		 

	system("pause");
}
*/

/*
//返回静态变量 或者全局变量
int& get1()
{
	static int a = 10;
	a++;
	//int &b = a;
	//return b;
	cout << a << endl;
	return a;// 自动 转存 &a
}

void main()
{
	//返回静态变量
	int a = get1();
	cout << a << endl;
	a++;
	cout << a << endl;

	//函数返回值是一个引用，并且当左值
	get1() = 100;
	get1();

	system("pause");
}

*/