C++学习记录（1）

2021.11.10

程序中的内存模型：

C++在程序运行之前分为全局区和代码区

代码区：存放CPU执行的机器指令，

        共享，对于频繁被执行的程序，只需要在内存中有一份代码即可

        只读，防止程序意外地修改了指令

全局区：存放全局变量、静态变量、常量（存放const修饰的全局变量、字符串常量），该区域的数据在程序结束后由操作系统释放。

不在全局区中：局部变量、const修饰的局部变量

栈区：由编译器自动分配释放，存放函数的参数值、局部变量等（不要返回局部变量的地址，栈区开辟的数据由编译器自动释放）

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

int * a = new int(10);      //10表示整形10
int * arr = new int[10];    //10表示数组有10个元素

   若果想释放堆区的数据，利用关键字delete。

delete a;
delete []arr;

C++中的引用

作用：给变量起别名

语法：数据类型  &别名  = 原名

int a = 10;    
int &b = a;    //引用必须初始化，引用在初始化后不可以改变

1.引用作函数参数

void swap(int &a, int &b)    //引用传递，形参会修饰实参，地址传递(指针)也可以
{
    int temp = a;
    a = b;
    b = temp;
}

2.引用做函数返回值

int &a = test();              //不要返回局部变量引用
cout << "a = " << a << endl;
test() = 1000                //如果函数的返回值是引用，这个函数调用可以作为左值
cout << "a = " << a << endl;

3.引用的本质：在C++内部实现就是指针常量

int& ref = a;        //相当于  int* const ref = &a ;

************************************分割线******************************************************

2021.11.11

函数

1.函数的默认参数

如果某个位置参数有默认值，那么这个位置往后，从左向右，必须要有默认值；如果函数声明有默认值，则函数实现的时候就不能有默认参数（二者只有一个有默认参数）。

2.占位参数

返回函数值类型    函数名（数据类型）{ }        

void func(int a, int)    //占位参数还可以有默认值，如  void func(int a ,int = 10)
{}

3.函数重载

满足条件：①同一个作用域；②函数名相同；③函数参数类型不同，或者个数不同，或者顺序不同

void func() { }
void func(int a) { }
void func(int a ,double b) { }
void func(double a , int b) { }

类和对象

1.类的访问权限：

public        公共权限        类内可以访问        类外可以访问

protected        保护权限        类内可以访问        类外不可以访问

private        私有权限        类内可以访问        类外不可以访问

2.class和struct的区别

class默认权限是私有权限，struct默认权限是private

3.成员属性私有化

①可以自己控制读写权限；②对于写权限，我们可以检测数据的有效性。

4.构造函数和析构函数

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

①没有返回值，不写void；②函数名称与类名相同；③构造函数可以有参数，因此可以发生重载；④程序在调用对象的时候会自动调用构造，无需手动调用，而且只会调用一次。

析构函数语法：~类名（）{ }

①没有返回值，不写void；②函数名称和类名相同，因此在名称前加上符号~；③析构函数不可以有参数，因此不能发生重载；④程序在对象销毁前会自动调用析构函数，无需手动，只调用一次。

**********************************************分割线**************************************************

2021.11.21

1.构造函数的分类

按照参数分类为：有参构造和无参构造，无参构造又称默认构造

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

Person(){        }        //无参构造
Person(int a ) {        }    //有参构造
Person(const Person & p)     {    }    //拷贝构造

2.构造函数的调用

无参构造调用

Person p;

有参构造函数调用：括号法、显式法、隐式转换法

Person p1(10);        //括号法，常用
Person p2 = Person(10);    //显式法，普通构造
Person p3 = Person(p2);    //显式法，拷贝构造
Person p4 = 10;            //隐式转换法，普通构造
Person p5 = p4;            //隐式转换法，拷贝构造

3.拷贝构造函数调用时机

（1）使用一个已经创建完毕的对象来初始化一个新对象

（2）值传递的方式给函数参数传值、

（3）以值方式返回局部对象

//使用已经创建完毕的对象来初始化一个新对象
Person p1(20);
Person p2(p1);
//值传递的方式给函数参数传值，其中，func(Person p) {  }
func(p);
//值方式返回局部对象，其中，Person func() { ...; return *; }
Person p = func();

4.构造函数调用规则

（1）如果定义了有参构造函数，就不会提供无参构造，但会提供拷贝构造

（2）如果定义了拷贝构造函数，不会提供其他构造函数

5.深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

下面是一个深拷贝和浅拷贝的例子，这是构造函数和析构函数初始化

class Person {
public:
	Person() {
		cout << "无参构造函数调用" << endl;
	}
	//有参构造函数
	Person(int age,int height) {
		m_Age = age;
		m_Height = new int(height);
		cout << "有参构造函数调用" << endl;
	}
	//拷贝构造函数
	Person(const Person &p) {
		cout << "拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
		m_Height = new int(*p.m_Height);    //深拷贝，重新申请一块内存空间用于存放拷贝的数据
	}
	~Person() {
		cout << "析构函数调用" << endl;
		if (m_Height != NULL)    //因为深拷贝重新申请了内存空间，使用完后需要手动释放
		{
			delete m_Height;
			m_Height = NULL;
		}
	}
	int m_Age;
	int *m_Height;
};

**********************************************分割线**************************************************

2021.11.22

1.初始化列表

语法：  构造函数():属性1(值1),属性2(值2)...{    }          

Person(int a , int b, int c):m_A(a), m_B(b), m_C(c) { 
}                    //其中m_A, m_B, m_C是类中定义的3个变量

2.类对象作为类成员

class Phone
{
public:
    Phone(string pname){
        m_Pname = pname;
    }
    string m_Pname;
};

class Person
{
public:
    Person(string name, string pname):m_Name(name),m_Phone(pname){
        
    }
    string m_Name;
    Phone m_Phone;        //Phone类作为Person类的成员
};

当类中成员是其他类对象时，我们称该成员为对象成员

构造的顺序是：先调用对象成员的构造，再调用本类构造

析构的顺序：与构造相反（先进后出、迟到早退）

3.静态成员

静态成员变量：所有对象共享同一份数据、在编译阶段分配内存、类内声明类外初始化

静态成员函数：所有对象共享同一个函数，静态成员函数只能访问静态成员变量

class Person{
public:
    static void func()       //静态成员函数
    {
        m_A = 100;
    }
    static int m_A;        //静态成员变量
};
int Person::n_A = 10;        //类内定义，类外初始化
//静态成员函数两种访问方式
Person p1;
p1.func();                //通过对象调用
Person :: func();           //通过类名访问

4.对象模型和this指针

C++中成员变量和成员函数是分开存储的，空对象占1个字节用于区分空对象占内存的位置。

this指针概念：this指针是隐含每一个非静态成员函数内的一种指针，不需要定义，直接使用，指向被调用的成员函数所属的对象。

用途：当形参和成员变量同名时，可用this指针来区分；在类的非静态成员函数中返回对象时，可使用return *this

class Person {
public:
	Person(int age) {
		this->age = age;
	}

	Person & PersonAddPerson(Person p) {
		this->age += p.age;
		return *this;
	}

	int age;
};
//调用
	Person p1(10);
	Person p2(10);
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);         //链式编程

5.空指针访问成员函数

空指针也是可以调用成员函数的，但是也要注意有没有用到this指针，如果用到this指针，需要加以判断保证代码的健壮性。类内加入如下代码

if(this==NULL){
    return;
}

6.const修饰成员函数

常函数：成员函数加const之后我们称为常函数，常函数内不可修改成员属性，成员属性声明时加了mutable之后，在常函数中依然可以修改。

常对象：声明对象前加上const，常对象只能调用常函数

class Person {
public:
	void showName() const        //常函数
	{
		//m_A = 10;	//常函数中不可修改成员属性
		m_B = 10;	//加了mutable关键字后，可在常函数中修改
	}
	void func()  {  }
	int m_A;
	mutable int m_B;
};
//调用
	Person p1;
	p1.showName();
	p1.func();
	const Person p2;     //常对象
	p2.showName();
	//p2.func();		//常对象只能调用常函数

7.全局函数作友元

友元的目的：让一个函数或类访问另一个类中私有成员，关键字friend

友元的三种实现：全局函数作友元、类作友元、成员函数作友元

class Building {
	friend void goodGay(Building &build);        //全局函数作友元
public:
	Building() {
		m_SittingRom = "客厅";
		m_BedRoom = "卧室";
	}
public:
	string m_SittingRom;		//客厅
private:
	string m_BedRoom;			//卧室
};

void goodGay(Building &build)
{
	cout << "正在访问：" << build.m_SittingRom << endl;
	cout << "正在访问：" << build.m_BedRoom << endl;
}

8.类作友元

class Building
{
	friend class GoodGay;        //类作友元
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};

class GoodGay		//若GoodGay类写在前面，需要先声明Building类，class Building;
{
public:
	GoodGay();
	void visit();
	Building *building;
};
//类外写成员函数
GoodGay::GoodGay()
{
	building = new Building;
}
void GoodGay::visit()
{
	cout << "正在访问：" << building->m_SittingRoom << endl;
	cout << "正在访问：" << building->m_BedRoom << endl;
}
//调用
GoodGGay gg;
gg.visit();

9.成员函数作友元

将上述代码GoodGay类中的visit成员函数作为友元，只需要在Building类中添加如下代码

//将friend class GoodGay; 替换成如下代码
friend void GoodGay::visit();