C++中继承时的初始化列表和函数重载（overload）_c++继承其他类后还能用初始化列表赋值吗

在C++中的一个重要内容就是可继承性，继承后的子类拥有父类中的所有方法和属性，因此子类在继承后就可以对父类中的属性初始化。在类中可通过构造函数，对一个类中的属性采用列表的方式进行初始化，例如用一个程序来管理学生的基本信息：

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

class Student{
    string _name;
    char _gender;
    int _studentNumber;
    int _gerad;
public:
    Student(const string& name, const char gender, const int studentNumber, const int gerad): _name(name), _gender(gender),_studentNumber(studentNumber),_gerad(gerad){}
    //上一行为构造函数，通过列表的形式直接初始化所有的属性。形式为：“；”后面接赋值情况，括号中为参数，前面为属性名
    string text(){  //输出学生信息
        stringstream ss;
        ss << "姓名:\t" << _name << endl;
        ss << "性别:\t" << _gender << endl;
        ss << "学号：\t" << _studentNumber <<endl;
        ss << "成绩:\t" << _gerad << endl;
        return ss.str();
    }
};

int main(){
    Student A("Xiao Ming", 'M', 12345678, 95);
    Student B("Xiao Hong", 'F', 22345678, 94);
    Student C("Xiao Gang", 'M', 32345678, 93);
    cout << A.text() << endl;
    cout << B.text() << endl;
    cout << C.text() << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

输出结果：

上面程序中对对象的属性的赋值，便采用了初始化列表的方式。同样的地这种方式也可用在继承中，例如下面要将男女生信息分开采集。那么除了性别之外，其他的都一样。例如：

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

class Student{
    string _name;
    int _studentNumber;
    int _gerad;
public:
    Student(const string& name, const int studentNumber, const int gerad) : _name(name),_studentNumber(studentNumber),_gerad(gerad){}
    //上一行为构造函数，通过列表的形式直接初始化所有的属性。形式为：“；”后面接赋值情况，括号中为参数，前面为属性名
    string text(){  //输出学生信息
        stringstream ss;
        ss << "姓名:\t" << _name << endl;
        ss << "学号：\t" << _studentNumber <<endl;
        ss << "成绩:\t" << _gerad << endl;
        return ss.str();
    }
};

class Male : public Student{   //男生类是学生类的继承者
public:
    Male(const string& name, const int studentNumber, const int gerad) : Student(name, studentNumber, gerad){} //对子类Male初始化，同样也将参数传递，但构造函数时将父类的属性全部交给父类，只保留自己特有的属性
    void text(){
        cout << Student::text() << endl;  //父类方法被子类重载，但此处调用了父类方法
    }
};

class Female : public Student{   //男生类是学生类的继承者
public:
    Female(const string& name, const int studentNumber, const int gerad) : Student(name, studentNumber, gerad){} //对子类Male初始化，同样也将参数传递，但构造函数时将父类的属性全部交给父类，只保留自己特有的属性
    void text(){
        cout << Student::text() << endl;
    }
};

int main(){
    Male A("Xiao Ming", 12345678, 95);
    Female B("Xiao Hong", 22345678, 94);
    Male C("Xiao Gang", 32345678, 93);
    Female D("Xiao Xin", 42345678, 99);
    cout << "男生：\n";
    A.text();
    C.text();
    cout << "女生：\n";
    B.text();
    D.text();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

输出结果：

子类也可以对父类中的方法进行重载（overload），重载方法和类中的重载方法完全一致，但也可以是相同类型的重载，例如：

#include <iostream>
using namespace std;

class A{
public:
    void f(){
        cout << "A::f()" << endl;
    }

    void h(){
        cout << "A::g()" << endl;
    }
};

class B : public A{
public:
    void f(){   //该函数为子类的方法f，对父类进行了重载
        cout << "B::f()" << endl;  //对父类中的方法f重载，方法类型与父类中的完全相同。
    }
};

int main(){
    B b;
    b.f();  //调用B中的方法f
    b.h();  //调用A中的方法h
    A a;
    a.f();  //此处调用父类中的f
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

输出结果：

如果子类需要重载父类中的方法，同时又需要再次调用父类中的方法，则需要声明该方法为父类中的方法，声明方法和名空间的声明方法相似——“：：”，例如：

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

class A{
public:
    void f(){
        cout << "调用类A的f" << endl;
    }

    void g(){
        cout << "调用类A中的g" << endl;
    }
};

class B : public A{
public:
    void f(){  //对父类A中的方法f进行重载
        cout << "调用类B中的f" << endl;
    }

    void g(){  //对父类A中的方法g进行重载
        cout << "调用类B中的f" << endl;
    }
};

int main(){
    B b;
    b.f();  //调用B中的方法f
    b.g();  //调用B中的方法g
    b.A::f();//调用A中的方法f
    b.A::g();//调用A中的方法g
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

输出结果：

如有错误，欢迎大家批评与指正！