c++学习代码-类的特性

目录

封装

数组类封装

MyArray.hpp

继承

基本语法

继承方式

多继承语法

继承中的对象模型

继承中构造和析构的顺序

同名成员处理

同名静态成员处理

菱形继承

多态

多态的基本语法

多态的原理分析

虚析构和纯虚析构

纯虚函数和抽象类

案例1计算机类

案例2制作饮品

电脑组装

---

封装

数组类封装

/*可以以对内置数据类型以及自定义数据类型的数据进行存储
将数据中的数据存储到堆区
构造函数中可以传入数组的容量
提供对应的拷贝构造函数以及operator=防止浅拷贝问题
提供尾插法和尾删法对数组中的数据进行增加和删除
可以通过下标的方式访问数组中的元素
可以获取数组中当前元素个数和数组的容量
*/
#include"MyArray.hpp"
void test01()
{
	MyArray<int> arr1(5);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

MyArray.hpp

/*可以以对内置数据类型以及自定义数据类型的数据进行存储
将数据中的数据存储到堆区
构造函数中可以传入数组的容量
提供对应的拷贝构造函数以及operator=防止浅拷贝问题
提供尾插法和尾删法对数组中的数据进行增加和删除
可以通过下标的方式访问数组中的元素
可以获取数组中当前元素个数和数组的容量
*/
#include"MyArray.hpp"
void test01()
{
	MyArray<int> arr1(5);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

继承

基本语法

#include<iostream>
using namespace std;
//继承的好处:减少重复代码
// 语法： class 子类 ：继承方式 父类
// public为公共继承
// 子类也称为派生类
// 父类也成为基类 
//普通实现界面
//Java界面
class Basepage
{
public:
	void header()
	{
		cout << "首页，公开课，登录，注册。。。（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心，交流合作，站内地图。。。（公共底部）" << endl;
	}
	void left()
	{
		cout << "Java,python,c++...(公共分列表)" << endl;
	}

};
//java页面
class java :public Basepage {//此处为继承
public:
	void content()
	{
		cout << "Java学科视频" << endl;
	}
};
void test01()
{
	java ja;
	cout << "Java下载视频页面如下";
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

继承方式

#include<iostream>
using namespace std;
//继承方式
//公共继承
class Basel
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son1 :public Basel
{
public:
	void func()
	{
		m_A = 10;//父类中的公共权限成员，到子类中依然是公共权限
		m_B = 10;//父类中的保护权限成员，到子类中依然是保护权限
		//m_C = 10;私有，不可以访问
	}
};
void test01()
{
	Son1 s1;
	s1.m_A = 100;
	//s1.m_B=100;保护权限类外不可以访问
}
//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 100;//父类中公有成员，到子类中变为保护权限
		m_B = 100;//父类中保护成员，到子类中变为保护权限
		//m_c = 100;父类中的私有成员 子类访问不到
	}
};
void test02()
{
	Son2 s1;
	//s1.m_A=100;保护继承，类外访问不到
}
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 100;//父类中公共成员 到子类中变为 私有成员
		m_B = 100;//父类中保护成员 到子类中变为 私有成员
		//m_C = 100;//父类中私有成员，子类访问不到
	}
};
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//m_A = 1000;这里的m_A为私有成员
	}
};
void test03()
{
	Son3 s1;
	//s1.m_A=100;//到Son3中变为私有成员 类外访问不到
}
int main()
{
	system("pause");
	return 0;
}

多继承语法

#include<iostream>
using namespace std;
//语法: class 子类 : 继承方式 父类1 , 继承方式2 父类2.....
//多继承可能会引发父类中有同名成员出现，需要加作用域区分
//c++实际开发中不建议使用多继承
class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};
class Base2
{
public:
	Base2()
	{
		m_A = 199;
		m_B = 200;
	}
	int m_A;
	int m_B;
};
//子类 需要继承Base1和Base2
class Son :public Base1, public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	//当父类中出现同名成员，需要加作用域
	cout << "Base1 :m_A = " << s.Base1::m_A << endl;
	cout << "Base2 :m_A = " << s.Base2::m_A << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

继承中的对象模型

#include<iostream>
using namespace std;
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son :public Base
{
public:
	int m_D;

};
void test01()
{
	cout << "size of Son = " << sizeof(Son) << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

继承中构造和析构的顺序

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		cout << "Base的构造函数！" << endl;
	}
	~Base()
	{
		cout << "Base的析构函数" << endl;
	}
};
class Son :public Base
{
public:
	Son()
	{
		cout << "Son的构造函数！" << endl;
	}
	~Son()
	{
		cout << "Son的析构函数" << endl;
	}
};
void test01()
{
//继承中的构造和析构的顺序如下
	//先构造父类，再构造子类，析构的顺序与构造的顺序相反
	Son a;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

同名成员处理

#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base - func()调用" << endl;
	}
	void func(int a)
	{
		cout << "Base2 - func()调用" << endl;
	}
	int m_A;
};
class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	void func()
	{
		cout << "Son - func()调用" << endl;
	}
	int m_A;
};
void test01()//同名成员属性的处理方式
{
	Son s;
	cout << "Son 下的 m_A = " << s.m_A << endl;
	//如果通过子类对象 访问到父类中同名成员，需要加作用域
	cout << "Base 下的 m_A= " << s.Base::m_A << endl;
}
void test02()//同名的成员函数的处理方式
{
	Son s;
	s.func();
	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数

	s.Base::func(1);
}
int main()
{
	test01();
	cout << endl;
	test02();
	system("pause");
	return 0; 
}
//1.子类对象可以直接访问到子类中同名函数
//2.子类对象加作用域可以访问到父类同名成员
//3.当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

同名静态成员处理

#include<iostream>
using namespace std;
class Base
{
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(a)" << endl;
	}
	static int m_A;
};
 int Base::m_A=100;
class Son :public Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
};
int Son::m_A = 200;

//同名静态成员属性
void test01()
{
	//1.通过对象访问
	Son s;
	cout << "Son 下的 m_A = " << s.m_A << endl;
	cout << "Base 下的 m_A = " << s.Base::m_A << endl;
	//2.通过类名访问
	cout << "通过类名访问：" << endl;
	cout << "Son 下的 m_A = " << Son::m_A << endl;
	//第一个::代表通过类名方式访问 第二给::代表访问父类作用域下
	cout << "Base 下的 m_A = " << Son::Base::m_A << endl;
}
//同名静态成员函数
void test02()
{
	Son s;
	//1.通过对象访问
	s.func();
	s.Base::func();
	s.Base::func(2);
	cout << endl;
	//2.通过类名访问
	//Son::func(2)  这里会调用失败，被隐藏掉
	Son::func();
	Son::Base::func();
	Son::Base::func(2);
}
int main()
{
	test01();
	cout << endl << "*******************" << endl;
	test02();
	system("pause");
	return 0;
}

菱形继承

#include<iostream>
using namespace std;
//两个派生类继承同一个基类
//又有某个类同时继承两个派生类
//动物类
class Animal
{
public:
	int m_Age;
};
//加上关键字 virtual 叫做虚继承  解决菱形继承问题
// Animal 类成为虚基类
//羊类
class Sheep:virtual public Animal
{

};
//驼类
class Tuo :virtual public Animal
{

};
//羊驼类
class SheepTuo :public Tuo, public Sheep
{

};
void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 88;
	st.Tuo::m_Age = 18;
	//当菱形继承，两个父类拥有相同数据，需要加以作用域区分
	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;
	//这份数据我们知道 只有有一份就可以，菱形继承导致有两份，资源浪费
}
int main()
{
	test01();
	system("pause");
	return 0;
}

多态

多态的基本语法

#include<iostream>
using namespace std;
//静态多态：函数重载和运算符重载属于静态多态，复用函数名
//动态多态：派生类和虚函数实现运行时多态
//静态多态和动态多态区别：
//静态多态的函数地址早绑定 - 编译阶段确定函数地址
//动态多态的函数地址晚绑定 - 运行阶段确定函数地址
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
//猫类
class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};
//狗类
class Dog :public Animal
{
public:
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};
//执行说话的函数
//地址早绑定，在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定


//满足动态多态
//1.有继承关系
//2.子类重写父类的虚函数   重写是子类中的virtual 可写可不写


//动态多态的使用
//父类的指针或者引用 执行子类对象

void doSpeak(Animal& animal)//Animal & animal = cat;
{
	animal.speak();
}
void test01()
{
	Cat cat;
	Dog dog;
	doSpeak(cat);
	doSpeak(dog);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

多态的原理分析

#include<iostream>
using namespace std;
//静态多态：函数重载和运算符重载属于静态多态，复用函数名
//动态多态：派生类和虚函数实现运行时多态
//静态多态和动态多态区别：
//静态多态的函数地址早绑定 - 编译阶段确定函数地址
//动态多态的函数地址晚绑定 - 运行阶段确定函数地址
class Animal
{
public:
	virtual void speak()//加virtual后
	{
		cout << "动物在说话" << endl;
	}
};
//猫类
class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};
//狗类
class Dog :public Animal
{
public:
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};
//执行说话的函数
//地址早绑定，在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定


//满足动态多态
//1.有继承关系
//2.子类重写父类的虚函数   重写是子类中的virtual 可写可不写


//动态多态的使用
//父类的指针或者引用 执行子类对象

void doSpeak(Animal& animal)//Animal & animal = cat;
{
	animal.speak();
}
void test01()
{
	Cat cat;
	Dog dog;
	doSpeak(cat);
	doSpeak(dog);
}
void test02()
{
	cout << "sizeof Animal = " << sizeof(Animal) << endl;
}
int main()
{
	test01();
	cout << endl << endl;
	test02();
	system("pause");
	return 0;
}

虚析构和纯虚析构

#include<iostream>
#include<string>
using namespace std;
//虚析构和纯虚析构
class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}
	//virtual ~Animal()//利用虚析构，可以解决父类指针释放子类对象时不干净的问题
	//{
	//	cout << "Animal的析构函数调用" << endl;
	//}
	//纯虚函数
	virtual ~Animal() = 0;//纯虚析构
	virtual void speak() = 0;

};
Animal:: ~Animal()
{
	cout << "Animal的纯虚析构函数调用" << endl;
}
class Cat :public Animal
{
public:
	Cat(string name)
	{
		cout << "Cat的构造函数调用" << endl;
		m_Name = new string(name);
	}
	virtual void speak()
	{
		cout << *m_Name << "小猫在说话" << endl;
	}
	~Cat()
	{
		if (m_Name != NULL)
		{
			cout << "Cat析构函数调用" << endl;
			delete m_Name;
			m_Name = NULL;
		}
	}
	string* m_Name;
};
void test01()
{
	Animal* animal = new Cat("牛牛");
	animal->speak();
	//父类的指针在析构时，不会调用子类中的析构函数，导致子类如果有堆区属性，出现内存泄露
	delete animal;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

纯虚函数和抽象类

#include<iostream>
using namespace std;
//纯虚函数语法  virtual 返回值类型 函数名 （参数列表） = 0；
//当类中有了纯虚函数，这个类也成为抽象类
//抽象类无有法实例化对象
//抽象类的子类必须重写抽象类中的纯虚函数，否则也属于抽象类
class Base
{
public:
	virtual void func() = 0;//纯虚函数
};

class Son :public Base
{
public:
	void func()
	{
		cout << "func函数调用" << endl;
	}
};

void test01()
{
	/*Base b;
	new Base;*///抽象类不能实例化对象
	Base* base = new Son;
	base->func();
	Son s;
}

int main()
{
	system("pause");
	return 0;
}

案例1计算机类

#include<iostream>
#include<string>
using namespace std;
class Calculator
{
public:
	int getResult(string oper)
	{
		if (oper == "+") return m_Num1 + m_Num2;
		else if(oper == "-")return m_Num1 - m_Num2;
		else if (oper == "*")return m_Num1 * m_Num2;

	}
	int m_Num1;//操作数1
	int m_Num2;//操作数2
};
void test01()
{
	//创建计算器对象
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 9;
	cout << c.m_Num1 << " + " << c.m_Num2 <<"= " << c.getResult("+") << endl;
	cout << c.m_Num1 << " - " << c.m_Num2 <<"= " << c.getResult("-") << endl;
	cout << c.m_Num1 << " * " << c.m_Num2 <<"= "<< c.getResult("*") << endl;
	//如果扩展新的功能，需要修改源码
	//真实开发中，气场开闭原则
	//开闭原则：对扩展进行开发，对修改进行关闭
	//利用多态实现计算器
	//实现计算器的抽象类
}
//利用多态实现计算器
//实现计算器的抽象类
class AbstractCalculator
{
public:
	virtual int getResult()
	{
		return  0;
	}
	int m_Num1;
	int m_Num2;
};

//设计加法计算器类
class AddCalculator :public AbstractCalculator {
public:
	virtual int getResult()
	{
		return  m_Num1+m_Num2;
	}
};
//减法计算器类
class SubCalculator :public AbstractCalculator {
public:
	virtual int getResult()
	{
		return  m_Num1 - m_Num2;
	}
};
//乘法计算器类
class MulCalculator :public AbstractCalculator {
public:
	virtual int getResult()
	{
		return  m_Num1 * m_Num2;
	}
};
void test02()
{
	//多态使用条件
	//父类指针或者引用指向子类对象
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 99;
	abc->m_Num2 = 1;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	//用完后销毁
	delete abc;
	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 99;
	abc->m_Num2 = 1;
	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;
	//乘法运算
	abc = new MulCalculator;
	abc->m_Num1 = 99;
	abc->m_Num2 = 1;
	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;
}
int main()
{
	test01();
	cout << endl;
	test02();
	system("pause");
	return 0;
}
//多态好处
//组织结构清晰
//可读性强
//对于前期和后期扩展及维护性高

案例2制作饮品

#include<iostream>
using namespace std;
class AbstractDrinking
{
public:
	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourTnCup() = 0;
	//加入辅料
	virtual void PutSomething() = 0;
	//制作饮品
	void makeDrink()
	{
		Boil();
		Brew();
		PourTnCup();
		PutSomething();
	}
};
//制作咖啡
class Coffee :public AbstractDrinking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮农夫山泉" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	//倒入杯中
	virtual void PourTnCup()
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout << "加入糖和牛奶" << endl;
	}
};
class Tea :public AbstractDrinking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮农夫" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	//倒入杯中
	virtual void PourTnCup()
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout << "加入柠檬" << endl;
	}
};
void doWork(AbstractDrinking* abs)//AbstractDrinking * abs =new Coffee
{
	abs->makeDrink();
	delete abs;
}
void test01()
{
	//制作咖啡
	doWork(new Coffee);
	cout << endl;
	doWork(new Tea);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

电脑组装

#include<iostream>
using namespace std;
//抽象的CPU类
class CPU
{
public:
	//抽象的计算函数
	virtual void caculate() = 0;
};
//抽象的显卡
class ViedoCard
{
public:
	virtual void display() = 0;
};
class Memory
{
public:
	virtual void storage() = 0;
};
class computor
{

};
int main()
{
	system("pause");
	return 0;
}