C++ 子类的构造函数调用基类带参数的构造函数
时间: 2024-10-09 11:03:18 浏览: 8
在 C++ 中,当创建子类的对象时,如果子类的构造函数中包含了对基类带参数的构造函数的显式调用,那么这个过程被称为“初始化列表”(Initialization List)。这是通过在子类构造函数的第一行直接写出 `: base(param1, param2)` 来完成的,`base` 是基类的名称,`(param1, param2)` 是传递给基类构造函数的参数。
例如:
```cpp
class Base {
public:
Base(int a, int b) : value_a(a), value_b(b) {} // 带参构造函数
private:
int value_a;
int value_b;
};
class Derived : public Base { // 继承基类
public:
Derived(int c, int d) : Base(c, d) {} // 显式调用基类带参数构造
};
```
在这个例子中,`Derived` 的构造函数会先执行 `Base(c, d)` 的构造过程,再继续执行自身的其他初始化工作。这样做可以确保基类的状态在子类对象的构造过程中得到正确的设置。
相关问题
用定义student基类:数据成员name及其set和get函数,无参和有参构造函数,show() 定义student的子类undergraduate:增加数据成员major及其set和get函数,无参和有参构造函数,show( 在main函数中声明子类对象,调用成员函数,观察运行结果,理解类的继承,父类和子类构造函数调用时的关系,理解成员函的覆盖
下面是定义student基类和undergraduate子类的代码:
```C++
#include <iostream>
#include <string>
using namespace std;
class student {
private:
string name;
public:
student() {}
student(string n) : name(n) {}
void setName(string n) { name = n; }
string getName() { return name; }
virtual void show() { cout << "Name: " << name << endl; }
};
class undergraduate : public student {
private:
string major;
public:
undergraduate() {}
undergraduate(string n, string m) : student(n), major(m) {}
void setMajor(string m) { major = m; }
string getMajor() { return major; }
void show() { cout << "Name: " << getName() << ", Major: " << major << endl; }
};
int main() {
student s("Tom");
s.show(); // Name: Tom
undergraduate u("Jerry", "Computer Science");
u.show(); // Name: Jerry, Major: Computer Science
u.setName("Jack");
u.setMajor("Mathematics");
u.show(); // Name: Jack, Major: Mathematics
student* p = &u;
p->show(); // Name: Jack,因为调用的是子类的show函数,所以输出结果与父类的show函数不同
return 0;
}
```
在上面的代码中,我们定义了一个 `student` 基类,其中包含了一个数据成员 `name` 和相应的 set 和 get 函数,以及无参和有参构造函数和一个 `show` 函数。然后我们定义了一个 `undergraduate` 子类,它继承了 `student` 基类,并增加了一个数据成员 `major` 和相应的 set 和 get 函数,以及无参和有参构造函数和一个 `show` 函数。在 `undergraduate` 子类中,我们使用了 `student` 基类的构造函数来初始化其 `name` 成员。同时,我们还重写了 `show` 函数,使得在输出时包含了 `major` 数据成员的信息。
在 `main` 函数中,我们首先创建了一个 `student` 对象 `s` 和一个 `undergraduate` 对象 `u`,并分别调用了它们的 `show` 函数,观察输出结果。然后我们使用 set 函数修改了 `u` 对象的 `name` 和 `major` 数据成员,并再次调用了 `show` 函数,观察输出结果。接着,我们声明了一个 `student` 基类的指针 `p` 并将其指向 `u` 对象,然后调用了 `p` 所指向对象的 `show` 函数,观察输出结果。由于 `show` 函数是虚函数,因此在调用时会根据实际指向的对象来决定调用哪个版本的函数。在这个例子中,由于 `p` 指向的是 `undergraduate` 对象,因此调用的是 `undergraduate` 子类的 `show` 函数,输出了相应的信息。
c++多继承下调用基类构造函数
在C++多继承中,子类需要调用每个基类的构造函数来初始化基类的成员变量。具体来说,子类的构造函数应该在初始化列表中调用每个基类的构造函数,以确保每个基类的成员变量都能正确地初始化。下面是一个示例代码:
```cpp
class Base1 {
public:
Base1(int x) : m_x(x) {}
int m_x;
};
class Base2 {
public:
Base2(int y) : m_y(y) {}
int m_y;
};
class Derived : public Base1, public Base2 {
public:
Derived(int x, int y, int z) : Base1(x), Base2(y), m_z(z) {}
int m_z;
};
int main() {
Derived obj(1, 2, 3);
std::cout << obj.m_x << " " << obj.m_y << " " << obj.m_z << std::endl; // 输出 1 2 3
return 0;
}
```
在上面的示例代码中,`Derived`类继承了`Base1`和`Base2`两个类。在`Derived`的构造函数中,使用初始化列表调用了`Base1`和`Base2`的构造函数。这样,在`Derived`的构造函数中,每个基类的成员变量都能正确地初始化。