public private, protect. 以及继承。 草稿。

#include <iostream>
#include <thread>
#include <memory>

// | 父类的public成员 | 父类的protected成员 | 父类的private成员
//---------------|------------------|---------------------|-----------------
//public继承 | public | protected | 访问不到
//---------------|------------------|---------------------|-----------------
//protected继承 | protected | protected | 访问不到
//---------------|------------------|---------------------|-----------------
//private继承 | private | private | 访问不到

using namespace std;

class Book
{
public:
string signture;
//virtual void showInfo() 不虚化,继承类如使用,基类指针,会调用基类方法.出错.
//除非使用派生类指针.非虚函数.会优先使用指针所定义的类型的方法(假如同名)
//从设计上说.这个就是程序本身错误的设计.继承的意义,就是继承类行为像一个基类,同名函数,而又不虚化,那么继承类中的同名非虚化函数就不应该存在.
//如果非要存在.就说明继承类行为上就不像一个基类.他们就不是继承关系.
void showInfo()
{
cout<<"book name:"<<name<<". price:"<<price<<". cost:"<<cost<<". supplier:"<<supplier<<". signtrue:"<<signture<<endl;
}
Book(const string& _name,int _c,int _p,const string& _s):name(_name),cost(_c),price(_p),supplier(_s){}

void SetCost(int _cost,int passWord)
{
if(passWord==123)
{
//private:只有book类的函数才可以访问.这里访问主体是book::SetCost(int,int,Book* this).访问对象是this->cost.
//虽然把setcost方法变成了public.但是我们可以利用函数的参数,要求输入密码.体现了类的封装性.
cost=_cost;
}
}

//可修改的参数,使用指针,不建议写成Book&, 参考google c++ 代码规范.
void SetOtherCost(int _cost,int passWord, Book* myBook)
{
if(passWord==123)
{
//这里访问主体是Book::SetOtherCost(int,int, Book* myBook,Book* this).访问对象是*myBook和*this.
myBook->cost=_cost;
cost=_cost;
}
}

private:
string name;
int cost;
int price;
string supplier;
};

//根据设计规范,只推荐book 和englichbook 继承一个抽象类.
//这里就english就强烈依赖book了.连showinfo.都没办法自定义.
class EnglichBook:public Book
{
public:
void showInfo()
{
cout<<"Tax:"<<tax<<". ";
Book::showInfo();
}
EnglichBook(const string& _name,int _c,int _p,const string& _s,int _tax):Book(_name,_c,_p,_s),tax(_tax){}
private:
int tax;
};

//public:任何函数都可以访问任何此类对象的public成员.
//private:就是说外部函数不可访问任何此类对象的私有成员.而类的内部函数可以访问任何此类对象的私有成员.

int main()
{
Book cpp=Book("c++ primer",20,50,"bird public");
cpp.showInfo();
cpp.signture=string("linson's book");//public:任何函数都可以访问.这里访问主体是main().访问对象是cpp.signture
//cpp.cost=5;//error. private:只有book类的函数才可以访问.
cpp.showInfo();

//密码错误,修改无效
cpp.SetCost(15,33);
cpp.showInfo();

//密码ok
cpp.SetCost(15,123);
cpp.showInfo();

Book cSharp=Book("c# good",10,20,"bird public");

//可以通过一个对象来访问另外一个对象的private私有成员.为什么.我们进入函数,分析一下.
cSharp.SetOtherCost(10,123,&cpp);
cpp.showInfo();
cSharp.showInfo();

EnglichBook cppEN=EnglichBook("c++ primer[EN]",20,50,"bird public",5);
Book* pcppen=&cppEN;
cppEN.showInfo();
pcppen->showInfo();//同名函数,且又不对基类函数虚化,产生的危害.
}

//public:任何函数都可以访问任何此类对象的public成员.
//private:就是说外部函数不可访问任何此类对象的私有成员.而类的内部函数可以访问任何此类对象的私有成员.
//protect:就是说外部函数不可访问任何此类对象的私有成员.而继承类类的内部函数可以访问任何此继承类对象的私有成员.
//但继承类的内部函数不可以访问基类的protect成员.

1.fun()==>fun(b* a)

2.fun(T*)==>fun(b* a,b* b)

如1，可以访问a的私有。那么也可以访问b的私有。

3.fun()==>fun(d* a)

4.fun(b*)==>fun(b* a,d* b)

如1，访问a的私有。但fun是继承类的函数。就不能访问除

不管基类还是继承类。他们的函数都只能访问本类产生出的对象的私有和protect。

也就是继承类不能访问基类对象的私有或protect对象。