C ++ вызывает суперкласс

Question

Я в основном программист на Java и AS3, но сейчас я кое-что работаю в C ++ и наткнулся на проблему.У меня есть базовый класс (назовем его ClassA) с закрытой переменной var1.В этом классе у меня есть метод getVar1 (), который возвращает указатель на эту переменную.

Далее у меня есть другой класс, который расширяет Base (назовем его ClassB).Как мне вызвать getVar1 () из суперкласса?В Java это так просто, как this.var1 = super.getVar1 ().

Я читал, что это похоже на var1 = ClassA :: getVar1 (), но я не уверен, что это нормально для работы спеременные (иначе указатели могут меняться).

Спасибо.

Answer 1

нормально называть его ClassA :: getVar1 ().

Однако, если вы хотите использовать Java-способ, вы можете сделать метод «виртуальным».Это означает, что всякий раз, когда вы пишете getVar1 (), это не зависит от типа, который вы написали перед ним (так во время компиляции), но это зависит от типа объекта, когда вы вызываете его (во время выполнения).По этой причине c ++ хранит внутреннюю v-таблицу для поиска подходящего метода.Это эквивалентно Java-пути и называется поздним связыванием.

Answer 2

getVar1() должно быть достаточно

class ClassB : public ClassA
{
...
   void foo() { yourvartype* v = getVar1(); ... }
};

если вы в OTOH определили другой getVar1() в ClassB, тогда ClassA::getVar1() следует использовать, чтобы помочь компилятору определить, какую функцию вызывать.

Answer 3

Вот небольшой пример, показывающий, что происходит: - А инициализирует х в 10 - B инициализирует х в 20 ниже вы можете увидеть, как работают вызовы виртуальных функций и как работает вызов вашего родителя (даже если вы инициализировали значение по-другому)

самое важное, что нужно иметь в виду, это то, что даже если вы вызываете вашу суперфункцию (A :: GetX), она все равно использует значение из вашего собственного класса (B :: x)

class A
{
public:
    A::A() : x(10) {}
virtual int GetX() {return x*2;}
protected:
    int x; 
};

class B : public A
{
public:
    B::B() : A()
    {
        x = 20;
    }
    virtual int GetX() {return x;}
};

int _tmain(int argc, _TCHAR* argv[])
{
    A* a1 = new A();
    B* b1 = new B();
    int test1 = a1->GetX(); // returns 20 (because x is 10, but function doubles value)
    int test2 = b1->GetX(); // returns 20 (because x is initialized at 20)
    return 0;
}

Теперь, если мы изменим B :: GetX на:

virtual int GetX() {return A::GetX();}

Получаем следующий результат:

int _tmain(int argc, _TCHAR* argv[])
{
A* a1 = new A();
B* b1 = new B();
int test1 = a1->GetX(); //returns 20 (as previously)
int test2 = b1->GetX(); // return 40 (x is initialized by B at 20, but then the
                        // A:GetX is called, which doubles the result)
return 0;
}