c++之——派生类的同名成员和函数调用方式及构造析构顺序

#include<iostream>
using namespace std;
class Object {
public:
    Object(int test) :a(1), b(2), c(3) { cout << "object 构造\n"; }
    ~Object()
    {
        cout << "object 析构\n";
    }
    int a;
    int b;
    int c;
    void same_fuc()
    {
        cout << "object test...\n";
    }
    void o_print()
    {
        cout << "a b c is" << a << " " << b << " " << c << endl;
    }

};
class Parent :public Object {
public:
    Parent(int test):Object(1), a(100),b(200),c(300),obj1(1),obj2(2)//NOTE
    {
        cout << "parent 构造。。。\n";
    }
    ~Parent()
    {
        cout << "Parent 析构。。。\n";
    }
    int a;
    int b;
    int c;
    void same_fuc()
    {
        cout << "Parent test...\n";
    }
    void p_print()
    {
        cout << "a b c is" << a << " " << b << " " << c << endl;
    }
    Object obj1;
    Object obj2;
};
class Child :public Parent
{
public:
    Child() :Parent(1), a(1000), b(2000), c(3000) { cout << "child 构造\n"; }
    ~Child()
    {
        cout << "child 析构，，，\n";
    }
    void c_print()
    {
        cout << "a b c is" << a << " " << b << " " << c << endl;
    }
    void same_fuc()
    {
        cout << "child test...\n";
    }
    int a;
    int b;
    int c;
};

int main()
{

    Child c1;
    c1.c_print();
    c1.a = 520;//默认等价于c1.Child::a=520;
    c1.c_print();
    c1.Parent::a = 5200;
    c1.p_print();
    c1.c_print();
    c1.Object::a = 52000;
    c1.o_print();
    c1.c_print();

    c1.same_fuc();//默认等价于c1.Child::same_fuc();
    c1.Parent::same_fuc();
    c1.Object::same_fuc();
    return 0;
}

 

上诉代码，如果直接使用子类对象调用子类的某个和父类同名函数或者使用同名变量，默认使用子类的，但我们可以加上域作用符强制使用父类的属性或者方法。

 

同名函数再探：

#include<iostream>
using namespace std;

class Parent {
public:
    Parent(int test):a(100),b(200),c(300)
    {
        cout << "parent 构造。。。\n";
    }
    ~Parent()
    {
        cout << "Parent 析构。。。\n";
    }
    int a;
    int b;
    int c;
    virtual void same_fuc()//不加virtual就不会产生多态
    {
        cout << "Parent test...\n";
    }
    void p_print()
    {
        cout << "a b c is" << a << " " << b << " " << c << endl;
    }

};
class Child :public Parent
{
public:
    Child() :Parent(1), a(1000), b(2000), c(3000) { cout << "child 构造\n"; }
    ~Child()
    {
        cout << "child 析构，，，\n";
    }
    void c_print()
    {
        cout << "a b c is" << a << " " << b << " " << c << endl;
    }
    void same_fuc()
    {
        cout << "child test...\n";
    }
    int a;
    int b;
    int c;
};
void test(Parent &p)
{
    p.same_fuc();
}
int main()
{

    Child c1;
    test(c1);
    Parent p1(1);
    test(p1);
    return 0;
}

 当且仅当对通过引用或者指针调用虚函数时，才会在运行时解析该调用，也只有在这种情况下对象的动态类型才有可能与静态类型不同。

一旦某个函数被声明成虚函数，则在所有派生类中它都是虚函数。

一个派生类的函数如果覆盖了某个继承而来的虚函数，那么它的参数类型必须与被它覆盖的基类函数完全一致。同样，返回类型也必须与基类匹配，该返回类型规则存在一个例外，当类的虚函数返回类型是类本身的指针或者引用时，该返回类型匹配一致规则无效。eg：如果B类由A类派生得到，则基类A的虚函数可以返回A*或者A&而派生类B对应的虚函数可以返回B*或者B&，但是这样的返回类型要求从B到A的类型是可以访问的。