C++学习笔记（七）封装（三种权限）、struct和class区别、成员属性设为私有_struct 有属性限制么?

类和对象

//c++面向对象的三大特性为：封装、继承、多态
//C++认为万事万物都皆为对象，对象上有其属性和行为
//例如：
	//人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...
	//车也可以作为对象，属性有轮胎、方向盘、车灯..., 行为有载人、放音乐、放空调...
//具有相同性质的 == 对象 == ，我们可以抽象称为 == 类 == ，人属于人类，车属于车类
1
2
3
4
5
6

1.封装

//封装的意义：
	//将属性和行为作为一个整体，表现生活中的事物
	//将属性和行为加以权限控制
1
2
3

1.1将属性和行为作为一个整体，表现生活中的事物

语法：

class 类名
{
访问权限：
	属性；
	行为；
}；
1
2
3
4
5
6

//类中的属性和成员，统一称为成员
//属性=成员属性=成员变量
//行为=成员函数=成员方法
1
2
3

代码：

//圆周率
const double PI = 3.14;

//设计一个圆类，求圆的周长
//圆的周长公式：2 * PI *半径
//class 代表设计一个类，类后面紧跟着的是类名称
class Circle
{
	//访问权限
public://公共权限

	//属性
	int m_r;//半径

	//行为，通常用函数来表示
	//获取圆的周长
	double calculateZC()
	{
		return 2 * PI*m_r;
	}

};

//设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
//设计学生类
class Student
{
	//公共权限
public:

	//属性
	string m_Name;//姓名
	int m_ID;//学号

	//行为
	//显示姓名和学号
	void showStudent()
	{
		cout << "姓名："<< m_Name << "\t学号：" << m_ID << endl;
	}

	//给姓名赋值
	void setName(string name)
	{
		m_Name = name;
	}

	//给学号赋值
	void setID(int ID)
	{
		m_ID = ID;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

main函数：

	//设计一个圆类，求圆的周长
	//圆的周长公式：2 * PI *半径
	
	//实例化：通过一个类创建一个对象的过程
	//通过圆类创建具体的圆（对象）
	//语法：类名称 对象名称；
	Circle c1;
	//给圆对象的属性进行赋值
	c1.m_r = 10;

	cout << "圆的周长为：" << c1.calculateZC() << endl;
	
	
	//设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
	//创建一个具体的学生   实例化对象
	Student s1;
	//给s1对象进行属性赋值操作
	s1.m_Name = "张三";
	s1.m_ID = 1;
	//显示学生信息
	s1.showStudent();
	
	Student s2;
	s2.setName("李四");
	s2.setID(2);
	s2.showStudent();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1.2将属性和行为加以权限控制 //public 公共权限

//public 公共权限   成员在类内可以访问,类外也可以访问
//protected 保护权限   成员在类内可以访问，类外不可以访问  儿子也可以访问父亲中的保护内容
//private 私有权限   成员在类内可以访问，类外不可以访问   儿子不可以访问父亲中的私有内容
1
2
3

代码：

class Person
{
public://公共权限
	//姓名
	string m_Name;

protected://保护权限
	//汽车
	string m_Car;

private://私有权限
	//银行卡密码
	int m_Password;

public:
	void func()
	{
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}

};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

main函数：

	//将属性和行为加以权限控制
	//public 公共权限
	//protected 保护权限
	//private 私有权限
	
	//实例化具体对象
	Person p1;
	p1.m_Name = "王五";
	//p1.m_Car = "奔驰"; //错误，保护权限内容，在类外访问不到
	//p1.m_Password = 123;//错误，私有权限内容，类外访问不到
1
2
3
4
5
6
7
8
9
10

2.struct和class区别

//struct默认权限为公共
//class默认权限为私有
1
2

代码：

/*struct和class区别*/
	//struct默认权限为公共
	//class默认权限为私有
class C1
{
	int m_A;//默认权限是私有
};
struct C2
{
	int m_A;//默认权限是公共
};
1
2
3
4
5
6
7
8
9
10
11

main函数：

	/*struct和class区别*/
	//struct默认权限为公共
	//class默认权限为私有
	C1 cc1;
	//cc1.m_A = 100;//错误，class默认权限为私有，类外不可以访问
	C2 c2;
	c2.m_A = 100;//正确，struct默认权限为公共
1
2
3
4
5
6
7

3.成员属性设置为私有

//优点1：将所有成员属性设置为私有，可以自己控制读写权限
//优点2：对于写权限，我们可以检测数据的有效性
1
2

代码：

/*成员属性设置为私有*/
//优点1：将所有成员属性设置为私有，可以自己控制读写权限
//优点2：对于写权限，我们可以检测数据的有效性

//设计人的类
class Person1
{
public:
	//写姓名=设置姓名
	void setName(string name)
	{
		m_Name = name;
	}
	//读姓名=获取姓名
	string getName()
	{
		return m_Name;
	}
	//获取年龄  可读可写  如果想修改（年龄的范围必须是0-150之间）
	int getAge()
	{
		//m_Age = 0;//初始化为0岁
		return m_Age;
	}

	//设置年龄
	void setAge(int age)
	{
		if (age < 0 || age>150)
		{
			m_Age = 0;
			cout << "你这个老妖精！" << endl;
			return;//没有return的话会往下执行m_Age=age赋值操作，有return以后直接退出
		}
		m_Age = age;
	}

	//设置情人  只写
	void setLover(string lover)
	{
		m_Lover = lover;
	}

private:
	//姓名  可读可写
	string m_Name;
	//年龄  可读可写  如果想修改（年龄的范围必须是0-150之间）
	int m_Age;
	//情人  只写
	string m_Lover;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

main函数：

	/*成员属性设置为私有*/
	//优点1：将所有成员属性设置为私有，可以自己控制读写权限
	//优点2：对于写权限，我们可以检测数据的有效性
	Person1 pp1;
	pp1.setName("张六");
	cout << "姓名为：" << pp1.getName() << endl;
	pp1.setAge(1000);
	cout << "年龄为：" << pp1.getAge() << endl;
	pp1.setLover("王五");
1
2
3
4
5
6
7
8
9

4.设计长方体类

设计立方体类(Cube)
求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等

代码：

/*设计长方体类*/
//1.创建长方体类
//2.设计属性
//3.设计行为 获取长方体面积和体积
//4.分别利用全局函数和成员函数 判断两个长方体是否相等
class Cube
{
public:
	//设置长
	void setL(int l)
	{
		m_L = l;
	}

	//获取长
	int getL()
	{
		return m_L;
	}

	//设置宽
	void setW(int w)
	{
		m_W = w;
	}

	//获取宽
	int getW()
	{
		return m_W;
	}

	//设置高
	void setH(int h)
	{
		m_H = h;
	}

	//获取高
	int getH()
	{
		return m_H;
	}

	//获取长方体面积
	int calculateS()
	{
		return 2 * m_L*m_H + 2 * m_H*m_W + 2 * m_W*m_L;
	}

	//获取长方体体积
	int calculateV()
	{
		return m_H * m_L*m_W;
	}

	//利用成员函数判断两个长方体是否相等
	bool isSameByClass(Cube &cube)
	{
		//用getL()与cube.getL()判断或者m_L与cube.getL()判断
		if (getL() == cube.getL() && m_W == cube.getW() && m_H == cube.getH())
		{
			return true;
		}
		else
			return false;
	}

private:
	int m_L;//长
	int m_W;//宽
	int m_H;//高
};

//利用全局函数判断两个长方体是否相等
bool isSame(Cube &cube1, Cube &cube2)
{
	if (cube1.getL() == cube2.getL() && cube1.getW() == cube2.getW() && cube1.getH() == cube2.getH())
	{
		return true;
	}
	else
		return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

main函数：

	/*设计长方体类*/
	//实例化对象  创建长方体
	Cube cube1;
	cube1.setL(10);
	cube1.setH(10);
	cube1.setW(10);

	cout << "cube1的面积为：" << cube1.calculateS() << endl;
	cout << "cube1的体积为：" << cube1.calculateV() << endl;
	
	//创建第二个长方体
	Cube cube2;
	cube2.setL(10);
	cube2.setH(10);
	cube2.setW(10);

	//判断两个长方体是否相等
	//利用全局函数判断
	bool result1 = isSame(cube1, cube2);
	if (result1)
	{
		cout << "两个相等" << endl;
	}
	else
	{
		cout << "两个不相等" << endl;
	}

	//利用成员函数判断
	bool result2 = cube1.isSameByClass(cube2);
	if (result2)
	{
		cout << "两个相等	" << endl;
	}
	else
	{
		cout << "两个不相等	" << endl;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

代码：

#include <iostream>
#include<string>

using namespace std;


//创建全局变量
int global_a = 10;
int global_b = 10;

//const修饰的全局变量=全局常量
const int c_g_a = 10;
const int c_g_b = 10;



//栈区
int * func()
{
	int a = 10;//局部变量 存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;//返回局部变量的地址
}

int * func2(int b)//形参数据也会放在栈区
{
	b = 100;
	int a = 10;//局部变量 存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;//返回局部变量的地址
}

//堆区
int * func3()
{
	//利用new关键字，可以将数据开辟到堆区
	//指针 本质也是局部变量，放在栈区，但是指针保存的数据是放在堆区
	int*p = new int(10);//new int(10)返回整型数据10的地址
	return p;
}



//new
int * func4()
{
	//在堆区创建整型数据
	//new返回的是该数据类型的指针
	//语法：new 数据类型（变量值），这是创建一个变量
	int *p_new = new int(10);
	return p_new;
}

void test01()
{
	int*p = func4();
	cout << *p << endl;//输出10
	cout << *p << endl;//10
	cout << *p << endl;//10
	//堆区的数据 由程序员管理开辟，程序员管理释放
	//如果想释放堆区的数据，用delete释放  语法：delete 指针变量名称；
	delete p;
	//cout << *p << endl;//内存已经被释放，再次访问就是非法操作，会报错
}

//在堆区利用new开辟数组
void test02()
{
	//创建10个整型数据的数组，在堆区
	//语法： new 数据类型[数据值]，这是创建数据值个变量
	int *arr = new int[10];//10代表数组有10个元素
	for (int i = 0; i < 10; i++)
	{
		arr[i] = i + 100;//给10个元素赋值：100~109
	}
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
	//释放数组
	//语法：delete[] 指针变量名；
	delete[]arr;
}




//引用做函数参数
//交换函数
//1.值传递
void mySwap01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

	cout << "swap01\ta=" << a << "\tb=" << b << endl;//值传递形参发生改变
	return;
}

//2.地址传递
void mySwap02(int *a, int *b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
	return;
}



//3.引用传递
void mySwap03(int &a,int &b)
{
	int temp = a;
	a = b;
	b = temp;
	return;
}



/*引用做函数返回值*/
//语法：返回值类型 & 函数名称（参数列表) {函数体语句；return语句；}
//作用：引用是可以作为函数的返回值存在的
//1.不要返回局部变量的引用
int& test03()
{
	int a = 10;//局部变量存放在栈区
	return a;
}

//2.函数的调用可以作为左值
int& test04()
{
	static int a = 10;//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
	return a;
}



//引用的本质
//发现是引用，转换为 int* const ref = &a; 
void func5(int& ref) 
{
	ref = 100;
	// ref是引用，转换为*ref = 100 
	cout << "func5\tref=" << ref << endl;
} 


//打印数据函数
void showValue(int &val)
{
	val = 1000;
	cout << "value=" << val << endl;
}

//打印数据函数2
void showValue2(const int &val)
{
	//val = 1000;//错误，不可修改
	cout << "value=" << val << endl;
}



/*函数默认参数*/
int func6(int a, int b=20, int c=30)
{
	return a + b + c;
}

int func7(int a, int b=1, int c=2 )	//1.如果某个位置已经有了默认参数，那么从这个位置往后都必须有默认值
{
	return a + b + c;
}

//2.如果函数声明有默认参数，函数实现就不能有默认参数
//函数声明和函数实现只能有一个有默认参数,两者任选一个给默认值就可以
//int func8(int a=10, int b=20);//函数声明

int func8(int a=10, int b = 20)//函数实现
{
	return a + b ;
}


/*占位参数*/
//占位参数还可以有默认值 比如：void func9(int a,int =10)
void func9(int a,int)
{
	cout << "this is func9" << endl;
}



/*函数重载*/
//可以让函数名相同，提高复用性
//函数重载满足条件：
//1.同一个作用域下
//2.函数名称相同
//3.函数参数类型不同或者个数不同或者顺序不同

void funct()
{
	cout << "funct的调用" << endl;
}

void funct(int a)
{
	cout << "funct(int a)的调用" << endl;
}

void funct(double a)
{
	cout << "funct(double a)的调用" << endl;
}

void funct(int a, double b)
{
	cout << "funct(int a,double b)的调用：" << endl;
}

void funct(double a, int b)
{
	cout << "funct(double a, int b)的调用：" << endl;
}

//注意：函数的返回值不可以作为函数重载的条件  int跟void返回值不同，不可以作为重载的条件
//int funct(double a, int b)
//{
//	cout << "funct(double a, int b)的调用：" << endl;
//}


//函数重载注意事项
//1.引用作为重载条件
void fun(int &a)
{
	cout << "fun(int &a)调用" << endl;
}

void fun(const int &a)
{
	cout << "fun(const int &a)调用" << endl;
}
//2.函数重载碰到函数默认参数
void fun2(int a)
{
	cout << "fun2(int a)的调用" << endl;
}

void fun2(int a,int b=10)
{
	cout << "fun2(int a)的调用" << endl;
}



/*类和对象*/

/*封装*/

//将属性和行为作为一个整体，表现生活中的事物
//语法：class 类名 { 访问权限： 属性；行为；}；

//圆周率
const double PI = 3.14;

//设计一个圆类，求圆的周长
//圆的周长公式：2 * PI *半径
//class 代表设计一个类，类后面紧跟着的是类名称
class Circle
{
	//访问权限
public://公共权限

	//属性
	int m_r;//半径

	//行为，通常用函数来表示
	//获取圆的周长
	double calculateZC()
	{
		return 2 * PI*m_r;
	}

};

//设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
//设计学生类
class Student
{
	//公共权限
public:

	//属性
	string m_Name;//姓名
	int m_ID;//学号

	//行为
	//显示姓名和学号
	void showStudent()
	{
		cout << "姓名："<< m_Name << "\t学号：" << m_ID << endl;
	}

	//给姓名赋值
	void setName(string name)
	{
		m_Name = name;
	}

	//给学号赋值
	void setID(int ID)
	{
		m_ID = ID;
	}
};


//将属性和行为加以权限控制
	//public 公共权限   成员在类内可以访问,类外也可以访问
	//protected 保护权限   成员在类内可以访问，类外不可以访问  儿子也可以访问父亲中的保护内容
	//private 私有权限   成员在类内可以访问，类外不可以访问   儿子不可以访问父亲中的私有内容

class Person
{
public://公共权限
	//姓名
	string m_Name;

protected://保护权限
	//汽车
	string m_Car;

private://私有权限
	//银行卡密码
	int m_Password;

public:
	void func()
	{
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}

};



/*struct和class区别*/
	//struct默认权限为公共
	//class默认权限为私有
class C1
{
	int m_A;//默认权限是私有
};
struct C2
{
	int m_A;//默认权限是公共
};


/*成员属性设置为私有*/
//优点1：将所有成员属性设置为私有，可以自己控制读写权限
//优点2：对于写权限，我们可以检测数据的有效性

//设计人的类
class Person1
{
public:
	//写姓名=设置姓名
	void setName(string name)
	{
		m_Name = name;
	}
	//读姓名=获取姓名
	string getName()
	{
		return m_Name;
	}
	//获取年龄  可读可写  如果想修改（年龄的范围必须是0-150之间）
	int getAge()
	{
		//m_Age = 0;//初始化为0岁
		return m_Age;
	}

	//设置年龄
	void setAge(int age)
	{
		if (age < 0 || age>150)
		{
			m_Age = 0;
			cout << "你这个老妖精！" << endl;
			return;//没有return的话会往下执行m_Age=age赋值操作，有return以后直接退出
		}
		m_Age = age;
	}

	//设置情人  只写
	void setLover(string lover)
	{
		m_Lover = lover;
	}

private:
	//姓名  可读可写
	string m_Name;
	//年龄  可读可写  如果想修改（年龄的范围必须是0-150之间）
	int m_Age;
	//情人  只写
	string m_Lover;
};



/*设计长方体类*/
//1.创建长方体类
//2.设计属性
//3.设计行为 获取长方体面积和体积
//4.分别利用全局函数和成员函数 判断两个长方体是否相等
class Cube
{
public:
	//设置长
	void setL(int l)
	{
		m_L = l;
	}

	//获取长
	int getL()
	{
		return m_L;
	}

	//设置宽
	void setW(int w)
	{
		m_W = w;
	}

	//获取宽
	int getW()
	{
		return m_W;
	}

	//设置高
	void setH(int h)
	{
		m_H = h;
	}

	//获取高
	int getH()
	{
		return m_H;
	}

	//获取长方体面积
	int calculateS()
	{
		return 2 * m_L*m_H + 2 * m_H*m_W + 2 * m_W*m_L;
	}

	//获取长方体体积
	int calculateV()
	{
		return m_H * m_L*m_W;
	}

	//利用成员函数判断两个长方体是否相等
	bool isSameByClass(Cube &cube)
	{
		//用getL()与cube.getL()判断或者m_L与cube.getL()判断
		if (getL() == cube.getL() && m_W == cube.getW() && m_H == cube.getH())
		{
			return true;
		}
		else
			return false;
	}

private:
	int m_L;//长
	int m_W;//宽
	int m_H;//高
};

//利用全局函数判断两个长方体是否相等
bool isSame(Cube &cube1, Cube &cube2)
{
	if (cube1.getL() == cube2.getL() && cube1.getW() == cube2.getW() && cube1.getH() == cube2.getH())
	{
		return true;
	}
	else
		return false;
}

int main()
{
	/*设计长方体类*/
	//实例化对象  创建长方体
	Cube cube1;
	cube1.setL(10);
	cube1.setH(10);
	cube1.setW(10);

	cout << "cube1的面积为：" << cube1.calculateS() << endl;
	cout << "cube1的体积为：" << cube1.calculateV() << endl;
	
	//创建第二个长方体
	Cube cube2;
	cube2.setL(10);
	cube2.setH(10);
	cube2.setW(10);

	//判断两个长方体是否相等
	//利用全局函数判断
	bool result1 = isSame(cube1, cube2);
	if (result1)
	{
		cout << "两个相等" << endl;
	}
	else
	{
		cout << "两个不相等" << endl;
	}

	//利用成员函数判断
	bool result2 = cube1.isSameByClass(cube2);
	if (result2)
	{
		cout << "两个相等	" << endl;
	}
	else
	{
		cout << "两个不相等	" << endl;
	}

	
	/*成员属性设置为私有*/
	//优点1：将所有成员属性设置为私有，可以自己控制读写权限
	//优点2：对于写权限，我们可以检测数据的有效性
	Person1 pp1;
	pp1.setName("张六");
	cout << "姓名为：" << pp1.getName() << endl;
	pp1.setAge(1000);
	cout << "年龄为：" << pp1.getAge() << endl;
	pp1.setLover("王五");
	
	/*struct和class区别*/
	//struct默认权限为公共
	//class默认权限为私有
	C1 cc1;
	//cc1.m_A = 100;//错误，class默认权限为私有，类外不可以访问
	C2 c2;
	c2.m_A = 100;//正确，struct默认权限为公共
	
	
	

	/*类和对象*/
	//c++面向对象的三大特性为：封装、继承、多态
	//C++认为万事万物都皆为对象，对象上有其属性和行为
	//例如：
		//人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...
		//车也可以作为对象，属性有轮胎、方向盘、车灯..., 行为有载人、放音乐、放空调...
	//具有相同性质的 == 对象 == ，我们可以抽象称为 == 类 == ，人属于人类，车属于车类
	
	
	/*封装*/
	//封装的意义：
		//将属性和行为作为一个整体，表现生活中的事物
		//将属性和行为加以权限控制
	

	//将属性和行为作为一个整体，表现生活中的事物
	//语法：class 类名 { 访问权限： 属性；行为；}；
	//类中的属性和成员，统一称为成员
	//属性=成员属性=成员变量
	//行为=成员函数=成员方法

	//设计一个圆类，求圆的周长
	//圆的周长公式：2 * PI *半径
	
	//实例化：通过一个类创建一个对象的过程
	//通过圆类创建具体的圆（对象）
	//语法：类名称 对象名称；
	Circle c1;
	//给圆对象的属性进行赋值
	c1.m_r = 10;

	cout << "圆的周长为：" << c1.calculateZC() << endl;
	
	
	//设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
	//创建一个具体的学生   实例化对象
	Student s1;
	//给s1对象进行属性赋值操作
	s1.m_Name = "张三";
	s1.m_ID = 1;
	//显示学生信息
	s1.showStudent();
	
	Student s2;
	s2.setName("李四");
	s2.setID(2);
	s2.showStudent();
	
	//将属性和行为加以权限控制
	//public 公共权限
	//protected 保护权限
	//private 私有权限
	
	//实例化具体对象
	Person p1;
	p1.m_Name = "王五";
	//p1.m_Car = "奔驰"; //错误，保护权限内容，在类外访问不到
	//p1.m_Password = 123;//错误，私有权限内容，类外访问不到



	
	/*内存分区模型*/

	//内存大方向分为四个区域
	//代码区：存放函数体的二进制代码，由操作系统进行管理
	//全局区：存放全局变量和静态变量以及常量
	//栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
	//堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收



	/*程序运行之前：代码区，全局区*/

	//代码区：存放CPU执行的机器指令
	//代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
	//代码区是只读的，使其只读的原因是防止程序意外地修改它的指令

	//全局区包括：全局变量、静态变量、全局常量、字符串常量
	//全局区的数据在程序结束后由操作系统释放

	//创建普通局部变量
	int a1 = 10;
	int b1 = 10;

	cout << "局部变量a1的地址为：" << (int)&a1 << endl;
	cout << "局部变量b1的地址为：" << (int)&b1 << endl;

	//输出定义的全局变量
	cout << "全局变量global_a的地址为：" << (int)&global_a << endl;
	cout << "全局变量global_b的地址为：" << (int)&global_b << endl;

	//创建静态变量,在普通变量前加static就属于静态变量
	//语法：static 数据类型 变量名称；
	static int static_a = 10;
	static int static_b = 10;

	cout << "静态变量static_a的地址为：" << (int)&static_a << endl;
	cout << "静态变量static_b的地址为：" << (int)&static_b << endl;

	//常量
	//字符串常量  语法："..."
	cout << "字符串常量的地址为：" << (int)&"hello world" << endl;

	//const修饰的变量：修饰全局变量、修饰局部变量
	//const修饰的全局变量
	cout << "全局常量c_g_a的地址为：" << (int)&c_g_a << endl;
	cout << "全局常量c_g_b的地址为：" << (int)&c_g_b << endl;

	//const修饰的局部变量
	//c-const，g-global，l-local
	const int c_l_a = 10;
	const int c_l_b = 10;

	cout << "局部常量c_l_a的地址为：" << (int)&c_l_a << endl;
	cout << "局部常量c_l_b的地址为：" << (int)&c_l_b << endl;
	//全局常量、全局变量、静态变量和字符串常量放在全局区，局部常量和局部变量不在全局区

	//总结
	//C++中在程序运行前分为全局区和代码区 
	//代码区特点是共享和只读 
	//全局区中存放全局变量、静态变量、常量 
	//常量区中存放const修饰的全局常量和字符串常量



	/*程序运行后：栈区和堆区*/
	//栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
	//注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放
	
	//接收func函数的返回值
	int *p = func();

	cout << *p << endl;//输出10 //第一次可以打印正确的数字，是因为编译器做了一次保留
	cout << *p << endl;//输出乱码 //第二次这个数据就不再保留

	//堆区;由程序员分配释放，若程序员不释放，程序结束时由操作系统回收
	//在C++中主要利用new在堆区开辟内存
	int *p_dq = func3();
	
	cout << *p_dq << endl;//输出10
	cout << *p_dq << endl;//输出10



	/*new操作符*/
	//利用new在堆区开辟数据
	//语法：new 数据类型
	//利用new创建的数据，会返回该数据对应类型的指针
	//堆区开辟的数据，由程序员手动开辟，手动释放，释放利用delete进行
	test01();
	test02();



	/*引用*/
	//引用：给变量起别名
	//语法：数据类型 &别名=原名；
	int a_yy = 10;
	int &b_yy = a_yy;
	
	cout << "a=" << a_yy << endl;//输出10
	cout << "b=" << b_yy << endl;//10

	b_yy = 100;//通过修改b_yy,此时a_yy、b_yy都修改为100

	cout << "a=" << a_yy << endl;//输出100
	cout << "b=" << b_yy << endl;//100

	//引用注意事项
	//引用必须初始化
	int a_zy = 10;
	//int &b_zy; //错误，必须要初始化
	int &b_zy = a_zy;//一旦初始化后，就不可以更改

	cout << "a=" << a_zy << endl;//输出10
	cout << "b=" << b_zy << endl;//输出10

	//引用在初始化后，不可以改变
	int c_zy = 20;
	b_zy = c_zy;//赋值操作，而不是更改引用
	//把b_zy赋值了20，此时a_zy和b_zy都是20

	cout << "a=" << a_zy << endl;//输出20
	cout << "b=" << b_zy << endl;//输出20
	cout << "c=" << c_zy << endl;//输出20


	/*引用做函数参数*/
	//作用：函数传参时，可以利用引用的技术让形参修饰实参
	//优点：可以简化指针修改实参
	int a_yyhs = 10;
	int b_yyhs = 20;

	cout << "交换前：" << endl;
	cout << "a_yyhs=" << a_yyhs << "\tb_yyhs=" << b_yyhs << endl;

	mySwap01(a_yyhs, b_yyhs);//值传递，形参不会修饰实参，main函数仍然输出原来的值
	cout << "值传递交换后：" << endl;
	cout << "a_yyhs=" << a_yyhs << "\tb_yyhs=" << b_yyhs << endl;

	mySwap02(&a_yyhs, &b_yyhs);//地址传递，形参会修饰实参
	cout << "地址传递交换后：" << endl;
	cout << "a_yyhs=" << a_yyhs << "\tb_yyhs=" << b_yyhs << endl;

	mySwap03(a_yyhs, b_yyhs);//引用传递，形参会修饰实参
	cout << "引用传递交换后：" << endl;
	cout << "a_yyhs=" << a_yyhs << "\tb_yyhs=" << b_yyhs << endl;
	//通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单



	/*引用做函数返回值*/
	//作用：引用是可以作为函数的返回值存在的
	//1.不要返回局部变量的引用
	int &ref = test03();

	cout << "ref=" << ref << endl;//第一次正确，输出10，是因为编译器做了保留
	cout << "ref=" << ref << endl;//第二次错误，因为内存已经释放

	int & ref2 = test04();
	cout << "ref2=" << ref2 << endl;//输出10
	cout << "ref2=" << ref2 << endl;//输出10

	//2.函数的调用可以作为左值
	test04() = 1000;//函数调用作为左值，必须返回引用，这就相当于a=1000的赋值操作

	cout << "函数调用作为左值赋值后：" << endl;
	cout << "ref2=" << ref2 << endl;//输出1000
	cout << "ref2=" << ref2 << endl;//输出1000



	/*引用的本质*/
	//本质：引用的本质在C++内部实现是一个指针常量,一旦初始化后就不可以发生改变
	int a_bz = 10;          
	//自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改  
	int& ref_bz = a_bz;  
	ref_bz = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;       
	cout << "a:" << a_bz << endl;  
	cout << "ref:" << ref_bz << endl;      
	func5(a_bz);  



	/*常量引用*/
	//作用：常量引用主要用来修饰形参，防止误操作
	//在函数形参列表中，可以加const修饰形参，防止形参改变实参
	//语法：返回值类型 函数名称（const 变量类型 & 引用名称）{ 函数体语句；return语句；}
	int a_xs = 10;
	//int &ref_xs = 10;//错误，引用必须引一块合法的内存空间
	const int & ref_xs = 10;//正确，加上const以后，编译器将代码修改为int temp=10;const int & ref_xs=temp;
	//ref_xs = 20;//错误，加入const之后变为只读，不可以修改

	//打印a_xs
	showValue(a_xs);//输出1000
	cout << "a_xs=" << a_xs << endl;//输出1000

	//防止误操作
	int b_xs = 20;
	showValue2(b_xs);//输出20
	cout << "b_xs=" << b_xs << endl;//输出20



	/*函数默认参数*/
	//在C++中，函数的形参列表中的形参是可以有默认值的
	//语法：返回值类型 函数名称（参数=默认值）{ 函数体语句；return语句；}
	//如果我们自己传入数据，就用自己的数据；如果没有，那么用默认值
	cout << func6(10) << endl;//10+20+30=60
	cout << func6(10,30) << endl;//10+30+30=70
	//注意事项
	//1.如果某个位置已经有了默认参数，那么从这个位置往后都必须有默认值
	//2.如果函数声明有默认参数，函数实现就不能有默认参数
	cout << func8(10, 20) << endl;



	/*占位参数*/
	//C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
	//语法：返回值类型 函数名（参数1，...,数据类型）{ 函数体语句；return语句；}
	
	func9(10,1);//占位参数必须填补
	//func9(10) //占位参数有默认值



	/*函数重载*/
	//函数重载满足条件：
	//1.同一个作用域下
	//2.函数名称相同
	//3.函数参数类型不同或者个数不同或者顺序不同
	//注意：函数的返回值不可以作为函数重载的条件
	funct();
	funct(10);
	funct(3.14);
	funct(10, 3.14);
	funct(3.14, 10);



	/*函数重载注意事项*/
	//1.引用作为重载条件
	//int a_cz = 10;
	//fun(a_cz); //调用fun（int &a)

	fun(10);//调用fun(const int &a)

	//2.函数重载碰到默认参数
	//fun2(10);//当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况



	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882