C++核心编程

C++核心编程

1、程序的内存模型

1.1程序运行前

1、代码区

存放CPU执行的机器指令

• 共享：对于频繁被执行的程序只在内存中有一份代码
• 只读：防止程序意外修改指令

2、全局区

存放全局变量和静态变量
全局区还包含了常量区：包含了字符串常量和其他常量
该区域数据在程序结束后释放。
全局区以外的：局部变量和const修饰的局部变量（局部常量）

1.2程序运行后

3、栈区

编译器自动释放，存放函数的参数值（形参），局部变量等。

4、堆区

由程序员分配释放，若不释放，程序结束时由操作系统回收
在C++中利用new在堆区开辟内存：

int *p = new int(10);  //创建一个整型变量
int *arr = new int[10]; //创建10个整形数据的数组

释放利用操作符delete：

delete p;//释放堆区int变量
delete[] arr;//释放堆区数组

2、引用

2.1引用的基本使用

作用：给变量起别名
语法：数据类型 &别名 = 原名

int a = 10;
int &b = a;

2.2引用的注意事项

• 引用必须初始化

int &b;//错误

• 引用初始化后，就不可以更改

2.3引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参（值传递时，形参不会修饰实参）
优点：简化指针修改实参

//1.值传递、实参不会交换
void mySwap01(int a, int b)
 {
	int temp = a;
	a = b;
	b = temp;
}
//2. 地址传递、实参会交换
void mySwap02(int* a, int* b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}

//3. 引用传递、实参会交换
void mySwap03(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}

2.4引用做函数返回值

作用：引用是可以作为函数的返回值存在的
注意：不要返回局部变量引用，可用static将变量变成静态变量再返回

int& test02() 
{
	static int a = 20;
	return a;
}

用法：函数调用作为左值

test02() = 1000;

2.5 引用的本质

本质：引用的本质在c++内部实现是一个指针常量.

int& ref = a;//自动转换为int* const ref = &a;
ref = 20;//自动转换为 *ref = 20;

2.6常量引用

作用：常量引用主要用来修饰形参，防止误操作

在函数形参列表中，可以加const修饰形参，防止形参改变实参

void showValue(const int& v)
 {
	v += 10;    //报错，因为常量不可修改
	cout << v << endl;
}

函数提高

3.1函数默认参数

int func(int a, int b = 10, int c = 10)
 {
	return a + b + c;
}
//1. 默认值必须放最后
//2. 声明和实现只能有一初地方写默认值

3.2 函数占位参数

void func(int a, int) //占位参数可以有默认值
{
	cout << "this is func" << endl;
}
int main() {

	func(10,10); //占位参数必须填补

	system("pause");

	return 0;
}

3.3 函数重载

作用： 函数名可以相同，提高复用性

函数重载满足条件：

• 同一个作用域下
• 函数名称相同
• 函数参数类型不同 或者 个数不同 或者 顺序不同

函数重载注意事项：

• 引用作为重载条件

//1、引用作为重载条件
void func(int &a)
{
	cout << "func (int &a) 调用 " << endl;
}

void func(const int &a)
{
	cout << "func (const int &a) 调用 " << endl;
}
int a = 10;
func(a); //调用无const
func(10);//调用有const

• 函数重载碰到函数默认参数

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

void func2(int a)
{
	cout << "func2(int a) 调用" << endl;
}
//当调用func2(10)时，会产生歧义，报错

4、类和对象

4.1封装

在设计类的时候，属性和行为写在一起，表现事物

语法： class 类名{ 访问权限： 属性 / 行为 };

//封装一个圆类，求圆的周长
//class代表设计一个类，后面跟着的是类名

class Circle
{
public:  //访问权限  公共的权限

	//属性
	int m_r;//半径

	//行为
	//获取到圆的周长
	double calculateZC()
	{
		//2 * pi  * r
		//获取圆的周长
		return  2 * PI * m_r;
	}
};

int main() {

	//通过圆类，创建圆的对象
	// c1就是一个具体的圆
	Circle c1;
	c1.m_r = 10; //给圆对象的半径 进行赋值操作

	//2 * pi * 10 = = 62.8
	cout << "圆的周长为： " << c1.calculateZC() << endl;

	system("pause");

	return 0;
}

访问权限有三种：

1. public 公共权限 类内可以访问 类外可以访问
2. protected 保护权限 类内可以访问 类外不可以访问
3. private 私有权限 类内可以访问 类外不可以访问

保护权限和私有权限在继承时有所区别。

struct和class的区别：

• struct 默认权限为公共
• class 默认权限为私有

成员属性设置为私有：

优点1： 将所有成员属性设置为私有，可以自己控制读写权限

可以设置函数提供对外的接口

优点2： 对于写权限，我们可以检测数据的有效性

	//设置年龄
	void setAge(int age) {
		if (age < 0 || age > 150) {
			cout << "输入年龄错误" << endl;
			return;
		}
		m_Age = age;
	}

4.2对象的初始化和清理

4.2.1 构造函数和析构函数

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名(){}

1. 构造函数，没有返回值也不写void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数语法： ~类名(){}

1. 析构函数，没有返回值也不写void
2. 函数名称与类名相同,在名称前加上符号 ~
3. 析构函数不可以有参数，因此不可以发生重载
4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};

4.2.2 构造函数的分类及调用

两种分类方式：

​ 按参数分为： 有参构造和无参构造

​ 按类型分为： 普通构造和拷贝构造

三种调用方式：

​ 括号法

​ 显示法

​ 隐式转换法

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};
//调用有参的构造函数
void test02() {

	//2.1  括号法，常用
	Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p2 = Person