标签:构造顺序 clu inf 方式 父类 name pac ima The
目录
1.1、什么是类的继承?
单继承派生类
class 派生类名: [继承方式] 基类名
{};
多继承派生类
派生类名:public 基类名 1, public 基类名 2, ...,protected 基类名 n
{};
总参数列表:子类的形参和所有基类的形参总和
内嵌子对象:本质组合类
无内嵌对象的子类构造函数
派生类名::派生类名(总参列表):基类名(参数表)
{}
//无内嵌子对象的子类构造函数
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class B: public A
{
public:
B(int b1,int a1):A(a1)
{
cout<<"B()"<<endl;
}
};
int main()
{
B b(1,2);
return 0;
}
//输出:
//A()
//B()
含内嵌子对象的子类
派生类名::派生类名(总参列表):基类名(参数表),内嵌子对象(参数表)
{}
//含内嵌子对象的子类
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class C
{
public:
C(int c1)
{
cout<<"C()"<<endl;
}
};
class B: public A
{
public:
B(int b1,int a1,int c1):A(a1),MYC(c1)
{
cout<<"B()"<<endl;
}
private:
C MYC;
};
int main()
{
B b(1,2,3);
return 0;
}
//输出:
//A()
//C()
//B()
含内嵌子对象的多继承子类
派生类名::派生类名(总参列表):
基类名 1(参数表 1),基类名(参数名 2)....基类名 n(参数名 n),
内嵌子对象 1(参数表 1),内嵌子对象 2(参数表 2)...内嵌子对象 n(参数表 n)
{};
//含内嵌子对象的多继承子类
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class C
{
public:
C(int c1)
{
cout<<"C()"<<endl;
}
};
class D
{
public:
D(int d1)
{
cout<<"D()"<<endl;
}
};
class B:public A,public C
{
public:
B(int b1,int a1,int c1,int d1):A(a1),C(c1),myd(d1)
{
cout<<"B()"<<endl;
}
private:
D myd;
};
int main()
{
B b(1,2,3,4);
return 0;
}
//输出:
//A()
//C()
//D()
//B()
多继承的构造顺序
//多继承的构造顺序
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class C
{
public:
C(int c1)
{
cout<<"C()"<<endl;
}
};
class B:public A,public C
{
public:
B(int b1,int a1,int c1):A(a1),C(c1) //C(c1),A(c1) 程序输出会有何不一样呢? 答:参数列表顺序改变无影响
{
cout<<"B()"<<endl;
}
};
int main()
{
B b(1,2,3);
return 0;
}
//输出:
//A()
//C()
//B()
多内嵌子对象的构造顺序
//多内嵌子对象的构造顺序
#include <iostream>
using namespace std;
class A
{
public:
A(int a1)
{
cout<<"A()"<<endl;
}
};
class C
{
public:
C(int c1)
{
cout<<"C()"<<endl;
}
};
class B
{
public:
B(int b1,int a1,int c1):MYA(a1),MYC(c1) //MYA(a1),MYC(c1)程序输出会有何不一样呢? 答:参数列表顺序改变无影响
{
cout<<"B()"<<endl;
}
private:
C MYC;
A MYA;
};
int main()
{
B b(1,2,3);
return 0;
}
//输出:
//C()
//A()
//B()
a、总的构造函数的调用顺序
构造顺序依次为:基类、内嵌子对象、派生类
b、多继承的基类的构造函数执行顺序为
class A: public b ,public c 重要:决定构造顺序
{
A():c(),c(),b() //无任何影响
{
}
}
总结: 基类的构造顺序仅与子类继承时的继承顺序有关,与构造函数的参数列表顺序无关。
该示例构造顺序依次为:b c a。
class B
{
}
class C
{
}
class A
{
A():c1(),b1() //无任何影响
{
}
private: 重要:决定构造顺序
B b1;
C c1;
}
总结: 内嵌子对象的构造顺序仅与子类实例化对象的先后有关,与构造函数的参数列表顺序无关。
该示例构造顺序依次为:b c a。
//示例1
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout<<"A()"<<endl;
}
};
class C
{
public:
};
int main()
{
A a;
C c;
}
//输出:
//A()
//示例2:
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout<<"A()"<<endl;
}
};
class C
{
public:
};
class B:public A,public C
{
public:
B(int b1,int a1,int c1,int d1)
{
cout<<"B()"<<endl;
}
};
int main()
{
B b(1,2,3,4);
return 0;
}
//输出:
//A()
//B()
不同点
1、默认构造函数指系统默认的隐士构造函数,不体现在用户代码中。当定义对象时它会隐士调用,内部可能不做任何操作。
2、无参构造函数指用户实现的构造函数,该函数没有参数,一旦用户定义对象时,该函数就会得到调用。
相同点
1、无参构造函数的类与默认构造函数的类定义对象时都一致,如:B b;
继承方式 | 属性 |
---|---|
public | 基类的公有成员和保护成员在派生类中保持原有访问属性,其私有成员仍为基类的私有成员。 |
private | 基类的公有成员和保护成员在派生类中成了私有成员,其私有成员 仍为基类的私有成员。 |
protected | 基类的公有成员和保护成员在派生类中成了保护成员,其私有成员仍为基类的私有成员。 |
原基类属性 | public | protected | private |
---|---|---|---|
子类继承方式 | public | public | public |
基类成员在子类属性 | public | protected | invisible |
标签:构造顺序 clu inf 方式 父类 name pac ima The
原文地址:https://www.cnblogs.com/retry/p/9308865.html