Что говорит C++ 03 12.4/12 о вызове деструктора базового класса явно через указатель?

Question

Согласно C++ 03 12,4/12, когда деструктор вызывается явно

, если объект не относится к типу класса деструктора, а не из класса, производного от типа класса деструктора, программа имеет неопределенное поведение

так что у меня этот код:

class Base {}; 
class Derived : public Base {}; 

char memory[100]; 
new(memory) Derived(); 
Base* ptr = (Base*)memory; 
ptr->~Base(); 

Здесь объект типа Derived и «тип класса деструктор» является Base и поэтому л ooks, как в соответствии со стандартной формулировкой, нет оснований для UB.

Значит, код выше дает UB в соответствии со стандартом?

Answer 1

Правильно, нет неопределенного поведения.

В отличие есть потенциал UB в этом случае в зависимости от типов вовлеченных:

Base *ptr = new Derived(); 
delete ptr; 

Причина заключается в том, что для некоторых типов корректировка может быть применена к реализации, чтобы получить от Derived* до Base*. Таким образом, без указателя на полный объект нет возможности правильно освободить выделение памяти. Виртуальный деструктор гарантирует, что под-объект Base предоставляет достаточную информацию для реализации для восстановления (механизм виртуального вызова должен иметь возможность восстановить указатель Derived*, чтобы передать его как this).

Но в вашем примере память не освобождена, и поэтому нет мотивации сделать ее UB. Конечно, это еще плохая идея, так как концептуально объект Derived находится в неисправном состоянии. У вас нет законного способа позвонить ~Derived, даже. В вашем примере, хотя оба типа тривиально разрушаемы, поэтому нет нужно, чтобы вызвать деструктор.

Answer 2

, пожалуйста, исправьте меня, если я ошибаюсь, я думаю, что нет неопределенного поведения, но все же его следует избегать в сущности человечества (или поддержания целостности). но, рассмотрим, что Derived создает какой-либо элемент, например. общий указатель (который не является нетипичным даже для исключений :). я попробовал этот код на моей машине, а также на codepad:

class Base { 
public: 
    boost::shared_ptr<int> x; 
}; 
class Derived : public Base { 
public: 
    boost::shared_ptr<int> y; 
}; 


int main(int argc, char *argv[]) { 
    boost::shared_ptr<int> xx(new int(0xff)); 
    boost::shared_ptr<int> yy(new int(0xaa)); 

    int memory[100]; 
    for(int i=0; i<100; i++) 
    memory[i] = 0; 
    Derived* foo = new(memory) Derived(); 
    foo->x = xx; 
    foo->y = yy; 
    (*foo->y)--; 
    Base* ptr = (Base*)foo; 

    ptr->~Base(); 

    Derived* bar = new(memory) Derived(); 

    bar->x = xx; 
    bar->y = yy; 

    foo->~Derived(); 

    return 0; 
} 

здесь является то, что shared_ptr уу не выпустили, и никто не может гарантировать, чтобы никогда не забывать о Derived не должны предоставлять какие-либо вещи.

Answer 3

Это не UB, так как оба класса имеет тривиальные деструкторы, и поэтому вызов деструктора имеет тот же эффект, как не вызывающего деструктор (и не вызывающего деструктор, конечно, не UB).