вопрос наследования c ++

Question

У меня есть вопрос по этому поводу:

class A
{
  int a;
  int* pa;
public:
   A(int i):a(i) , pa(new int(a))
   {
      cout<<"A ctor"<<a<<endl;
   }
   ~A()
    {
      delete pa;
      cout<<"dtor\n";
    }
    int * &get()
    {
     return pa;
    }
};

class B : public A
{
     int b;
public:
      B (A obj): A(obj) , b(0)
      {
       cout<<"B ctor\n";
      }
      ~B()
      {
       cout<<"B dtor\n";
      }
};

int main()
{
 int i = 23 ; 
 A* p = new B(i);
}

Скажите, почему компилируется последняя строка в main? Я передаю int в B конструктор, который ожидает объект A. Я считаю, что int переводится в A в конструкторе B, но почему?

Заранее спасибо.

Avri.

Answer 1

Поскольку вы не объявили A конструктор как explicit, компилятор создает аномимный экземпляр A с использованием i и использует его для инициализации B экземпляра. Если вы не хотите, чтобы компилятор делал эти неявные преобразования, объявите ваш конструктор как explicit. Тогда вы получите ошибку компилятора.

Answer 2

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

Когда вы делаете new B(i), поскольку единственный жизнеспособный конструктор для B принимает A, делается попытка преобразовать i в A и построить из него новый B.Это преобразование выполняется путем создания временного A с использованием конструктора, который принимает int.

Когда создается объект B, базовый класс A является копией, созданной из временного A что означает копирование переменных-членов a и pa из временного A.

Строго говоря, поскольку конструктор принимает A объект по значению, временный объект концептуально копируется снова.Однако компилятор может исключить временное, создав параметр конструктора для B непосредственно из i, поэтому эффект может выглядеть просто как одна копия.

Это приведет к серьезной ошибке, потому что когдавременное A уничтожено, delete pa приведет к уничтожению динамически выделенного int, но базовый класс A вновь выделенного объекта B все еще будет иметь копию этого указателя, которая теперь больше не указывает на недопустимыйобъект.Если компилятор не удаляет одну из копий, немедленно произойдет «двойное освобождение».

Ключевым аспектом A является то, что он имеет определенный пользователем деструктор, который выполняет действие с ресурсом (освобождение)).Это строгое предупреждение о том, что A требуется пользовательский конструктор копирования и оператор назначения копирования, поскольку версия, сгенерированная компилятором, вероятно, не будет работать согласованно с дизайном A.

Это известно как "правило трех ", которое гласит, что если вам нужна пользовательская версия одного из деструктора, конструктора копирования или оператора копирования, то вам, вероятно, потребуются пользовательские версии всех из них.

Были ли выпопытка освободить динамически размещенный объект B в вашем примере, это, вероятно, приведет к ошибке «двойного освобождения».Кроме того, деструктор A должен быть помечен как virtual для удаления через указатель на A для правильной работы.

Answer 3

Поскольку происходит преобразование из int в A, неявно ваш код переводится в

 A* p = new B(A(i));