Насколько это виртуально?

Question

вы можете объяснить мне, почему:

int main (int argc, char * const argv[]) { 
    Parent* p = new Child(); 
    p->Method(); 
    return 0; 
} 

печатает "ребенка :: Метод()", а это:

int main (int argc, char * const argv[]) { 
    Parent p = *(new Child()); 
    p.Method(); 
    return 0; 
} 

печатает "Родитель :: Method()"?

Классы:

class Parent { 
public: 
    void virtual Method() { 
     std::cout << "Parent::Method()"; 
    } 
}; 

class Child : public Parent { 
public: 
    void Method() { 
     std::cout << "Child::Method()"; 
    } 
}; 

спасибо, Etam.

Answer 1

Ваш второй код экземпляры a Child объект в переменной Parent. По способу slicing он теряет всю информацию, относящуюся к Child (т. Е. Все частные поля, частичные к Child) и, как следствие, связанную с ним информацию о виртуальном методе.

Кроме того, оба ваших кода утечки памяти (но я думаю, вы знаете это).

Вы можете использовать ссылки. Например:

Child c; 
Parent& p = c; 
p.Method(); // Prints "Child::Method" 

Answer 2

В первом случае вы называете реальный объект имеет класс детей:

Parent* p = new Child(); // you new'ed Child class 
p->Method(); // and a method of a Child class object is getting called 

, поэтому для детей :: Метод() вызывается. Во втором случае вы копируете объект класса Child на объект класса Родитель:

Parent p = *(new Child()); // you new'ed Child, then allocated a separate Parent object on stack and copied onto it 
p.Method(); // now you have a Parent object and its method is called 

и Parent :: Метод() вызывается.

Answer 3

Во втором примере происходит срез: экземпляр Child-instance преобразуется в родительский экземпляр, который не имеет записи vtable для Child-метода. Детский метод «разрезан».

Answer 4

В первом случае у вас есть указатель «Родитель» на объекте «Ребенок», который является каким-то общим, поскольку «Ребенок» наследуется от «Родитель». Следовательно, вызывается перегруженный метод «Child».

Во втором случае вы создаете неявный приведение экземпляра «Child» к типу «Родитель», поэтому вы вызываете метод на объекте «Родитель».

Надеюсь, что это поможет.

Answer 5

В первом примере вы вызываете метод через указатель:

p->Method(); 

В этом случае «р» является указателем на Родитель, и C++ знает, что Родитель имеет V-таблицу , поэтому он использует это, чтобы найти фактический метод для вызова, который в этом случае, как вы заявляете, является Child::Method(), потому что, когда C++ находит v-таблицу, он находит v-таблицу «нового» экземпляра Child.

Во втором примере вы вызываете метод на примере:

p.Method(); 

В этом случае «р» является экземпляром Родитель и C++ предполагает, что он знает, что точный тип действительно «Родитель» и так он звонит Parent::Method() без прохождения каких-либо v-таблиц.

Я только что проверил это с VS2008 и выше, на самом деле то, что происходит, и есть не нарезая, однако, я думаю, что нарезка делает происходит, но вы видите, что только его во втором случае, если вы сделали:

Parent& q=p; 
q.Method(); 

Потом я вижу: Parent :: Метод() печатаемого. q.Method() должен быть виртуальным вызовом, но он может найти только v-таблицу для родителя.

Answer 6

Виртуальное поведение доступно, только если виртуальная функция - , вызываемая указателем или ссылкой. Когда вы говорите:

Parent p = *(new Child()); 
p.Method(); 

у вас есть реальный объект Parent, поэтому метод родителя не всегда будет вызываться, независимо от того, что вы назначаете р.

Answer 7

В первом случае тип объекта, на который указывает указатель p, имеет тип «Child». Поскольку дочерний элемент переопределяет виртуальный метод, определенный в базовом классе, вызывается метод child. Во втором случае у вас есть , который копирует дочерний объект в родительский объект. Здесь происходит разбиение объектов, и тип результирующего объекта имеет тип «Родитель». Следовательно, когда вы вызываете метод, вызывается метод parent.

Answer 8

Полиморфизм в C++ возможен только с указателями. Различие между статическим и динамическим типом (в вашем первом примере p имеет статический тип Parent *, но динамического типа Child *, и это позволяет C++ вызвать метод производного класса) не вступает в игру с не указателями ,

Answer 9

Что произойдет, если вы сделаете это?

int main (int argc, char * const argv[]) { 
    Parent &p = *(new Child()); 
    p.Method(); 
    return 0; 
} 

То есть один и тот же «синтаксический» эффект (p не требует разыменований, чтобы использовать его), но семантический эффект не является в настоящее время полностью отличается, потому что вы больше не копировать часть Child в Parent.

Answer 10

Ваш первый случай прост. Экземпляр Ребенка создается и присваивается p. Поэтому вызов p-> Method() вызывает Child :: Method().

Во втором случае, четыре вещи:

1. Экземпляр класса детей, которые были определены временной переменной компилятором присваивается, создается.
2. Создан экземпляр класса Parent, идентифицированный переменной p.
3. Создатель копирования Parent :: Parent (родительский &) вызывается, когда p создается для копирования родительского «среза» состояния экземпляра Child на p. Обратите внимание, что если вы не определяете этот конструктор копирования, тогда компилятор создает его для вас.
4. Вы вызываете метод() на p, который является экземпляром Родитель.

Попробуйте явно определить конструктор копирования, и вы увидите, что он вызывается.

Ваше возможное замешательство, вероятно, связано с тем, что задания (=) в двух примерах делают разные вещи. В первом примере он просто устанавливает один указатель, равный другому, и есть только один объект. Во втором нет указателей, поэтому вы назначаете (нарезку) значение. Это вызывает конструктор копирования, и вы получаете два объекта (ребенок и родитель). Тот факт, что компилятор создает невидимую временную переменную, не помогает понять, что происходит. Вы можете проверить статью this о конструкторах копий.

Это легкая ошибка, если вы привыкли к языкам, таким как Java или C#, где в основном все является ссылкой (также называемой указателем).

Как говорили другие, полиморфизм работает только с указателями и ссылками, и они не используются в вашем втором примере.