032继承的构造函数
#include<iostream>
#include<cstdlib>
#include<string>
#include<vector>
using namespace std;
class A
{
public:
A(int i,int j,int k=7):number01(i),number02(j),number03(k)
{
;
}
A()
{}
public:
int number01;
int number02;
int number03;
};
class B:public A
{
public:
using A::A;
};
int main(void)
{
B b1(3, 4, 5);
B b2;
system("pause");
return 0;
}
033多重继承与多层继承
#include<iostream>
#include<cstdlib>
#include<string>
#include<vector>
using namespace std;
class GrandFather1
{
public:
int myValueGrand;
public:
GrandFather1(int i):myValueGrand(i)
{}
virtual ~GrandFather1()
{
cout << "GrandFather1的析构函数执行" << endl;
}
void myInfo()
{
cout << "我是GrandFather01" << myValueGrand << endl;
}
};
class GrandFather02
{
public:
int myValueGrand02;
public:
GrandFather02(int i) :myValueGrand02(i)
{}
virtual ~GrandFather02()
{
cout << "GrandFather1的析构函数执行" << endl;
}
void myInfo()
{
cout << "我是GrandFather02" << endl;
}
};
class Father:public GrandFather1
{
public:
int myValueFather;
public:
Father(int i,int k):GrandFather1(i),myValueFather(k)
{
;
}
virtual ~Father()
{
cout << "这是Father类的析构函数" << endl;
}
void myInfo()
{
cout << "我是Father" << endl;
}
};
class Son:public Father
{
public:
int myValueSon;
public:
Son(int i,int j,int k):Father(i,j),myValueSon(k)
{
}
virtual ~Son()
{
cout << "这是son类的洗头函数"<<endl;
}
void myInfo()
{
cout << "我是son" << endl;
}
};
class Father02:public GrandFather1,public GrandFather02
{
public:
int myVlaueFather02;
public:
Father02(int i,int j,int k):GrandFather1(i),GrandFather02(j),myVlaueFather02(k)
{}
virtual ~Father02()
{
cout << "这是类Father02类的析构函数" << endl;
}
void myInfo()
{
cout << "我是Father02,继承自两个Grandfather1,02" << endl;
}
};
class Son02:public Father02
{
public:
int myValueSon02;
public:
Son02(int i,int j,int k,int m):Father02(i,j,k),myValueSon02(m)
{
;
}
};
int main(void)
{
Father02 my_father01(1, 2, 3);
my_father01.myInfo();
my_father01.GrandFather02::myInfo();
system("pause");
return 0;
}
034派生类构造函数与析构函数顺序
#include<iostream>
#include<cstdlib>
#include<string>
#include<vector>
using namespace std;
class A
{
public:
int a;
A(int i):a(i)
{
cout << "A构造函数执行" << endl;
}
virtual ~A()
{
cout << "A析构函数" << endl;
}
};
class B1:public A
{
public:
int b1;
B1(int i,int j):A(i),b1(j)
{
cout << "B1构造函数执行" << endl;
}
virtual ~B1()
{
cout << "B1析构函数" << endl;
}
};
class B2 :public A
{
public:
int b2;
B2(int i, int j) :A(i), b2(j)
{
cout << "B2构造函数执行" << endl;
}
virtual ~B2()
{
cout << "B2析构函数" << endl;
}
};
class C:public B1,public B2
{
public:
int c;
C(int i,int j, int k):B1(i,j),B2(i,j),c(k)
{
cout << "c构造函数执行" << endl;
}
public:
static int static_number;
public:
virtual ~C()
{
cout << "C析构函数" << endl;
}
};
int C::static_number = 10;
void playObject()
{
C c1(1, 2, 3);
c1.static_number = 12;
C::static_number = 30;
}
int main(void)
{
playObject();
system("pause");
return 0;
}
035从基类继承构造函数
#include<iostream>
#include<cstdlib>
#include<string>
#include<vector>
using namespace std;
class A
{
public:
int a;
A(int i) :a(i)
{
cout << "A构造函数执行" << endl;
}
virtual ~A()
{
cout << "A析构函数" << endl;
}
};
class B1 :public A
{
public:
int b1;
B1(int i, int j) :A(i), b1(j)
{
cout << "B1构造函数执行" << endl;
}
virtual ~B1()
{
cout << "B1析构函数" << endl;
}
};
class B2 :public A
{
public:
int b2;
B2(int i, int j) :A(i), b2(j)
{
cout << "B2构造函数执行" << endl;
}
virtual ~B2()
{
cout << "B2析构函数" << endl;
}
};
class C :public B1, public B2
{
public:
int c;
C(int i, int j, int k) :B1(i, j), B2(i, j), c(k)
{
cout << "c构造函数执行" << endl;
}
public:
static int static_number;
public:
virtual ~C()
{
cout << "C析构函数" << endl;
}
};
int C::static_number = 10;
void playObject()
{
;
}
int main(void)
{
playObject();
system("pause");
return 0;
}
036虚基类与虚继承
#include<iostream>
#include<cstdlib>
#include<string>
#include<vector>
using namespace std;
class A
{
public:
int a;
A(int i) :a(i)
{
cout << "A构造函数执行" << endl;
}
A(){}
virtual ~A()
{
cout << "A析构函数" << endl;
}
};
class B1 :virtual public A
{
public:
int b1;
B1(int j) : b1(j)
{
cout << "B1构造函数执行" << endl;
}
virtual ~B1()
{
cout << "B1析构函数" << endl;
}
};
class B2 :virtual public A
{
public:
int b2;
B2(int j) : b2(j)
{
cout << "B2构造函数执行" << endl;
}
virtual ~B2()
{
cout << "B2析构函数" << endl;
}
};
class C :public B1, public B2
{
public:
int c;
C(int i, int j, int k) : A(i), B1(j), B2(j), c(k)
{
cout << "c构造函数执行" << endl;
}
public:
static int static_number;
public:
virtual ~C()
{
cout << "C析构函数" << endl;
}
};
int C::static_number = 10;
void playObject()
{
B1*b_point1 = new C(1,2,3);
C c2(11, 22, 33);
c2.c = 55;
cout << c2.c << endl;
}
int main(void)
{
playObject();
system("pause");
return 0;
}