1.1.2 封装意义二

        类在设计时;可以把属性和行为放在不同的权限下;加以控制

        访问权限有三种;

                1. public                 公共权限;成员 类内类外都可以访问

                2. protected            保护权限;成员 类内可以访问;类外不可以访问 

                                                                 子类可以访问父类中的保护内容

                3. private                私有权限;成员 类内可以访问;类外不可以访问

                                                                 子类可以不可以访问父类中的私有内容

1.2 struct和class区别

在C;;中struct和class唯—的区别就在于默认的访问权限不同

区别;

        struct默认权限为公共;如下代码中;无错误提示

        class默认权限为私有;如下代码中;有错误提示

1.3 成员属性设置为私有

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

        优点2;对于写权限;我们可以检测数据的有效性;判断写入的数据是否合规;

        示例;;我想设置私有成员中的 

                                姓名 / 可读可写  

                                年龄 / 只读

                                id / 只写

                        ;

        解决思路;

        可以在公有权限中;对三个私有属性分别设置相应的成员函数;如果要可读可写;就在公有权限中编辑读和写的函数。

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	// 设置姓名;可写姓名;
	void setName(string name)
	{
		m_Name = name;
	}
	// 获取姓名;可读姓名;
	string getName()
	{
		return m_Name;
	}

private:
	string m_Name;
	int m_age;
	int id;
};


int main() {
	Person p;
	p.setName(;张三;);

	cout << ;姓名;; << p.getName() << endl;

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

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

	// 2. 析构函数
	~Person()
	{
		cout << ;Person 析构函数的调用; << endl;
	}
};

void test01()
{
	Person p;
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	// 传统初始化操作;通过构造函数初始化属性
	Person(int a, int b, int c)
	{
		m_A = a;
		m_B = b;
		m_C = c;
	}

	int m_A;
	int m_B;
	int m_C;
};

void test01()
{
	Person p(10, 20, 30);
	cout << ;m_A = ; << p.m_A << endl;
	cout << ;m_B = ; << p.m_B << endl;
	cout << ;m_C = ; << p.m_C << endl;
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	Person():m_A(10),m_B(10),m_C(30)
	{
	}

	int m_A;
	int m_B;
	int m_C;
};

void test01()
{
	Person p;
	cout << ;m_A = ; << p.m_A << endl;
	cout << ;m_B = ; << p.m_B << endl;
	cout << ;m_C = ; << p.m_C << endl;
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

class A {}
class B
{
    A a;
}

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	static int m_A;  // 类内申明
};

int Person::m_A = 100;  // 类外初始化

void test01()
{
	Person p;
	cout << ;p的 m_A = ; << p.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << ;p2的 m_A = ; << p.m_A << endl;
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

Person p;
cout << p.m_A << endl;

cout << Person::m_A << endl;

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	static void func()
	{
		cout << ;调用func; << endl;
	}
};

void test01()
{
	// 通过对象访问
	Person p;
	p.func();

	// 通过类名访问
	Person::func();
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	Person(int age)
	{
		// this指针指向被调用的成员函数 所属的对象
		this->age = age;
	}
	int age;
};

void test01()
{
	Person p1(18);
	cout << ;p1的年龄; << p1.age << endl;
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	void showClassName()
	{
		cout << ;show class name; << endl;
	}

	void showPersonAge()
	{
		cout << ;age = ; << this->m_Age << endl;
	}

	int m_Age;
};

void test01()
{
	Person * p = NULL;
	//p->showClassName();
	p->showPersonAge();
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	void showClassName()
	{
		cout << ;show class name; << endl;
	}

	void showPersonAge()
	{
		if (this == NULL)
		{
			return;
		}
		cout << ;age = ; << this->m_Age << endl;
	}

	int m_Age;
};

void test01()
{
	Person * p = NULL;
	//p->showClassName();
	p->showPersonAge();
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

const Person p;

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	void showPerson(int num) const
	{
		m_A = num;
	}

	mutable int m_A;
};

void test01()
{
	const Person p;
	p.showPerson(100);
	cout << p.m_A << endl;

}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Building
{
	friend void goodFriend(Building *building);  //表示goodFriend全局函数是本类的友元;可以访问本类的私有属性

public:
	Building()
	{
		m_SittingRoom = ;客厅;;
		m_BedRoom = ;卧室;;
	}
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};

void goodFriend(Building *building)
{
	cout << ;goodFriend 正在访问;; << building->m_BedRoom << endl;
}

void test01()
{
	Building building;
	goodFriend(&building);
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Building;
class goodFriend
{
public:
	goodFriend();
	void visit();  //用来访问Building中的属性
	Building * building;
};

class Building
{
	friend class goodFriend;  //表示goodFriend类是Building类的友元;可以访问Building中的私有成员
public:
	Building();
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};

// 类外写成员函数
Building::Building()  //Building的构造函数
{
	m_SittingRoom = ;客厅;;
	m_BedRoom = ;卧室;;
}
goodFriend::goodFriend()  //goodFriend的构造函数
{
	// 创建building对象
	building = new Building;
}

void goodFriend::visit()
{
	cout << ;goodFriend类正在访问;; << building->m_SittingRoom << endl;
	cout << ;goodFriend类正在访问;; << building->m_BedRoom << endl;
}

void test01()
{
	goodFriend gg;
	gg.visit();
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Building;
class goodFriend
{
public:
	goodFriend();  //申明构造函数
	void visit(); //让visit函数可以访问Building中的私有成员

	Building * building;
};

class Building
{
	friend void goodFriend::visit();  //让goodFriend类中的visit成员函数作为本类的友元
public:
	Building();  //申明构造函数
public:
	string m_SitingRoom;
private:
	string m_BedRoom;
};

//类外实现成员函数
Building::Building()
{
	m_SitingRoom = ;客厅;;
	m_BedRoom = ;卧室;;
}

goodFriend::goodFriend()
{
	building = new Building;
}

void goodFriend::visit()
{
	cout << ;visit函数正在访问;; << building->m_SitingRoom << endl;
	cout << ;visit函数正在访问;; << building->m_BedRoom << endl;
}


void test01()
{
	goodFriend gg;
	gg.visit();
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	Person operator;(Person &p)
	{
		Person temp;
		temp.m_A = this->m_A ; p.m_A;
		temp.m_B = this->m_B ; p.m_B;
		return temp;
	}
	int m_A;
	int m_B;
};

void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;

	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	Person p3 = p1 ; p2;
    //Person p3 = p1.operator;(p2);  // 成员函数重载本质调用

	cout << ;p3.m_A = ; << p3.m_A << endl;
	cout << ;p3.m_B = ; << p3.m_B << endl;
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	int m_A;
	int m_B;
};

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;
}

void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;

	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	Person p3 = p1 ; p2;
    // Person p3 = operator;(p1, p2)  // 全局函数重载本质调用
	cout << ;p3.m_A = ; << p3.m_A << endl;
	cout << ;p3.m_B = ; << p3.m_B << endl;
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Java
{
public:
	void header() 
	{
		cout << ;header; << endl;
	}
	void footer()
	{
		cout << ;footer; << endl;
	}
	void content()
	{
		cout << ;---Java---; << endl;
	}
};

class Python
{
public:
	void header()
	{
		cout << ;header; << endl;
	}
	void footer()
	{
		cout << ;footer; << endl;
	}
	void content()
	{
		cout << ;---Python---; << endl;
	}
};

void test01()
{
	Java ja;
	ja.footer();
	ja.header();
	ja.content();
	Python py;
	py.footer();
	py.header();
	py.content();
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

//继承实现
class Base
{
public:
	void header()
	{
		cout << ;header; << endl;
	}
	void footer()
	{
		cout << ;footer; << endl;
	}
};

class Java :public Base
{
public:
	void content()
	{
		cout << ;---Java---; << endl;
	}
};

class Python :public Base
{
public:
	void content()
	{
		cout << ;---Python---; << endl;
	}
};

void test01()
{
	Java ja;
	ja.footer();
	ja.header();
	ja.content();
	Python py;
	py.footer();
	py.header();
	py.content();
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

//继承实现
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 s;
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

//继承实现
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	int m_A;
};

class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	int m_A;
};

void test01()
{
	Son s;
	cout << ;Son m_A = ; << s.m_A << endl;  // 访问子类中的m_A
	cout << ;Base m_A = ; << s.Base::m_A << endl;  // 访问父类中的m_A
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

//继承实现
class Base
{
public:
	void func()
	{
		cout << ;调用Base的func; << endl;
	}
};

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

void test01()
{
	Son s;
	s.func();  // 直接调用;调用的是子类中同名的成员函数
	s.Base::func();  // 调用父类中的func
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

//继承实现
class Base
{
public:
	static int m_A;  // 类内申明
};
int Base::m_A = 100; //类外初始化

class Son :public Base
{
public:
	static int m_A;
};
int Son::m_A = 200;

// 同名静态成员属性
void test01()
{
	// 通过对象访问
	Son s;
	cout << ;Son的m_A = ; << s.m_A << endl;
	cout << ;Base的m_A = ; << s.Base::m_A << endl;

	// 通过类名访问
	cout << ;Son的m_A = ; << Son::m_A << endl;
	cout << ;Base的m_A = ; << Son::Base::m_A << endl;  // 第一个::代表通过类名方式访问; 第二个::代表访问父类作用域下
};

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

//继承实现
class Base
{
public:
	static void func()
	{
		cout << ;Base static void func(); << endl;
	}
};

class Son :public Base
{
public:
	static void func()
	{
		cout << ;Son static void func(); << endl;
	}
};

// 同名静态成员函数
void test02()
{
	Son s;
	s.func();  // 调用子类的func
	s.Base::func();  // 调用父类的func
}

int main() {
	test02();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>


class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};

class Base2
{
public:
	Base2()
	{
		m_B = 200;
	}
	int m_B;
};

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 << s.Base1::m_A << endl;
	cout << s.Base2::m_B << endl;
	cout << s.m_C << endl;

}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>


class Animal
{
public:
	int m_Age;
};

class Sheep : public Animal {};
class Tuo : public Animal {};

class SheepTuo : public Sheep, public Tuo {};


// 同名静态成员函数
void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 28;
	// 当菱形继承;两个父类拥有相同成员属性时;可以用作用域加以区分
	cout << ;st.Sheep::m_Age = ; << st.Sheep::m_Age << endl;
	cout << ;st.Tuo::m_Age = ; << st.Tuo::m_Age << endl;
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>


class Animal
{
public:
	int m_Age;
};

// 利用虚继承 解决菱形继承的问题
class Sheep : virtual public Animal {};
class Tuo : virtual public Animal {};

class SheepTuo : virtual public Sheep, public Tuo {};


// 同名静态成员函数
void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 28;
	// 当菱形继承;两个父类拥有相同成员属性时;可以用作用域加以区分
	cout << ;st.Sheep::m_Age = ; << st.Sheep::m_Age << endl;
	cout << ;st.Tuo::m_Age = ; << st.Tuo::m_Age << endl;
	cout << st.m_Age << endl;
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>


class Animal
{
public:
	void speak()
	{
		cout << ;Animal speak; << endl;
	}
};

class Cat :public Animal
{
public:
	void speak()
	{
		cout << ;Cat speak; << endl;
	}
};


// 同名静态成员函数
void doSpeak(Animal &animal)  // 地址早绑定;在编译阶段确定函数地址
{
	animal.speak();
}

void test01()
{
	Cat cat;
	doSpeak(cat);
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>


class Animal
{
public:
	virtual void speak()  //虚函数
	{
		cout << ;Animal speak; << endl;
	}
};

class Cat :public Animal
{
public:
	void speak()
	{
		cout << ;Cat speak; << endl;
	}
};

class Dog :public Animal
{
public:
	void speak()
	{
		cout << ;Dog speak; << endl;
	}
};


// 同名静态成员函数
void doSpeak(Animal &animal)  // 地址早绑定;在编译阶段确定函数地址
{
	animal.speak();
}

void test01()
{
	Cat cat;
	doSpeak(cat);
	Dog dog;
	doSpeak(dog);
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Calculate
{
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;
	int m_Num2;
};

void test01()
{
	// 创建计算器对象
	Calculate c;
	c.m_Num1 = 10;
	c.m_Num2 = 20;

	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;
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

// 利用多态实现计算器

//实现计算器抽象类
class AbstractCalculator
{
public:
	virtual int getResult()
	{
		return 0;
	}

	int m_Num1;
	int m_Num2;
};

//加法计算器类
class AddCalculator :public AbstractCalculator
{
public:
	int getResult()  //子类重写父类中的虚函数
	{
		return m_Num1 ; m_Num2;
	}
};

//减法计算器类
class SubCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};

//乘法计算器类
class MulCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};

void test02()
{
	//多态使用条件
	//父类指针或者引用指向子类对象

	//加法运算
	AbstractCalculator * abc = new AddCalculator;  //父类指针指向子类对象
	abc->m_Num1 = 10;
	abc->m_Num2 = 20;
	cout << abc->m_Num1 << ; ; ; << abc->m_Num2 << ; = ; << abc->getResult() << endl;
	delete abc;  //销毁指针

	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 200;
	cout << abc->m_Num1 << ; - ; << abc->m_Num2 << ; = ; << abc->getResult() << endl;
	delete abc;

	//乘法运算
	abc = new MulCalculator;
	abc->m_Num1 = 5;
	abc->m_Num2 = 15;
	cout << abc->m_Num1 << ; * ; << abc->m_Num2 << ; = ; << abc->getResult() << endl;
	delete abc;
}

int main() {
	test02();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;

class Base
{
public:
	// 只要类中有一个纯虚函数;这个类就称为抽象类
	virtual void func() = 0;
};

int main() {

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Base
{
public:
	virtual void func() = 0;
};

class Son :public Base
{
public:
	virtual void func() {}
};

void test01()
{
	//Son s;
	Base * base = new Son;
	base->func();
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class AbstractMakeDrinking
{
public:
	virtual void Boil() = 0;  //煮水
	virtual void Brew() = 0;  //冲泡
	virtual void PourInCup() = 0;  //倒入杯中
	virtual void PutSomeThing() = 0; //加入辅料
	
	void makeDirnk()  //只要一调用makeDirnk;就会执行这4个步骤
	{
		Boil();
		Brew();
		PourInCup();
		PutSomeThing();
	}
};

class MakeCoffee:public AbstractMakeDrinking
{
public:
	virtual void Boil()
	{
		cout << ;煮水; << endl;
	}
	virtual void Brew()
	{
		cout << ;冲泡; << endl;
	}
	virtual void PourInCup()
	{
		cout << ;倒入水中; << endl;
	}
	virtual void PutSomeThing()
	{
		cout << ;加入牛奶; << endl;
	}
};

class MakeTea :public AbstractMakeDrinking
{
public:
	virtual void Boil()
	{
		cout << ;煮水; << endl;
	}
	virtual void Brew()
	{
		cout << ;冲泡; << endl;
	}
	virtual void PourInCup()
	{
		cout << ;倒入水中; << endl;
	}
	virtual void PutSomeThing()
	{
		cout << ;加入柠檬; << endl;
	}
};

void doWork(AbstractMakeDrinking * abs)
{
	abs->makeDirnk();
	delete abs;  //释放指针;在堆区;
}

void test01()
{
	doWork(new MakeCoffee);
	cout << ;————————; << endl;
	doWork(new MakeTea);
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

#include<iostream>
using namespace std;
#include<string>

class Animal
{
public:
	Animal()
	{
		cout << ;调用Animal构造函数; << endl;
	}
	~Animal()
	{
		cout << ;调用Animal析构函数; << endl;
	}
	virtual void speak() = 0;  //纯虚函数
	
};

class Cat :public Animal
{
public:
	Cat(string name)
	{
		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(;Tom;);
	animal->speak();
	delete animal;
}

int main() {
	test01();

	system(;pause;);
	return 0;
}

~Animal()
{
	cout << ;调用Animal析构函数; << endl;
}

virtual ~Animal()
{
	cout << ;调用Animal析构函数; << endl;
}

class Animal
{
public:
	Animal()
	{
		cout << ;调用Animal构造函数; << endl;
	}
	virtual ~Animal() = 0;  //纯虚析构
	virtual void speak() = 0;  //纯虚函数

};

Animal::~Animal()
{
	cout << ;调用Animal纯虚析构函数; << endl;
}