C++繼承中的同名覆蓋

1，父子間的沖突是由繼承帶來的，兩個類之間存在了繼承的關系，必然的會帶來一 些問題，本文要討論的是父子之間成員變量或成員函數的命名問題；

 

2，思考：

    1，子類中是否可以定義父類中的同名成員？

       1，可以，本文先編程解決這個問題；

       2，這個問題就是同名覆蓋問題；

    2，如果可以，如何區分？如果不可以，為什么？

   

3，同名成員變量編程實驗：

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;
};

class Child : public Parent
{
public:
    int mi;  // 編譯結果通過，子類可以定義父類里面的同名變量；
};

int main()
{
    Child c;
    
    c.mi = 100;    // mi 究竟是子類自定義的，還是從父類繼承得到的？
    
    return 0;
}

   

4，父子間的沖突（同名覆蓋）：

    1，子類可以定義父類中的同名成員；

    2，子類中的成員將隱藏父類中的同名成員；

       1，編譯器認為已經從父類中繼承得到這個成員了，又自定義了一個同名成員，目的只有一個，就是你想要自己自定義的同名成員、而不想要從父類那里繼承得到的同名成員，因此會產生同名覆蓋現象；

    3，父類中的同名成員依然存在於子類中；

       1，隱藏、不是銷毀；

    4，通過作用域分辨符（::）訪問父類中的同名成員；

   

5，訪問父類中的同名成員方式：

    1，Child c；

    2，c.mi = 100;  // 子類中的 mi；

    3，c.Parent::mi = 1000；  // 父類中的 mi；

   

6，同名成員變量深度分析編程實驗：

#include <iostream>
#include <string>

using namespace std;

namespace A
{
    int g_i = 0;
}

namespace B
{
    int g_i = 1;  // 同名的全局變量，但是位於兩個不同的命名空間；
}

class Parent
{
public:
    int mi;
    
    Parent()
    {
        cout << "Parent() : " << "&mi = " << &mi << endl;
    }
};

class Child : public Parent
{
public:
    int mi;  // 編譯器沒有簡單的對同名成員報錯，是因為作用域，雖然兩個成員的名字相同，但是出於不同的作用域當中；同命名空間的本質是一樣的；
    
    Child()
    {
        cout << "Child() : " << "&mi = " << &mi << endl;
    }
};

int main()
{
    Child c;  // Parent() : &mi = 0xbfb43a08    Child() : &mi = 0xbfb43a0c
    
    c.mi = 100;    
    
    c.Parent::mi = 1000;
    
    cout << "&c.mi = " << &c.mi << endl;  // &c.mi = 0xbfb43a0c，證明直接訪問的是子類的 mi；  
    cout << "c.mi = " << c.mi << endl;  // c.mi = 100；
    
    cout << "&c.Parent::mi = " << &c.Parent::mi << endl;  // &c.Parent::mi = 0xbfb43a08；  作用域分辨符訪問父類 mi；
    cout << "c.Parent::mi = " << c.Parent::mi << endl;  // c.Parent::mi = 1000；
    
    return 0;
}

    1，父類和子類可以產生同名覆蓋沖突，但是通過作用域分辨符可以解決這個問     題；

   

7，再論重載：

    1，類中的成員函數可以進行重載：

       1，重載函數的本質為多個不同的函數；

       2，函數名和參數列表是唯一的標識；

       3，函數重載必須發生在同一個作用域中；

      

8，問題：

    1，子類中定義的函數是否能重載父類中的同名函數？

       1，將父子間的沖突問題上升到成員函數了；

   

9，父子間的函數重載編程實驗：

    1，繼承父類成員函數，累加父類的同名成員；

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mi;
};

int main()
{
    Child c;
    
    c.mi = 100;    
    
    c.Parent::mi = 1000;
    
    cout << "c.mi = " << c.mi << endl;  // c.mi = 100；
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;  // c.Parent::mi = 1000；
    
    c.add(1);  // 繼承自父類的成員函數；這個函數得到的 mi 不知道后面還要定義一個子類，它知道的 mi 只是父類中的，這個時候 mi 的作用域在父類中，所以給了父類中的 mi 做累加；
    c.add(2, 3);  // 繼承自父類的成員函數；
    
    cout << "c.mi = " << c.mi << endl;  // c.mi = 100；
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;  // c.Parent::mi = 1006；累加到父類中的 mi 了；
    
    return 0;
}

    2，函數的同名覆蓋：

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mi;
    
    void add(int x, int y, int z)
    {
        mi += (x + y + z);
    }
};

int main()
{
    Child c;
    
    c.mi = 100;    
    
    c.Parent::mi = 1000;
    
    cout << "c.mi = " << c.mi << endl;  // c.mi = 100；
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;  // c.Parent::mi = 1000；
    
    // c.add(1);  // 編譯器顯示沒有匹配的函數調用 Child::add(int)；同名成員函數覆蓋，並沒有重載，作用域不同；
    // c.add(2, 3);  // 編譯器顯示沒有匹配的函數調用 Child::add(int, int)；同名成員函數覆蓋，並沒有重載，作用域不同；
    
    c.Parent::add(1);  // 作用域分辨符解決同名成員函數覆蓋問題；
    c.Parent::add(2, 3);  // 作用域分辨符解決同名成員函數覆蓋問題；累加父類中的 mi
    
    c.add(4, 5, 6);  // 調用子類中的 add()，默認情況下訪問的就是子類中的 mi，這個地方發生了同名覆蓋；
    
    cout << "c.mi = " << c.mi << endl;  // c.mi = 115；默認訪問的 mi 是子類中的 mi；
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;  // c.Parent::mi = 1006；前兩次累加的是父類中的 mi；
    
    return 0;
}

   

10，父子間的沖突：

    1，子類中的函數將隱藏父類的同名函數；

    2，子類無法重載父類中的成員函數；

       1，因為它們處於不同的作用域；

    3，使用作用域分辨符訪問父類中的同名函數；

       1，類名加上作用域分辨符；

    4，子類可以定義父類中完全相同的成員函數；

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;
    
    void add(int v)
    {
        mi += v;
    }
    
    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mi;
    
    void add(int v)  // 同名覆蓋；函數重寫；
    {
        mi += v;
    }
    
    void add(int a, int b)  // 同名覆蓋；函數重寫；
    {
        mi += (a + b);
    }
    
    void add(int x, int y, int z)  // 重載；
    {
        mi += (x + y + z);
    }
};

int main()
{
    Child c;
    
    c.mi = 100;    
    
    c.Parent::mi = 1000;
    
    cout << "c.mi = " << c.mi << endl;  // c.mi = 100；
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;  // c.Parent::mi = 1000；
    
    c.add(1);  // 同名覆蓋；
    c.add(2, 3);  // 同名覆蓋；
    c.add(4, 5, 6);  // 函數重載；
    
    cout << "c.mi = " << c.mi << endl;  // c.mi = 121；函數同名覆蓋和重載，都是默認訪問的子類的 mi；
    
    cout << "c.Parent::mi = " << c.Parent::mi << endl;  // 父類中的函數被同名覆蓋，未有訪問父類中的 mi；
    
    return 0;
}

   

11，小結：

    1，子類可以定義父類中的同名成員；

    2，子類中的成員將隱藏父類中的同名成員；

       1，包括同名成員變量和同名成員函數；

       2，重寫的依據；

       3，這就是同名覆蓋；

    3，子類和父類中的函數不能構成重載關系；

       1，作用域不同；

    4，子類可以定義父類中完全相同的成員函數；

       1，作用域不同；

    5，使用作用域分辨符訪問父類中的同名成員；

       1，父類名加上作用域分辨符；