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

Например, определение класса Body не отображается когда delete оператор называется на указателе на Body:

class Handle {
  class Body *impl;  
public:
  ~Handle() { delete impl; }
  // ...
};

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

Подобная проблема происходит, например, когда вы удрученный к указателю на неполный класс (downcasting бросает от указателя до базового класса к указателю на производный класс). При downcasting, отношении между основой и производным классом не известен. В частности, если производный класс наследовался нескольким классам при downcasting, эта информация не доступна. downcasting не может внести необходимые корректировки для множественного наследования, и получившийся указатель не может быть разыменован.

Подобный оператор может быть сделан для upcasting (бросающий от указателя до производного класса к указателю на базовый класс).

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

В качестве альтернативы можно выполнить одно из этих действий:

class Handle {
  class Body *impl;  
public:
  ~Handle() { delete impl; } 
  // ...
};

В этом примере, определении класса Body не отображается когда указатель на Body удален.

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

class Handle {
  class Body *impl;  
public:
  ~Handle();
  // ...
};
 
// Elsewhere
class Body { /* ... */ };
  
Handle::~Handle() {
  delete impl;
}

Другая возможная коррекция должна использовать std::shared_ptr введите вместо регулярного указателя.

#include <memory>
  
class Handle {
  std::shared_ptr<class Body> impl;
  public:
    Handle();
    ~Handle() {}
    // ...
};

File1.h:

">class Base {
protected:
  double var;
public:
  Base() : var(1.0) {}
  virtual void do_something();
  virtual ~Base();
};

File2.h:

">void funcprint(class Derived *);
class Base *get_derived(); 

File1.cpp:

#include "File1.h"
#include "File2.h"
 
void getandprint() {
  Base *v = get_derived();
  funcprint(reinterpret_cast<class Derived *>(v));
}

File2.cpp:

#include "File2.h"
#include "File1.h"
#include <iostream>
 
class Base2 {
protected:
  short var2;
public:
  Base2() : var2(12) {}
};
 
class Derived : public Base2, public Base {
  float var_derived;
public:
    Derived() : Base2(), Base(), var_derived(1.2f) {}
    void do_something()
    {
        std::cout << "var_derived: "
                  << var_derived << ", var : " << var
                  << ", var2: " << var2 << std::endl;
    }
 };
 
void funcprint(Derived *d) {
  d->do_something();
}
 
Base *get_derived() {
  return new Derived;
}

В этом примере, определении класса Derived не отображается в File1.cpp когда Base* указатель на удрученный к Derived* указатель.

В File2.cpp, класс Derived выводит из двух классов, Base и Base2. Эта информация о множественном наследовании не доступна при downcasting в File1.cpp. Результат downcasting передается функциональному funcprint и разыменованный в теле funcprint. Поскольку downcasting был сделан с неполной информацией, разыменовывание может быть недопустимым.

Одна возможная коррекция должна задать класс Derived прежде downcasting Base* указатель на Derived* указатель.

В этом откорректированном примере downcasting сделан в File2.cpp в теле funcprint в точке, где определение класса Derived отображается. downcasting не сделан в File1.cpp где определение Derived не отображается. Изменения из предыдущего неправильного примера подсвечены.

File1.h:

class Base {
protected:
  double var;
public:
  Base() : var(1.0) {}
  virtual void do_something();
  virtual ~Base();
};

File2.h:

void funcprint(class Base *);
class Base *get_derived(); 

File1.cpp:

#include "File1.h"
#include "File2.h"
 
void getandprint() {
  Base *v = get_derived();
  funcprint(v);
}

File2.cpp:

#include "File2_corr.h"
#include "File1_corr.h"
#include <iostream>
 
class Base2 {
protected:
  short var2;
public:
  Base2() : var2(12) {}
};
 
class Derived : public Base2, public Base {
  float var_derived;

public:
    Derived() : Base2(), Base(), var_derived(1.2f) {}
    void do_something()
    {
        std::cout << "var_derived: "
                  << var_derived << ", var : " << var
                  << ", var2: " << var2 << std::endl;
    }
};
 
void funcprint(Base *d) {
  Derived *temp = dynamic_cast<Derived*>(d);
  if(temp)  {
     d->do_something();
  }
  else {
      //Handle error
  }
}
 
Base *get_derived() {
  return new Derived;
}