当前位置：文档之家 › 派生类调用基类构造函数

派生类调用基类构造函数

  • 格式：docx
  • 大小：36.84 KB
  • 文档页数：3

派生类调用基类构造函数

在C++中，派生类调用基类构造函数有两种方式：一种是使用基类的默认构造函数，另一种是使用基类的有参构造函数。

使用基类的默认构造函数：

当基类的构造函数没有参数时，我们可以直接在派生类的构造函数中调用基类的构造函数，如下所示：

class Base

public:

Bas

cout << "基类的默认构造函数被调用" << endl;

}

};

class Derived: public Base

public:

Derive

cout << "派生类的默认构造函数被调用" << endl;

}

};

int mai Derived obj;

return 0;

输出结果为：

基类的默认构造函数被调用

派生类的默认构造函数被调用

在这个例子中，派生类 Derived 继承了基类 Base 的成员，当创建

Derived 对象时，会先调用基类 Base 的构造函数，再调用派生类

Derived 的构造函数。

如果基类的构造函数是带参数的，同时派生类的构造函数也是带参数的，则需要使用初始化列表来调用基类的构造函数。

使用基类的有参构造函数：

当基类的构造函数带有参数时，派生类在调用基类的构造函数时需要使用初始化列表来传递参数，如下所示：

class Base

public:

Base(int x)

cout << "基类的有参构造函数被调用，参数为：" << x << endl;

}

};

class Derived: public Base public:

Derived(int y): Base(y)

cout << "派生类的有参构造函数被调用，参数为：" << y << endl;

}

};

int mai

Derived obj(10);

return 0;

输出结果为：

基类的有参构造函数被调用，参数为：10

派生类的有参构造函数被调用，参数为：10

在这个例子中，基类 Base 的构造函数带有 int 类型的参数，派生类 Derived 在调用基类构造函数时使用初始化列表传递参数。派生类的构造函数也可以带有其他参数，并使用初始化列表来传递给基类构造函数。

总结一下，派生类调用基类构造函数的方式有两种：使用基类的默认构造函数和使用基类的有参构造函数。使用初始化列表传递参数是保证基类成员变量正确初始化的关键。这样做的好处是能够减少冗余代码，提高代码的复用性和可维护性。同时，派生类调用基类构造函数也是面向对象编程中的一种封装和继承的体现。

合集下载

虚基类构造函数

虚基类构造函数

虚基类构造函数

虚基类是 C++ 中的一种派生技术，可以让派生类继承多个基类的成员，但是每个基类只会在派生类中出现一次。虚基类构造函数是用于构造虚基类对象的函数，它在虚基类对象的构造过程中被调用。本文将深入探讨虚基类构造函数的相关知识。

一、虚基类的定义和使用

虚基类是指在多层继承结构中，被声明为虚基类的基类。在使用虚基类的过程中，我们可以使用虚基类指针来访问虚基类成员，从而避免多次继承中出现的二义性问题。

下面是一个使用虚基类的示例：

```c++

class Base {

protected:

int data;

};

class Derive1 : virtual public Base {

public:

void set(int x) { data = x; }

};

class Derive2 : virtual public Base {

public:

int get() { return data; }

};

class MI : public Derive1, public Derive2 {

};

MI obj; obj.set(5);

std::cout << obj.get(); // 输出5

}

```

在这个示例中，虚基类 Base 中的数据成员被 Derive1 和 Derive2 继承。在派生类

MI 中使用虚基类，可以使得 MI 类只继承一份 Base 类对象，从而避免 data 成员的二义性问题。

二、虚基类构造函数的调用

虚基类构造函数的调用是在虚基类对象的构造过程中完成的。虚基类构造函数的调用顺序是根据派生类构造函数的执行顺序而确定的。

对于下面的代码：

C++派生类的构造函数

C++派生类的构造函数

前面我们说基类的成员函数可以被继承，可以通过派生类的对象访问，但这仅仅指的是普通的成员函数，类的构造函数不能被继承。构造函数不能被继承是有道理的，因为即使继承了，它的名字和派生类的名字也不一样，不能成为派生类的构造函数，当然更不能成为普通的成员函数。

在设计派生类时，对继承过来的成员变量的初始化工作也要由派生类的构造函数完成，但是大部分基类都有 private

属性的成员变量，它们在派生类中无法访问，更不能使用派生类的构造函数来初始化。

这种矛盾在C++继承中是普遍存在的，解决这个问题的思路是：在派生类的构造函数中调用基类的构造函数。

下面的例子展示了如何在派生类的构造函数中调用基类的构造函数：

1. #include

2. using namespace std;

3.

4. //基类People

5. class People{

6. protected:

7. char *m_name;

8. int m_age;

9. public:

10. People(char*, int);

11. };

12. People::People(char *name, int age): m_name(name), m_age(age){}

13.

14. //派生类Student 15. class Student: public People{

16. private:

17. float m_score;

18. public:

19. Student(char *name, int age, float score);

20. void display();

21. };

22. //People(name, age)就是调用基类的构造函数

23. Student::Student(char *name, int age, float score): People(name, age), m_score(score){ }

自考C++程序结果及答案

自考C++程序结果及答案

1. 给出下面程序输出结果。

#include

class a

{public:

virtual void print()

{cout<< "a prog..."<< endl;};};

class b:public a

{};

class c:public b

{public:

void print(){cout<<"c

prog..."<

void show(a *p)

{(*p).print();}

void main()

{a a;

b b;

c c;

show(&a);

show(&b);

show(&c);}

答案：a prog...

a prog...

c prog...

［解析］考查多态性的。a类对象调用本身的虚函数，b类因为没有覆写print，所以仍然调用基

类的虚函数。而c类重新定义print虚函数，所以调用c类的print。

2. 给出下面程序输出结果。

#include

#include

#include

bool fun(long n);

void main()

{long a=10,b=30,l=0;

if(a%2==0) a++;

for(long m=a;m<=b;m+=2)

if(fun(m))

{if(l++%10==0)

cout <

cout <

}

} bool fun(long n)

{int sqrtm=(int)sqrt(n);

for(int i=2;i<=sqrtm;i++)

if(n%i==0)

return false;

return true;

}

答案：11 13 17 19 23 29

［解析］循环体用来判断n是否是质数的函数,在main函数判断10～30之间质数。

3. 给出下面程序输出结果。

#include

class Test

{int x,y;

public:

Test(int i,int j=0)

{x=i;y=j;}

虚基类构造函数调用顺序

虚基类构造函数调用顺序

class Base1 {

public:

Base1(void) {

cout << "class Base1" << endl;

}

};

class Base2 {

public:

Base2(void) {

cout << "class Base2" << endl;

}

};

class Level1:virtual public Base2,public Base1 {

public:

Level1(void) {

cout << "class Level1" << endl;

}

};

class Level2:public Base2,virtual public Base1 {

public:

Level2(void) {

cout << "class Level2" << endl; }

};

class Leaf:public Level1,virtual public Level2 {

public:

Leaf(void) {

cout << "class Leaf" << endl;

}

};

int main(void) {

Leaf obj;

return 0;

}

不看下面的分析，大家觉得输出结果应该是怎么样的？如果没有虚拟继承，也许能很快说出答案。

现在来分析一下在多继承和虚拟继承的情况下，构造函数的调用顺序是怎么样的。

编译器按照直接基类在声明中的顺序，来检查虚拟基类的出现情况。在我们的例子中，Level1首先被检查，然后是Level2。每个继承子树按照深度优先的顺序被检查。即，查找从树根类开始，然后向下移动。如对子树Level1而言，先检查Base2,然后是Base1，再到Level1。但是在虚拟继承中，基类构造函数的查找顺序只是为了知道虚拟继承的情况而已，基类构造函数的调用顺序和查找顺序是不一样的，那应该遵循什么样的一个原则呢?