C++高级编程的一些细节问题

1、引用 （&）

引用的本质：常量指针。数据类型 * const 变量名，如int * const p。
对于常量指针，不能修改指针指向，可修改指向的内容。
用引用的操作可以直接修改实参

2、函数重载

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

函数重载满足条件：

• 同一个作用域下
• 函数名相同
• 函数参数类型不同或者个数不同或者顺序不同
  注意：函数的返回值不可以作为函数重载的条件

3、struct和class的区别

在C++中，struct和class都可以表示一个类，唯一的区别就在于默认访问权限不同。

区别：

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

4、深拷贝与浅拷贝

• 浅拷贝：简单的赋值拷贝操作
• 深拷贝：在堆区重新申请空间，进行拷贝操作

5、静态成员变量、静态成员函数

• 静态成员变量
  静态成员变量不属于类对象上
  static关键字开头的变量，如static int a;注意，在类内定义静态成员变量时，要在类外进行声明，声明的格式为：数据类型 类名::变量名；如：int Student :: a;
• 静态成员函数：
  特点： 程序共享一个函数；
  静态成员函数只可以访问静态成员变量，不可以访问非静态成员变量。
  如：

int Student :: b; //静态变量声明
class Student {
public:
	static void func()
	{
		b = 100; //正确，静态成员函数可以访问静态成员变量
		//a = 200; //错误，静态成员函数不可以访问非静态变量
	}
	
	int a;
	static int b;
};

6、const修饰成员函数

常函数：

• 在成员函数后面加const，我们称这个函数为常函数。如void func() const {};
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字 mutable后，在常函数中依然可以修改

常对象：

• 声明对象前加const称该对象为常对象
• 常对象只能调用常函数

7、友元

• 1、全局函数做友元
  正常类内的私有属性类外是不可以访问的，但是，在类内加入friend关键字，并在类内声明，那么该全局函数就可以访问类内的私有属性了。
  格式： friend 返回值类型 函数名 (参数1，参数2，...)
  例如：

class Building
{
	friend void VisitBedRoom(Building &building); //将该全局函数做友元，就可以访问类内属性了
public:
	Building()
	{
		SittingRoom = "客厅";
		BedRoom = "卧室";
	}
	string SittingRoom;
private:
	string BedRoom;
};

void VisitBedRoom(Building &building)
{
	cout << "我正在访问：" << building.BedRoom << endl;
}

void test01()
{
	Building building;
	VisitBedRoom(building);
}

int main()
{
	test01();
	return 0;
}

• 2、类做友元
• 3、成员函数做友元
  在需要背访问的类内，加入需要访问的成员函数的声明，并加入friend关键字，同时声明该成员函数的作用域。
  格式： friend 返回值类型 所属类名 :: 成员函数名（参数1，参数2...）；
  例如：

class A{
	friend void B::func(); //成员函数func()做友元
public:

private:
	int a;
};
class B{
	void func()
	{
	}
};

8、运算符重载

概念： 对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。
语法： 自定义数据类型 operator 重载符号 （参数1， 参数2，...）
例如：

class Person
{
public:
	int m_A;
	int m_B;
	//成员函数重载 + 号
	Person operator +(Person& p1)
	{
		Person temp;
		temp.m_A = p1.m_A + this->m_A;
		temp.m_B = p1.m_B + this->m_B;
		return temp;
	}
};

//全局函数重载 + 号
Person operator +(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}

9、继承

语法： class 子类 ：继承方式 父类
如：class Son : public Father{ };
继承方式：

• 1、public方式继承
  父类中的私有属性，子类无法访问，其他都可以访问；类外只可以访问父类的公共属性，不可以访问保护属性以及私有属性。
• 2、protected方式继承
  父类中的私有属性，子类无法访问，其他都可以访问，且都变成保护属性；类外无法访问。
• 3、private方式继承
  父类中的私有属性，子类无法访问，其他都可以访问，且都变成私有属性；类外无法访问。

9.1、继承中同名成员处理

• 1、同名属性
  访问父类时需要加作用域，访问子类不需要。
  如：访问子类用s.a;即可访问；访问父类则需要用s.Father::a;
• 2、同名函数
  访问父类时需要加作用域，访问子类不需要，同时，当父类中同名函数有重载时，也不能直接调用该重载函数，也需要加作用域。
  如：访问子类用s.func();即可访问；访问父类用s.Father::func();

总结：

• 1、子类对象可以直接访问子类中同名成员；
• 2、子类对象加作用域可以访问到父类的同名成员；
• 3、当子类与父类拥有同名的成员函数，子类会隐藏父类中的同名成员函数，子类对象需要加作用域才可以访问到父类的同名成员函数。

9.2虚继承

目的： 利用虚继承，解决菱形继承的问题
语法： 继承之前，加上关键字virtual，如class Son:virtual public Father{ };

• Father类称为虚基类；

10、多态

多态分为两类：

• 静态多态：函数重载和运算符重载属于静态多态，复用函数名；
• 动态多态： 派生类和虚函数实现运行时多态。

静态多态和动态多态区别：

• 静态多态的函数地址早绑定，编译阶段确定函数地址；
• 动态多态的函数地址晚绑定，运行阶段确定函数地址。

动态多态满足条件：

• 1、有继承关系；
• 2、子类要重写父类的虚函数

例子：

class Father
{
public:
	virtual void speak() //在父类中的同名函数加virtual，这样在调用时就会调用子类的成员函数
	{
		cout << "父亲在说话" << endl;
	}
};

class Son : public Father
{
public:
	void speak()
	{
		cout << "儿子在说话" << endl;
	}
};

void doSpeak(Father& father)
{
	father.speak();
}

int main()
{
	Father* fa = new Son; //多态条件 父类指针指向子类对象
	doSpeak(*fa); //注意传入的是子类对象，然后创建函数的时候传入的是父亲类
	delete fa;
	return 0;
}

10.1、纯虚函数与抽象类

在多态中，通常父类中虚函数的实现是无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数。

纯虚函数语法：virtual 返回值类型 函数名（参数列表）= 0；
例如：virtual void func() = 0; //纯虚函数

当类中有了纯虚函数，这个类就成为了抽象类

抽象类特点：

• 无法实例化对象；
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类。

10.2、虚析构与纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构函数代码。

解决办法： 将父类中的析构函数改为虚析构或纯虚析构

虚析构与纯虚析构的共性：

• 可以解决父类指针释放子类对象的问题
• 都需要有具体的函数实现

虚析构与纯虚析构的区别：

• 如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：virtual ~类名（）{}
纯虚析构语法：virtual ~类名（） = 0；