c++核心编程

GHFR233

已于 2023-09-25 18:10:03 修改

阅读量147

点赞数

文章标签： c++ 开发语言

于 2023-09-24 17:39:16 首次发布

本文链接：https://blog.csdn.net/GHFR233/article/details/133245983

版权

c++核心编程

1.C\C++内存分区（4区）

代码区：存放写的代码注释之类的文本

全局区\常量区：存放全局变量静态变量 const修饰的全局变量宏定义常量等

栈区：自动释放

堆区：程序员控制释放

不同区中生命周期不同不会乱

1.1程序运行前

代码区：共享只读

全局区\常量区：只读程序运行之后释放

1.2程序运行中

栈区：编译器自动局部变量使用后会被释放就不存在了

堆区：c++中主要使用new 、c中使用 malloc()申请 free()释放

1.3 new操作符

**c++**中用new开内存

格式1：指针变量名=new 类型标识符；
格式2：指针变量名=new 类型标识符（初始值）；
格式3：指针变量名=new 类型标识符 [内存单元个数]；

2.引用

2.1基本使用

给变量起别名//也就是间接访问

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

2.2注意事项

必须初始化不能再指向别的变量

2.3引用作为函数参数

用实参修饰形参//就相当于地址传递

void swap(int &a,int &b);//a 和 b就是引用

2.4作为函数返回值

注意：不要返回局部变量的引用

函数可以作为左值

2.5引用的本质

本质就是 int * const p;指针常量指向是固定的

2.6常量引用

用来修饰形参防止误操作

const int &别名；也就是const int * const p；

例如

void showValue(const int &val)//防止修改引用值
{
	//val = 10000;非法的
	cout << "val =" << val << "\n";
}

2.7 右值引用

作为函数参数时用来延长局部参数寿命直到本函数使用结束

3.函数的提高

3.1 函数的默认参数

在C++中函数形参可以有默认值

语法：返回值类型函数名（参数名=默认值）{}

int func2(int a,int b=20)//当b参数不填的时候就为20
{
	return a + b;
}

如果参数有默认值，那么这个参数右边的所有参数都得有默认值

当声明有默认参数实现就不可以有

3.2函数占位参数

C++中函数形参可以有占位参数，用来占位，调用时需要填补

语法：返回值类型函数名(数据类型){}

3.3函数重载

3.3.1 重载概述

作用：函数名可以相同

条件：

统一作用域
函数名相同
参数类型、个数、顺序不同

返回值要相同

例如：

int funcrl(int a, int b) //传入整数相加
{
	return a + b;
};
int funcrl(float a,float b)//传入浮点数相加
{
	return (int)(a + b);
};

3.3.2 重载注意

引用作为重载条件

void funcrl2(int& a)
{
	cout << 1 << endl;
}
void funcrl2(const int& a)
{
	cout << 2 << endl;
}

默认参数作为重载条件

void funcrl3(int a)//会出错 同时适配两种参数表
{
cout << 3 << endl;
}
void funcrl3(int a,int b=10)
{
cout << 4 << endl;
}

4.类和对象

对象的三大特性为：封装、继承、多态

4.1封装

4.1.1封装的意义

将属性和行为作为一个整体
将属性和行为添加权限

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

属性（成员变量/成员属性）和行为（成员函数/成员方法）都叫成员

const double PI = 3.14;
//设计一个圆 用来求周长
class Round
{
	//访问权限
	public:
	//属性
		int m_r;//半径
	//行为
		double calZc() 	//获取圆的周长
		{ 
			return 2 * PI * m_r;
		}
};
int main(void)
{
	
	Round R1;//创建圆对象 也就是实例化
	R1.m_r = 10;//对属性进行赋值 使用.进行操作 类似于结构体
	//输出周长
	cout << "周长" << R1.calZc() << "\r\n";
	return 0;
}

//学生类
class Student
{
	public:
		int StudentID;//学号
		char Name[6];//姓名

		void ShowStuID() 
		{
			cout << "学号:" << StudentID << "\r\n";
		}
		void ShowStuName() 
		{
			cout << "姓名:" << Name << "\r\n";
		}
		void SetName(string name)
		{
			Name = name;
		}
	private:

};

权限

将不同的属性和行为放在不同的权限组下便于控制

public 公共权限成员在类内可以访问类外也可以访问
protected 保护权限成员在类内可以访问类外不可以访问
private 私有权限成员在类内可以访问类外不可以访问

4.1.2 struct 和class 的区别

在于访问权限不同

struct 的默认权限是公有

class 的默认权限是私有

4.1.3 成员属性设为私有

成员属性设为私有可以只有类内操作

检测写权限的有效性

设计立方体类

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

class Cube
{
public:
	//设置长
	void setL(int L) 
	{
		Length =L;
	}
	//获取长
	int getL()
	{
		return Length;
	}
	//设置宽
	void setW(int W)
	{
		Widgth = W;
	}
	//获取宽
	int getW()
	{
		return Widgth;
	}
	//设置高
	void setH(int H)
	{
		Height = H;
	}
	//获取高
	int getH()
	{
		return Height;
	}
	//获取面积
	int getArea()
	{
		return 2 * (Height * Widgth + Widgth * Length + Length * Widgth);
	}
	//获取体积
	int getVolume() 
	{
		return Height * Widgth * Length;
	}
	//判断是否是同一个立方体
	int IsSame(Cube cube)
	{
		if ((cube.getW() == Widgth) && (cube.getH() == Height) && (cube.getW() == Length))
		{
			return 1;
		}
		return -1;
	}

点和圆的关系

一个类可以在另一个类中

//点
class Point
{
public:
	void setX(int x)
	{
		X = x;
	}
	void setY(int y)
	{
		Y = y;
	}
	int getX()
	{
		return X;
	}
	int getY()
	{
		return Y;
	}
private:
	//x
	int X;
	//y
	int Y;

};
//圆
class Round
{
public:
	void setP(Point p)
	{
		P = p;
	}
	Point getP()
	{
		return P;
	}
	void setR(int r)
	{
		m_R = r;
	}
	int getR()
	{
		return m_R;
	}
private:
	//圆心
	Point P;
	//半径
	int m_R;
};

//判断点和圆的关系
int IsInRound(Point p,Round R)
{
	int L =	  (p.getX() - R.getP().getX()) * (p.getX() - R.getP().getX())
			+ (p.getY() - R.getP().getY()) * (p.getY() - R.getP().getY());
	int r= R.getR()* R.getR();
	if(L==r)
	{
		return 0;
	}
	else if(L> r)
	{
		return 1;
	}
	else
	{
		return -1;
	}

}

4.2对象的初始化和清理

4.2.1构造函数和析构函数

构造函数：用于创建对象时候为对象成员属性进行复制编译器自动调用
析构函数：对象那个销毁时候清理

构造函数语法：类名(){} 对象外需要表明作用域::

没有返回值也不写void
函数名和类名相同
可以有参数发生重载
创建对象的时候自动调用

析构函数语法：~类名(){} 对象外需要表明作用域::

没有返回值也不写void
函数名和类名相同添加~
没有参数不能重载
对象销毁自动析构

//对象初始化和清理
class Person1
{
public:
	Person1();
	~Person1();

private:

};

Person1::Person1()
{
	cout << "构造函数的调用" << endl;
}

Person1::~Person1()
{
	cout << "析构函数的调用" << endl;
}
int main(void)
{
	Person1 p;
	return 0;
}

4.2.2构造函数的分类和调用

两种方式：

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

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

三种调用方法：

括号法

显式法

隐式转换法

//调用

Person1 p;//默认 

//括号法
Person1 p2(10);//有参数
Person1 p3(p2);//拷贝构造函数

//显式法
Person1 p4 = Person1(10);//有参
Person1 p5 = Person1(p2);//拷贝构造

//隐式法
Person1 p6 = 10;//相当于Person1 p6 = Person1(10)		有参
Person1 p7 = p6;//Person1 p7= Person1(p6)			拷贝

4.2.3拷贝构造的时机

使用创建过的对象来创建新对象
值传递方式
用值方式返回局部对象

4.2.4构造函数调用规则

默认情况下给类添加三个函数

构造
析构
拷贝构造

调用规则

有自定义有参构造则不提供无参构造
有自定义拷贝构造函数则不会提供其他构造函数

4.2.5深拷贝和浅拷贝

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

如果对象出现内存申请则需要深拷贝否则会出现对同一空间反复释放

class Person
{
public:
	Person(int _age,int _height)
	{
		M_age = _age;
		M_height = new int(_height);
	}
	Person(const Person &p)//深拷贝
	{
		M_age = p.M_age;
		M_height = new int(*p.M_height);
	}
	~Person()
	{
		delete M_height;
		M_height = NULL;
	}
	int M_age;
	int* M_height;
private:

};

4.2.6 初始化列表

用来给给属性初始化

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

class Person
{
public:
	Person():M_age(1),M_height(192)
	{
		cout << M_age << M_height;
	}
	Person(const Person &p)//深拷贝
	{
		
	}
	~Person()
	{
		
	}
	int M_age;
	int M_height;

private:

};
void test01() 
{
	Person P;
}
int main(void)
{
	test01();
}

4.2.7类对象作为类成员

C++类中的成员课意识另一个类的成员，称为对象成员

class Phone
{
public:
	Phone()
	{
		cout << "Phone构造函数" << endl;
	}
	~Phone()
	{
		cout << "Phone析构函数" << endl;
	}

private:

};

class Person
{
public:
	Person()
	{
		cout << "Person构造函数" << endl;
	}
	~Person()
	{
		cout << "Person析构函数" << endl;
	}
	string m_Name;
	Phone m_Phone;

private:

};
void test01() 
{
	Person P;
}
int main(void)
{
	test01();
}

Phone构造函数
Person构造函数
Person析构函数
Phone析构函数

先构造对象成员后析构对象成员

4.2.8 静态成员

成员添加static,称为静态成员

静态成员变量

所有对象共享同一份数据
编译阶段分配内存
类内声明类外初始化

可以直接通过类名访问

class Person
{
public:
	Person()
	{
		cout << "Person构造函数" << endl;
	}
	~Person()
	{
		cout << "Person析构函数" << endl;
	}
	string m_Name;
	static int M_Age;

private:

};
int Person::M_Age=100;
void test01() 
{
	Person P;
	cout << P.M_Age << endl;
	Person P2;
	cout << P2.M_Age << endl;
}
int main(void)
{
	test01();
}

Person构造函数
100
Person构造函数
100
Person析构函数

静态成员函数

所有对象共享同一个函数

静态成员函数只能访问静态成员变量

class Person
{
public:
	Person()
	{
		cout << "Person构造函数" << endl;
	}
	~Person()
	{
		cout << "Person析构函数" << endl;
	}
	static void func(int _Age)
	{
		M_Age = _Age;
	}
	string m_Name;
	static int M_Age;

private:

};
int Person::M_Age=100;
void test01() 
{
	Person P;
	cout << P.M_Age << endl;
	P.func(200);
	Person P2;
	cout << P2.M_Age << endl;

}
int main(void)
{
	test01();
}
Person构造函数
100
Person构造函数
200
Person析构函数

4.3 C++对象模型和this指针

4.3.1成员变量和成员函数分开存储

编译器会给空对象分配一个字节的空间用来区分是否为空

静态成员不在对象上

4.3.2 this指针概念

this指针指向被调用的成员函数所属的对象

用途：

当形参和成员变量同名的时候来使用

在类的非静态成员函数返回对象本身可以用return *this

class Person
{
public:
	Person(int M_Age)
	{
		this->M_Age = M_Age;
		cout << "Person构造函数" << endl;
	}
	~Person()
	{
		cout << "Person析构函数" << endl;
	}
	Person GetPerson()
	{
		return *this;
	}
	string m_Name;
	int M_Age;

private:

};

void test01() 
{
	Person P(100);
	cout << "size of p="<< sizeof(P) << endl;
	P.GetPerson();

}
int main(void)
{

	test01();
}

4.3.3空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是要注意有没有用到this会出错每个成员属性默认自带一个this指针

class Person
{
public:
	Person(int M_Age)
	{
		this->M_Age = M_Age;
		cout << "Person构造函数" << endl;
	}
	~Person()
	{
		cout << "Person析构函数" << endl;
	}
	Person GetPerson()
	{
		return *this;
	}
	int M_Age;
	void ShowAge()
	{
		cout << "0041" << endl;
		cout << this->M_Age << endl;
	}
private:

};

void test01() 
{
	Person *p =NULL;
	p->ShowAge();

}
int main(void)
{

	test01();
}

const修饰成员函数

常函数：

在成员函数的() 后添加const 也就是为this指针(指针常量)添加const 这样this指向的值和this的指向都不可以改了
对成员属性添加mutable 后属性就可以修改了

常对象：

在对象前加const变为常对象
对成员属性添加mutable 后属性就可以修改了
常对象只能调用常函数

4.4友元

4.4.1全局函数做友元

语法：在类中声明全局函数

class Building
{
	friend void Goodfriend(Building& building);
public:
	string m_SettingRoom;
	Building()
	{
		m_SettingRoom = "客厅";
		m_BedRoom = "卧室";
	}
	~Building()
	{

	}

private:
	string m_BedRoom;
};
void Goodfriend(Building &building)
{
	cout << "访问public" << building.m_SettingRoom << endl;
	cout << "访问private" << building.m_BedRoom << endl;
}
void test01() 
{
	Building B;
	Goodfriend(B);
}
int main(void)
{
	test01();
}

4.4.2类做友元

class Building
{
	void Vist();
	friend class GoodFriend;
public:
	string m_SettingRoom;
	Building();
	~Building()
	{

	}

private:
	string m_BedRoom;
};
class GoodFriend
{
public:
	GoodFriend();
	void Vist();
	Building* b;

};
Building::Building()
{
	m_SettingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodFriend::GoodFriend()
{
	b = new Building;
}
void GoodFriend::Vist()
{
	cout << "访问public" << b->m_SettingRoom << endl;
	cout << "访问private" << b->m_BedRoom << endl;
}
void test01() 
{
	Building B;
	GoodFriend G;
	G.Vist();
}
int main(void)
{
	test01();
}

4.4.3 成员函数做友元


class Building;
class GoodFriend
{
public:
	GoodFriend();
	void Vist();
	void Vist2();
	Building * b;

};
class Building
{
	friend void GoodFriend::Vist();

public:
	string m_SettingRoom;
	Building();
	~Building()
	{

	}

private:
	string m_BedRoom;
};
GoodFriend::GoodFriend()
{
	b = new Building;
}
Building::Building()
{
	m_SettingRoom = "客厅";
	m_BedRoom = "卧室";
}
void GoodFriend::Vist()
{
	cout << "访问public" << b->m_SettingRoom << endl;
	cout << "访问private" << b->m_BedRoom << endl;
}
void GoodFriend::Vist2()
{
	cout << "访问public" << b->m_SettingRoom << endl;
	//cout << "访问private" << b->m_BedRoom << endl;
}
void test01() 
{
	Building B;
	GoodFriend G;
	G.Vist();
}
int main(void)
{
	test01();
}

4.5运算符重载

对±*/（）等运算符进行重载

4.5.1 加号运算符的重载

成员函数

class Person
{
public:
	Person(int _Age, int _Height);
	~Person();
	Person operator+(Person& p);
	int m_Age;
	int m_Height;
private:

};

Person::Person(int _Age,int _Height)
{
	m_Age =_Age;
	m_Height=_Height;
}

Person::~Person()
{
}

Person Person::operator+(Person &p)
{
	Person temp(0,0);
	temp.m_Age = this->m_Age + p.m_Age;
	temp.m_Height = this->m_Height + p.m_Height;
	return temp;
}
void test01() 
{
	Person p1(10, 150),p2(15,170);
	Person p3=p1 + p2;
	cout << p3.m_Age << endl;
	cout << p3.m_Height << endl;
}
int main(void)
{
	test01();
}

全局函数

class Person
{
public:
	Person(int _Age, int _Height);
	~Person();
	
	int m_Age;
	int m_Height;
private:

};

Person::Person(int _Age,int _Height)
{
	m_Age =_Age;
	m_Height=_Height;
}

Person::~Person()
{
}

Person operator+(Person &p1, Person& p2)
{
	Person temp(0,0);
	temp.m_Age = p1.m_Age + p2.m_Age;
	temp.m_Height = p1.m_Height + p2.m_Height;
	return temp;
}
void test01() 
{
	Person p1(10, 150),p2(15,170);
	Person p3=p1 + p2;
	cout << p3.m_Age << endl;
	cout << p3.m_Height << endl;
}
int main(void)
{
	test01();
}

4.5.2 左移运算符


class Person
{
public:
	Person(int _Age, int _Height);
	~Person();
	
	int m_Age;
	int m_Height;
private:

};

Person::Person(int _Age,int _Height)
{
	m_Age =_Age;
	m_Height=_Height;
}

Person::~Person()
{
}

Person operator+(Person &p1, Person& p2)
{
	Person temp(0,0);
	temp.m_Age = p1.m_Age + p2.m_Age;
	temp.m_Height = p1.m_Height + p2.m_Height;
	return temp;
}
ostream& operator<<(ostream &out,Person &p)//一定要返回引用对out对象进行保活
{
	out << "m_Age" << p.m_Age << "m_Height" << p.m_Height;
	return out;
}
void test01() 
{
	Person p1(10, 150),p2(15,170);
	Person p3=p1 + p2;
	cout << p3.m_Age << endl;
	cout << p3.m_Height << endl;
	cout << p3 << endl;

}
int main(void)
{
	test01();
}

4.5.3 递增运算符重载

class MyInteger
{
	friend ostream& operator<<(ostream& out, MyInteger& p);
public:
	MyInteger();
	~MyInteger();

	//前置运算符++
	MyInteger& operator++()
	{
		m_Num++;
		return *this;
	}
	//后置++
	int operator++(int)//占位参数区分后置递增
	{
		int temp = m_Num;
		m_Num++;
		return temp;

	}
private:
	int m_Num;
};

MyInteger::MyInteger()
{
	m_Num = 0;
}

MyInteger::~MyInteger()
{
}
class Person
{
public:
	Person(int _Age, int _Height);
	~Person();
	
	int m_Age;
	int m_Height;
private:

};

Person::Person(int _Age,int _Height)
{
	m_Age =_Age;
	m_Height=_Height;
}

Person::~Person()
{
}


ostream& operator<<(ostream &out, MyInteger&p)
{
	out << p.m_Num ;
	return out;
}
void test01() 
{
	MyInteger Number;
	cout << Number++ << endl;
	cout << ++Number << endl;


}
int main(void)
{
	test01();
}

4.5.4 赋值运算符重载

class Person
{
public:
	Person(int _Age, int _Height);
	~Person();
	Person& operator=(Person &p)
	{
		*this->m_Age = *p.m_Age;
		return *this;
	}
	int *m_Age;
	int m_Height;
private:

};

Person::Person(int _Age,int _Height)
{
	m_Age = new int(_Age);
	m_Height=_Height;
}

Person::~Person()
{
	if (m_Age!=NULL)
	{
		delete m_Age;
		m_Age = NULL;
	}
}

void test01() 
{
	
	Person p1(18,150);
	Person p2(20, 150);
	Person p3(30, 150);
	p1 = p2 = p3;
	cout << *p1.m_Age << endl;
	cout << *p2.m_Age << endl;
	cout << *p3.m_Age << endl;

}
int main(void)
{
	test01();
}

4.5.5 关系运算符重载

class Person
{
public:
	Person(int _Age, string _Name);
	~Person();
	bool operator==(Person &p)
	{
		if ((*p.m_Age == *m_Age) && (p.m_Name == m_Name))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator!=(Person& p)
	{
		if ((*p.m_Age == *m_Age) && (p.m_Name == m_Name))
		{
			return false;
		}
		else
		{
			return true;
		}
	}
	int *m_Age;
	string m_Name;
private:

};

Person::Person(int _Age, string _Name)
{
	m_Age = new int(_Age);
	m_Name = _Name;
}

Person::~Person()
{
	if (m_Age!=NULL)
	{
		delete m_Age;
		m_Age = NULL;
	}
}

void test01() 
{
	Person p1(18, "ZS");
	Person p2(18, "Ze");
	if (p1 == p2) 
	{
		cout << "相同的" << endl;
	}
	else
	{
		cout << "不相同的" << endl;
	}
	if (p1 != p2)
	{
		cout << "不相同的" << endl;
	}
	else
	{
		cout << "相同的" << endl;
	}
}
int main(void)
{
	test01();
}

4.5.6 函数调用运算符重载

也就是对“()”进行重载

class MyPrint
{
public:
	MyPrint();
	~MyPrint();
	void operator() (string Str)
	{
		cout << Str << endl;
	};
private:
	
};

MyPrint::MyPrint()
{
}

MyPrint::~MyPrint()
{
}
void test01() 
{
	MyPrint myPrint;
	myPrint ("eeeeeeee\r\n");
	MyPrint()("匿名函数对象\r\n");
}
int main(void)
{
	test01();
}

4.6 继承

面向对象的三大特征之一

类和类之间的特殊关系

4.6.1 继承的语法

class 子类名：继承方式父类

class BasePage
{
public:
	void header()
	{
		cout << "头" << endl;
	}
	void botton()
	{
		cout << "底部" << endl;
	}
	void left()
	{
		cout << "左侧" << endl;
	}
	void right()
	{
		cout << "右侧" << endl;
	}
private:

};
class Java:public BasePage
{
public:
	void content()
	{
		cout << "java内容" << endl;
	}
};
class Python :public BasePage
{
public:
	void content()
	{
		cout << "Python内容" << endl;
	}
};


void test01()
{
	Java java;
	Python python;
	java.header();
	python.header();
	java.content();
	python.content();
}
int main(void)
{
	test01();
}

4.6.2 继承方式

继承方式有三种

公共继承(public)：除了访问不到的成员就复制一份
保护继承(protected)：除了访问不到的成员就复制一份，并将权限变为保护
私有继承(private)：除了访问不到的成员就复制一份，并将权限变为私有

4.6.3 继承中的对象问题

所有成员属性都会被继承虽然私有的访问不了但是依然会继承

class Base1
{
public:

	int m_A;
	Base1();
	~Base1();

protected:
	int m_B;
private:
	int m_C;

};

Base1::Base1()
{
}

Base1::~Base1()
{
}

class Son1 :public Base1
{
public:
	Son1();
	~Son1();
	int m_D;
private:

};

Son1::Son1()
{


}

Son1::~Son1()
{
}
void test01()
{
	Son1 s;
	cout << sizeof(s) << endl;
	
	
}
int main(void)
{
	test01();
}



16

4.6.4继承中构造和析构的顺序

class Base1
{
public:

	int m_A;
	Base1();
	~Base1();

protected:
	int m_B;
private:
	int m_C;

};

Base1::Base1()
{
	cout << "父类构造" << endl;
}

Base1::~Base1()
{

	cout << "父类析构" << endl;
}

class Son1 :public Base1
{
public:
	Son1();
	~Son1();
	int m_D;
private:

};

Son1::Son1()
{
	cout << "子类构造" << endl;
}

Son1::~Son1()
{
	cout << "子类析构" << endl;
}
void test01()
{
	Son1 s;
}
int main(void)
{
	test01();
}
-------------------------------------------------------------------------
父类构造
子类构造
子类析构
父类析构

创造子类先要先前置类无论是继承还是类做成员，析构也要后析构不然会导致释放失败

4.6.5继承同名的处理方式

需要添加父类作用域，不要重载父类函数


class Base1
{
public:
	void func()
	{
		cout << "父类函数" << endl;
	}
	int m_A = 100;
	Base1();
	~Base1();

protected:
	int m_B;
private:
	int m_C;

};

Base1::Base1()
{
	cout << "父类构造" << endl;
}

Base1::~Base1()
{

	cout << "父类析构" << endl;
}

class Son1 :public Base1
{
public:
	Son1();
	~Son1();
	void func()
	{
		cout << "子类函数" << endl;
	}
	int m_A = 200;
private:

};

Son1::Son1()
{
	cout << "子类构造" << endl;
}

Son1::~Son1()
{
	cout << "子类析构" << endl;
}
void test01()
{
	Son1 s;
	cout << "子类：" << s.m_A			<< endl;
	cout << "父类：" << s.Base1::m_A		<< endl;
	s.func();
	s.Base1::func();

}
int main(void)
{
	test01();
}
--------------------------------------------------------------------
父类构造
子类构造
子类：200
父类：100
子类函数
父类函数
子类析构
父类析构

4.6.6 继承同名静态成员处理方式

class Base1
{
public:
	static void func()
	{
		cout << "父类函数" << endl;
	}
	static int m_A ;
	Base1();
	~Base1();

protected:
	int m_B;
private:
	int m_C;

};
int Base1::m_A=100 ;

Base1::Base1()
{
	cout << "父类构造" << endl;
}

Base1::~Base1()
{

	cout << "父类析构" << endl;
}

class Son1 :public Base1
{
public:
	Son1();
	~Son1();
	static void func()
	{
		cout << "子类函数" << endl;
	}
	static int m_A;
private:

};
int Son1::m_A = 200;
Son1::Son1()
{
	cout << "子类构造" << endl;
}

Son1::~Son1()
{
	cout << "子类析构" << endl;
}
void test01()
{
	Son1 s;
	//通过对象访问
	cout << "子类：" << s.m_A			<< endl;
	cout << "父类：" << s.Base1::m_A	<< endl;

	s.func();
	s.Base1::func();

	//通过类名访问
	cout << "子类：" << Son1::m_A << endl;
	cout << "父类：" << Base1::m_A << endl;
	cout << "父类：" << Son1::Base1::m_A << endl;

	Son1::func();
	Son1::Base1::func();


}
int main(void)
{
	test01();
}
--------------------------------------
父类构造
子类构造
子类：200
父类：100
子类函数
父类函数
子类：200
父类：100
父类：100
子类函数
父类函数
子类析构
父类析构

4.6.7多继承语法

允许一个类继承多个类

语法：class 子类：继承方式父类1 ，继承方式父类2，.......

实际开发中避免使用可能会冲突

class Base1
{
public:
	void func()
	{
		cout << "父类1函数" << endl;
	}
	int m_A = 100;
	Base1();
	~Base1();

protected:
	
private:

};

class Base2
{
public:
	void func()
	{
		cout << "父类2函数" << endl;
	}
	int m_B=200;
	Base2();
	~Base2();

protected:
	
private:
	

};
Base1::Base1()
{
	cout << "父类1构造" << endl;
}

Base1::~Base1()
{

	cout << "父类1析构" << endl;
}
Base2::Base2()
{
	cout << "父类2构造" << endl;
}

Base2::~Base2()
{

	cout << "父类2析构" << endl;
}

class Son1 :public Base1,public Base2
{
public:
	Son1();
	~Son1();
	static void func()
	{
		cout << "子类函数" << endl;
	}
	int m_C=300;
private:

};

Son1::Son1()
{
	cout << "子类构造" << endl;
}

Son1::~Son1()
{
	cout << "子类析构" << endl;
}
void test01()
{
	Son1 s;
	cout << s.m_A << endl;
	cout << s.m_B << endl;
	cout << s.m_C << endl;
	
}
int main(void)
{
	test01();
}
-----------------------------------------------------------------------
父类1构造
父类2构造
子类构造
100
200
300
子类析构
父类2析构
父类1析构

4.6.8菱形继承

也就是两个类继承同同一个基类

又有一个类同时继承他俩

问题：

会产生二义性
会复制两份祖类成员

通过virtual关键字变成虚继承也就是形成一个虚基指针(vbptr)指向被继承的类

class Base1
{
public:
	void func()
	{
		cout << "父类1函数" << endl;
	}
	int m_A = 100;
	Base1();
	~Base1();

protected:
	
private:

};

Base1::Base1()
{
	cout << "父类1构造" << endl;
}

Base1::~Base1()
{

	cout << "父类1析构" << endl;
}


class Son1 :virtual public Base1
{
public:
	Son1();
	~Son1();
	static void func()
	{
		cout << "子类函数" << endl;
	}
	int m_C=300;
private:

};

Son1::Son1()
{
	cout << "子类构造" << endl;
}

Son1::~Son1()
{
	cout << "子类析构" << endl;
}

class Son2 :virtual public Base1
{
public:
	Son2();
	~Son2();
	static void func()
	{
		cout << "子类2函数" << endl;
	}
	int m_C = 300;
private:

};
Son2::Son2()
{
	cout << "子类2构造" << endl;
}



Son2::~Son2()
{
	cout << "子类2析构" << endl;
}
class Grandson :public Son1,public Son2
{
public:
	Grandson();
	~Grandson();

private:

};

Grandson::Grandson()
{
}

Grandson::~Grandson()
{
}
void test01()
{
	Grandson s;
	//需要标明作用域
	s.Son1::m_A = 25;
	s.Son2::m_A = 35;
	
	cout << sizeof(s) << endl;
	
}
int main(void)
{
	test01();
}
------------------------------------------------------

4.7多态

4.7.1多态的基本概念

多态分为两类

静态多态:函数重载和运算符重载（编译阶段确定函数地址）
动态多态:派生类和虚函数(运行阶段确定函数地址)

class Base1
{
public:
	//虚函数 动态确定函数地址 
	virtual void func()
	{
		cout << "父类1函数" << endl;
	}
	int m_A = 100;
	Base1();
	~Base1();

protected:
	
private:

};

Base1::Base1()
{

}

Base1::~Base1()
{

}


class Son1 :public Base1
{
public:
	Son1();
	~Son1();
     void func()
	{
		cout << "子类函数" << endl;
	}
	int m_C=300;
private:

};

Son1::Son1()
{
	
}

Son1::~Son1()
{
	
}
void doSpeak(Base1 & _base1)
{
	_base1.func();
}
void test01()
{
	Son1 s;
	doSpeak(s);
}
int main(void)
{
	test01();
}
-------------------------------------------------
通过动态多态重写虚函数

多态条件：

有继承关系
子类重写父类中的虚函数

多态的使用条件

父类指针或者引用指向子类的对象

4.7.2多态案例

实现两个为操作数进行运算的计算器类

class Calculator
{
public:
	Calculator();
	~Calculator();
	
	int m_Number1;
	int m_Number2;
	int getResult(char oper)
	{
		switch (oper)
		{
		case '+':
			return m_Number1 + m_Number2;
			break;
		case '-':
			return m_Number1 - m_Number2;
			break;
		case '*':
			return m_Number1 * m_Number2;
			break;
		case '/':
			return m_Number1 / m_Number2;
			break;
		default:
			return -1;
			break;
		}
	}
private:

};

Calculator::Calculator()
{
}

Calculator::~Calculator()
{
}




class AbstractCalculator
{
public:
	int m_Number1;
	int m_Number2;
	virtual int getResult()
	{
		return 0;
	}
};
class Add:public AbstractCalculator
{
public:
	Add();
	~Add();
	virtual int getResult()
	{
		return m_Number1 + m_Number2;
	}
private:

};

Add::Add()
{
}

Add::~Add()
{
}
class Sub:AbstractCalculator
{
public:
	Sub();
	~Sub();
	virtual int getResult()
	{
		return m_Number1 - m_Number2;
	}
private:

};

Sub::Sub()
{
}

Sub::~Sub()
{
}
void test01()
{
	Calculator Cal;
	Cal.m_Number1 = 10;
	Cal.m_Number2 = 20;
	cout << Cal.getResult('+') << endl;
}
void test02()
{
	AbstractCalculator* abc = new Add;
	abc->m_Number1 = 10;
	abc->m_Number2 = 20;
	cout << abc->getResult() << endl;
	delete abc;
}
int main(void)
{
	test02();
}

通过多态避免修改基类

4.7.3纯虚函数和抽象类

纯虚函数语法：virtual 返回值类型函数名 (参数列表)=0；

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

抽象类的特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数

class Base1
{
public:
	Base1();
	~Base1();
	virtual void func() = 0;//纯虚函数
private:

};

Base1::Base1()
{
}

Base1::~Base1()
{
}
class Son1:public Base1
{
public:
	Son1();
	~Son1();
	void func() 
	{
		cout << "子函数" << endl;
	};
private:

};

Son1::Son1()
{
}

Son1::~Son1()
{
}
void test02()
{
	Son1 s;
	s.func();
}
int main(void)
{
	test02();
}

4.7.4多态案例-制作饮品

制作饮品的过程：煮水冲泡倒入杯中放入辅料

//煮水 冲泡 倒入杯中 放入辅料

class AbstractDrinking//抽象基类
{
public:
	AbstractDrinking();
	~AbstractDrinking();

	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourInCup() = 0;
	//放入辅料
	virtual void PutSomething() = 0;
	//制作
	void makeDrink()
	{
		Boil();
		Brew();
		PourInCup();
		PutSomething();
	}
private:

};

AbstractDrinking::AbstractDrinking()
{
}

AbstractDrinking::~AbstractDrinking()
{
}
//制作咖啡
class Coffee:public AbstractDrinking
{
public:
	Coffee();
	~Coffee();

	//煮水
	virtual void Boil() 
	{
		cout << "煮水" << endl;
	}
	//冲泡
	virtual void Brew() 
	{
		cout << "冲咖啡" << endl;
	}
	//倒入杯中
	virtual void PourInCup() 
	{
		cout << "倒进杯子里" << endl;
	}
	//放入辅料
	virtual void PutSomething() 
	{
		cout << "放牛奶" << endl;
	}

private:

};

Coffee::Coffee()
{
}

Coffee::~Coffee()
{
}
class Tea:public AbstractDrinking
{
public:
	Tea();
	~Tea();
	//煮水
	virtual void Boil()
	{
		cout << "煮水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "泡茶" << endl;
	}
	//倒入杯中
	virtual void PourInCup()
	{
		cout << "倒进杯子里" << endl;
	}
	//放入辅料
	virtual void PutSomething()
	{
		cout << "放枸杞" << endl;
	}
private:

};

Tea::Tea()
{
}

Tea::~Tea()
{
}
void doWork(AbstractDrinking*abs)
{
	abs->makeDrink();
	delete abs;
}
void test02()
{
	doWork(new Coffee);
	doWork(new Tea);
}
int main(void)
{
	test02();
}

4.7.5 虚析构和纯虚析构

多态使用时，如果子类开到堆区，那么父类无法释放

解决：使用虚析构或者纯虚析构

都需要具体的函数来实现纯虚析构无法实例化

class Animal
{
public:
	Animal();
	virtual ~Animal();//纯虚析构
	virtual void speak() = 0;
private:

};

Animal::Animal()
{
}

Animal::~Animal()//纯虚析构的空实现
{
}
class Cat:public Animal
{
public:
	Cat(string _Name);
	~Cat();
	void speak()
	{
		cout <<* m_Name << "猫说话" << endl;
	}
	string* m_Name;
private:

};

Cat::Cat(string _Name)
{
	m_Name = new string(_Name);
}

Cat::~Cat()
{
	if (m_Name != NULL) 
	{
		cout<<"释放m_Name" << endl;
		delete m_Name;
		m_Name = NULL;
	}
}
void test02()
{
	Animal* animal = new Cat("Tom");
	animal->speak();
	delete animal;
}
int main(void)
{
	test02();
}

4.7.7 多态案例-电脑组装

电脑的组成部分主要为CPU GPU MME

class CPU
{
public:
	CPU();
	~CPU();
	virtual void cal() = 0;
private:

};

CPU::CPU()
{
}

CPU::~CPU()
{
}
class GPU
{
public:
	GPU();
	~GPU();
	virtual void show() = 0;
private:

};

GPU::GPU()
{
}

GPU::~GPU()
{
}
class MEM
{
public:
	MEM();
	~MEM();
	virtual void save() = 0;
private:

};

MEM::MEM()
{
}

MEM::~MEM()
{
}
void test02()
{
	
}
class Computer
{
public:
	Computer(CPU* _cpu, GPU* _gpu,MEM* _mem);
	~Computer();
	void work() 
	{
		m_cpu->cal();
		m_gpu->show();
		m_mem->save();
	}
private:
	CPU* m_cpu;
	GPU* m_gpu;
	MEM* m_mem;
};

Computer::Computer(CPU* _cpu, GPU* _gpu, MEM* _mem)
{
	m_cpu=_cpu;
	m_gpu=_gpu;
	m_mem=_mem;
}

Computer::~Computer()
{
}

class InterCpu:public CPU
{
public:
	InterCpu();
	~InterCpu();
	void cal()
	{
		cout << "InterCpu开始计算" << endl;
	}
private:

};

InterCpu::InterCpu()
{
}

InterCpu::~InterCpu()
{
}

class InterGPU :public GPU
{
public:
	InterGPU();
	~InterGPU();
	void show()
	{
		cout << "InterGPU开始显示" << endl;
	}
private:

};

InterGPU::InterGPU()
{
}

InterGPU::~InterGPU()
{
}
class InterMEM :public MEM 
{
public:
	InterMEM ();
	~InterMEM ();
	void save()
	{
		cout << "InterMEM开始存储" << endl;
	}
private:

};

InterMEM ::InterMEM ()
{
}

InterMEM ::~InterMEM ()
{
}

class AMDCpu :public CPU
{
public:
	AMDCpu();
	~AMDCpu();
	void cal()
	{
		cout << "AMDCpu开始计算" << endl;
	}
private:

};

AMDCpu::AMDCpu()
{
}

AMDCpu::~AMDCpu()
{
}

class AMD :public GPU
{
public:
	AMD();
	~AMD();
	void show()
	{
		cout << "AMDGPU开始显示" << endl;
	}
private:

};

AMD::AMD()
{
}

AMD::~AMD()
{
}
class AMDMEM :public MEM
{
public:
	AMDMEM();
	~AMDMEM();
	void save()
	{
		cout << "AMDMEM开始存储" << endl;
	}
private:

};

AMDMEM::AMDMEM()
{
}

AMDMEM ::~AMDMEM()
{
}


void test01()
{
	CPU* interCPU = new InterCpu;
	GPU* interGpu = new InterGPU;
	MEM* interMem = new InterMEM;
	Computer* computer = new Computer(interCPU, interGpu, interMem);
	computer->work();
	delete computer;
	delete interCPU;
	delete interGpu;
	delete interMem;
	computer = NULL;
	interCPU = NULL;
	interGpu = NULL;
	interMem = NULL;
}
----------------------------
InterCpu开始计算
InterGPU开始显示
InterMEM开始存储

GHFR233

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
c++核心编程

作用：函数名可以相同统一作用域函数名相同参数类型、个数、顺序不同返回值要相同int funcrl(int a, int b) //传入整数相加int funcrl(float a,float b)//传入浮点数相加。
复制链接

扫一扫