// 4 单一继承
/*
#include <iostream>
using namespace std;
class fatcher
{
private:
int height, width;
public:
void setHeight(int h){ this->height = h; }
void setWidth(int w){ this->width = w; }
void show()
{
cout<<"身高="<<height<<" 体重="<<width<<endl;
}
};
class sun : public fatcher
{
private:
int sunJK, sunPC;
public:
void setSunJK(int j){ this->sunJK = j;}
void setSunPC(int j){ this->sunPC = j;}
void showSun(){ cout<<"JK:"<<sunJK<<" PC:"<<sunPC<<endl;}
};
int main()
{
sun a;
a.setHeight(170);
a.setWidth(50);
a.setSunJK(100);
a.setSunPC(200);
a.show();
a.showSun();
return 0;
}*/
//5 公有型 保护型和私有型
/*
#include <iostream>
using namespace std;
class fatcher
{
//private:
protected:
int height, width;
public:
void setHeight(int h){ this->height = h; }
void setWidth(int w){ this->width = w; }
void show()
{
cout<<"身高="<<height<<" 体重="<<width<<endl;
}
};
class sun : public fatcher
{
private:
int sunJK, sunPC;
public:
void setSunJK(int j){ this->sunJK = j;}
void setSunPC(int j){ this->sunPC = j;}
//void showSun(){ cout<<"JK:"<<sunJK<<" PC:"<<sunPC<<endl;}
void show(){
cout<<"身高="<<height<<" 体重="<<width<<endl;
cout<<"JK:"<<sunJK<<" PC:"<<sunPC<<endl;}
};
int main()
{
sun a;
a.setHeight(170);
a.setWidth(50);
a.setSunJK(100);
a.setSunPC(200);
a.show();
//a.showSun();
return 0;
}*/
//6 公有派生的公有成员
/*
#include <iostream>
using namespace std;
class fatcher
{
public:
void root(){ cout<<"父亲的大房子我也可以享受"<<endl;}
};
//公有继承对父类的公有属性，就像自己的一样，可以随便用
class son:public fatcher
{
};
int main()
{
son s;
s.root();
return 0;
}*/
// 7 公有派生的保护成员
/*
#include <iostream>
using namespace std;
class fatcher
{
protected:
void room(){ cout<<"父亲的大房子我也可以享受"<<endl;}
};
//公有继承对父类的公有属性，就像自己的一样，可以随便用
//公有继承对像，父类的保护成员在子类中也是保护成员
class son:public fatcher
{
public:
void enjoy(){ room(); } //只能通过公用的接口来访问父类的保护成员room()
};
int main()
{
son s;
//s.root(); //无法访问保护成员
s.enjoy();
return 0;
}*/
//8 公有派生的私有成员
/*#include <iostream>
using namespace std;
class fatcher
{
protected:
void room(){ cout<<"父亲的大房子我也可以享受"<<endl;}
private:
void secret(){ cout<<"父亲的密秘"<<endl;}
};
//公有继承对父类的公有属性，就像自己的一样，可以随便用
//公有继承对像，父类的保护成员在子类中也是保护成员
class son:public fatcher
{
public:
void enjoy(){
room();
//secret(); 不能访问你类的私有成员
} //只能通过公用的接口来访问父类的保护成员room()
};
int main()
{
son s;
//s.root(); //无法访问保护成员
s.enjoy();
return 0;
}*/
//公有派生的赋值问题
/*
#include <iostream>
using namespace std;
class father
{
public:
int x;
void show(){ cout<<"x:"<<x<<endl;}
};
class son : public father
{
public:
int y;
};
int main()
{*/
/*father Nick;
son Jack;
Jack.y = 11;
Jack.x = 22;
Jack.show();
Nick = Jack; //这里可以将子类的对像赋值给父类，但不能把你类的对像赋值给子类
Nick.show();*/
/*father *p;
son Jack;
p = &Jack;
p->x = 3;
cout<<p->x<<endl;*/
/*
son Jack;
father &Nick = Jack;
return 0;
}*/
// 私有派生
/*
#include <iostream>
using namespace std;
class father
{
public:
void room(){cout<<"父亲的大房子我可以享受"<<endl;}
};
//私有继承
//class son: private father
//保护继承
class son: protected father
{
public:
void enjoy(){room();}
};
int main()
{
son a;
a.enjoy();
return 0;
}*/
// 11 多重继承
/*
#include <iostream>
using namespace std;
class father
{
public:
void setA(int a){toll = a;}
void printA(){ cout<<"身高:"<<toll<<endl;}
private:
int toll;
};
class mother
{
private:
int weight;
public:
void setB(int w){ weight = w;}
void printB(){ cout<<"体重"<<weight<<endl;}
};
//class son: public father, public mother
class son: public father, private mother
//以私有方式继承后，基类的私有成员变成不可访问，而公有成员和保护成员也变成了私有，派生类中的成员想要访问他们必须定义一个公有函数作为接口
{
private:
int age;
public:
void setC(int a){ age = a;}
void setb(int b){ setB(b);} //必须定义一个公有的接口来访问私有成员,两个成员不可访问的问题
void printC(){
printA();
printB();
cout<<"年龄:"<<age<<endl;
}
};
int main()
{
son s;
s.setA(170);
//s.setB(50);
s.setb(50);
s.setC(23);
s.printC();
return 0;
}*/
//12 继承和构造与析构
/*
#include <iostream>
using namespace std;
class father
{
private:
int a;
public:
father(int i){ a= i; cout<<"构造基类a的值:"<<a<<endl;}
~father(){ cout<<"析构基类a的值"<<a<<endl;}
};
class son: public father
{
private:
int b;
public:
son(int i, int j);
~son(){cout<<"析构子类b的值:"<<b<<endl;}
};
son::son(int i, int j):father(i)
{
b = j;
cout<<"构造子类的b的值:"<<b<<endl;
};
int main()
{
son a(11,22);
return 0;
}*/
//构造和析构的顺序
//先构造父类的构造函数，然后构造子类的构造函数
//先析构子类的析构函数，然后析构父类的析构函数
// 向基类构造函数传递参数
/*
#include <iostream>
#include <string>
using namespace std;
class father
{
protected:
string name;
int tall;
public:
father(string a, int i){ name=a, tall=i; cout<<"执行带两个参数的基类对像"<<endl; };
father(){cout<<"构造基类"<<endl;}
//这里是输出字符串的
void print(){cout<<" 身高为:"<<tall<<" Name:"<<name<<endl;}
~father(){cout<<"释放基类对像"<<endl;}
};*/
/*
father::father(string a, int i)
{
cout<<"\n 在基类的构造函数内\n";
name = a;
tall = i;
print();
cout<<"离开基类构造函数"<<endl;
};*/
/*
class son:public father
{
private:
int weight;
public:
son(string a, int i, int j);
void print1();
~son(){cout<<"离开子类对像"<<endl;}
};
son::son(string a, int i, int j):father(a, i)
{
//name = a;
//tall = i;
weight = j;
cout<<"在子类的构造函数内"<<endl;
};
void son::print1()
{
father::print();
cout<<"体重:"<<weight<<endl;
}
int main()
{
son Make("Mike",180,77);
Make.print1();
cout<<"程序执行完成"<<endl;
return 0;
}*/
// 向基类构造函数传递参数
/*
#include <iostream>
#include <string>
using namespace std;
class father
{
protected:
string name;
int tall;
public:
father(string a, int i);
father(){cout<<"构造基类"<<endl;}
//这里是输出字符串的
void print(){cout<<" 身高为:"<<tall<<" Name:"<<name<<endl;}
~father(){cout<<"释放基类对像"<<endl;}
};
father::father(string a, int i)
{
cout<<"\n 在基类的构造函数内\n";
name = a;
tall = i;
print();
cout<<"离开基类构造函数"<<endl;
};
class son:public father
{
private:
int weight;
public:
son(string a, int i, int j);
void print1();
~son(){cout<<"离开子类对像"<<endl;}
};
son::son(string a, int i, int j)
{
name = a;
tall = i;
weight = j;
cout<<"在子类的构造函数内"<<endl;
};
void son::print1()
{
father::print();
cout<<"体重:"<<weight<<endl;
}
int main()
{
son Make("Mike",180,77);
Make.print1();
cout<<"程序执行完成"<<endl;
return 0;
}
*/
//多重继承容易产生两义性
/*
#include <iostream>
using namespace std;
class A
{
public:
void hello(){cout<<"基类A的hello函数"<<endl;}
};
class B
{
public:
void hello(){cout<<"基类B的hello函数"<<endl;}
};
class C : public A, public B
{
public:
void hello(){cout<<"基类C的hello函数"<<endl;}
};
int main()
{
C c;
c.hello(); //这里多重继承容易产生两义性
c.A::hello(); //这里可以去掉两义性
c.B::hello();
return 0;
}
*/
//15 继承中的重载
/*
#include <iostream>
using namespace std;
class father
{
public:
void hello(){cout<<"基类的事带参数的hello函数"<<endl;}
void hello(int i){ cout<<"基类的带一个参数hello函数"<<endl;}
};
class son:public father
{
public:
void hello(){cout<<"子类的事带参数的hello函数"<<endl;}
//当我们在子类中定义一个与基类同名的函数时，那么等于是告诉编译器，用子类的函数覆盖掉基类的同名函数，同时将它重载函数隐藏起来.
void hello()const{cout<<"子类的事带参数的const hello函数"<<endl;}
//这里与hello()函数是不一样的，因为hello()const函数只能被const对像所调用
void hello(int i){ cout<<"子类的带一个参数hello函数"<<endl;}
};
int main()
{
son s;
s.hello();
//s.hello(2); //将不能再访问了
const son ss;
ss.hello();
return 0;
}*/
/*
#include <iostream>
using namespace std;
class A
{
public:
void hello(){cout<<"基类A的hello函数"<<endl;}
void hello(int i)
{
cout<<"a.hello(i):"<<i<<endl;
cout<<"基类a的带一个参数的hello函数"<<endl;
}
};
class B : public A
{
public:
//void hello(){ cout<<"子类b的hello函数"<<endl;}
//还是一种方法是添加const,这样就不会把父类的函数隐藏起来了
void hello()const{ cout<<"子类b的hello函数"<<endl;}
void hello(int i)const{
cout<<"b.hello(i):"<<i<<endl;
cout<<"子类B的带一个参数的hello函数"<<endl;
}
};
int main()
{
B b;
b.hello();
b.hello(11);
//b.hello(11); //把带参的重载函数会是被隐藏起来了
//b.A::hello(11); //呵呵，这样也行，不握你隐藏起来
return 0;
}*/
// 16 两义性的归属问题
//一个派生类从多个基类派生，而这些基类双有一个共同的基类，那么在派生类中访问共同的基类中的成员时会产生两义性
/*
#include <iostream>
using namespace std;
class Human
{
public:
void stand(){cout<<"人类能够直立行走"<<endl;}
};
class father: public Human
{
};
class mother: public Human
{
};
class son : public father, public mother
{
};
int main()
{
son s;
//s.stand();//两义性的归属问题
s.mother::stand();
return 0;
}*/
//17 虚基类不会产生两义性
/*
#include <iostream>
using namespace std;
#include <iostream>
using namespace std;
class Human
{
public:
void stand(){cout<<"人类能够直立行走"<<endl;}
};
//virtual 声明为虚基类
class father:virtual public Human
{
};
class mother:virtual public Human
{
};
class son : public father, public mother
{
};
int main()
{
son s;
//s.stand();//两义性的归属问题
//s.mother::stand();
s.stand();
return 0;
};*/
#include <iostream>
using namespace std;
#include <iostream>
using namespace std;
class Human
{
public:
void stand(){cout<<"人类能够直立行走"<<endl;}
};
//virtual 声明为虚基类
class father:virtual public Human
{
public:
void stand(){cout<<"父类能够直立行走"<<endl;}
};
class mother:virtual public Human
{
public:
void stand(){cout<<"母类能够直立行走"<<endl;}
};
class son : public father, public mother
{
public:
void stand(){cout<<"子类能够直立行走"<<endl;}
};
int main()
{
son s;
s.stand();
father f;
f.stand();
mother m;
m.stand();
Human h;
h.stand();
return 0;
};
