继承时的变量作用域

Question

我在 C++ 中有两个类，一个类继承另一个类：

class A {
public: 
    virtual void Initialize(){
        m_MyString = "Default value";
    }

protected: 
     string m_MyString;
}

class B : public A {
public: 
    void Initialize(){ 
       A::Initialize(); 
       m_MyString = "New Value";
    }
}

上面的 B 类和这个类有区别吗？

class B : public A {
public: 
    void Initialize(){ 
       A::Initialize(); 
       A::m_MyString = "New Value";
    }
}

似乎使用作用域运算符会导致字符串出现垃圾，对吗？我在想当它覆盖时，A::m_MyString 与B::m_MyString 不同。这还有道理吗？

我看到变量在 A 中设置，然后当我们返回 B 时，出现垃圾。这与“隐藏”与覆盖有关吗？

Answer 1

您的代码在很多方面都是无效的。它应该看起来像：

class A { // << errors were here
public: 
    virtual void Initialize(){
        m_MyString = "Default value";
    }

protected: 
     string m_MyString;
}; // << lost ;

class B : public A // << errors were here
{
public: 
    virtual void Initialize(){  // << virtual
       A::Initialize(); // has no effect in the end

       A::m_MyString = "New Value"; // same as `m_MyString = "New Value";`
    }
}; // << lost ;

在上面的代码中，与 m_MyString 没有区别。发布您的实际代码，有错误。

如果您的代码如下所示：

class B : public A
{
public: 
    virtual void Initialize(){
       // here is a difference
       A::m_MyString = "New Value"; 
       m_MyString = "New Value";
    }
protected: 
     string m_MyString; // !!! overridden
};

那么存在差异，因为 B 有两个 m_MyString 实例：A::m_MyString 和 B： :m_MyString。

Answer 2

您是否从 A 的构造函数中调用 Initialize() ？

不建议在构造函数中调用虚方法。例如，如果 A 的构造函数看起来像

A::A() {
  Initialize();
}

B 的 Initialize 方法，则永远不会被调用。

查看您的实际代码会有很大帮助。

Answer 3

B 类的这两个版本之间没有区别。这是您在其中看到垃圾的真实代码吗？

Answer 4

编译器应该告诉您是否从构造函数调用虚函数。但如果没有，那肯定是有问题的。

我认为你可以在派生类中将虚函数设为final，但也许不行。无论是否显式定义作用域，变量都应该是相同的，除非派生类中有同名的变量。

Answer 5

如果您的代码如下所示：

using namespace std;

class A 
{
    public:
        virtual void Initialize()
        {
            m_MyString = "Default value";
        }

    protected:
        string m_MyString;
};

class B : public A 
{
    public:
        void Initialize()
        {
            A::Initialize();
            m_MyString = "New Value";
        }

        void display()
        {
            cout<<m_MyString<<endl;
        }
};

int main()
{
    B b;
    A a;

    b.Initialize();
    b.display();

    return 0;
}

那么您在问题中描述的 B 类的两个版本之间没有区别。我添加显示功能只是为了让值更清晰。根据您给出的类的定义，m_MyString 不会被覆盖。因此，m_MyString 变量将被分配“新值”，即类 A 和 B 将共享变量 m_MyString。

如果您像这样重写 B 类中的 m_MyString

class B : public A 
{
    public:
        void Initialize()
        {
            A::Initialize();
            m_MyString = "New Value";
        }

    void display()
    {
        cout<<m_MyString<<endl;
    }

    protected:
        string m_MyString;
};

那么 B::m_MyString 的值将包含“新值”，而 A::m_MyString 的值将包含“默认值”。

Answer 6

<块引用>

似乎使用作用域运算符会导致字符串出现垃圾，对吗？

不，这应该有效，并且在调用 b.Initialize() 后 m_MyString 将具有“新值”。

<块引用>

我在想当它覆盖时，A::m_MyString 与 B::m_MyString 不同。做
这还有道理吗？

不会，当一个类 B 继承另一个类 A 时，类 B 的对象将具有两者的数据成员的并集。在本例中，只有一个 m_MyString，即 A::m_MyString。

<块引用>

我看到变量在 A 中设置，然后当我们返回 B 时，出现垃圾。
这与“隐藏”与覆盖有关吗？

不，m_MyString 只有一个实例。

您绝对需要阅读此内容 - http://www.openrce.org/articles/files /jangrayhood.pdf。