Home / Questions / 249017
Accepted
Trauma
Asked: 2020-03-27 11:22:15 +0800 CST 2020-03-27 11:22:15 +0800 CST

VPTR initialization without invoking the constructor

  • 772

For certain reasons, I need to call placement new on an already correctly created instance , but with its VPTRincorrect . I have obtained it from a file, from a socket , ... the method does not matter.

It's a class with member-functions virtual, so I need to call the constructor to properly initialize the VPTR.

However, the constructor initializes all member-variables. If it was primitive data , I wouldn't have a problem. But they are not . Some of the member-variables have their own constructor.

Thinking about it, I found a solution... Call the copy constructor on the instance itself!

#include <iostream>

struct Dato {
  int x = 0,
      y = 0;
};

struct Padre {
  Dato datos;

  virtual ~Padre( ) {
  }
};

struct Hija : public Padre {
};

int main( ) {
  Hija h;

  h.datos.x = 10;
  h.datos.y = 20;

  Hija *ptr = new ( &h ) Hija( h );

  std::cout << "x: " << ptr->datos.x << ", y: " << ptr->datos.y << '\n';

  return 0;
}

The example is available at Wandbox.

The result obtained is the one sought:

x: 10, y: 20

The questions:

  1. How portable is this?

  2. I understand that a recursive call is made to the various constructors involved. Is there another method that gives the same result (initialize the VPTR without overwriting the rest of the memory), bypassing those calls?

c++

2 Answers

  1. I am convinced that your proposal results in undefined behavior and, consequently, it would not be portable. I have searched for the relevant quotes from standard 1 to validate my argument (translation and highlighting mine).

    3.8 Life cycle of objects.

    The life of a type object Tends when:

    —(1.3) If Tit is an object with a non-trivial destructor. EITHER

    —(1.4) The space that the object occupies is reused or freed .

    1. A program can end the life of an object by reusing the space that object occupies or by explicitly calling an object's destructor with a non-trivial destructor. For objects whose type has a nontrivial destructor , the program is not required to call the destructor explicitly before the space the object occupies is reused or freed; however, if there is no explicit call to the destructor or if a delete-expression is not used to free the space, the destructor must not be called implicitly and any program that depends on side effects caused by the destructor will have undefined behavior .

    Regarding the lifecycle, nothing happens if you overwrite an existing object with another, as long as the object has a trivial destructor; otherwise the behavior is undefined. Is it your case?

    12.4 Destroyers

    A destructor is trivial if it is not provided by the user and if:

    —(5.4) the destructor is not virtual ,

    —(5.5) all direct base classes of this class have trivial destructors , and

    —(5.6) for all non-static data members of the class that are of type object (or array), each of them has a trivial destructor.

    Otherwise, the destructor is not trivial.

    So in your case, you are forcing undefined behavior since:

    1. You end the life cycle of an object, by reusing its space:

      Hija h; // Inicio del ciclo de vida de h.

h.datos.x = 10;
h.datos.y = 20;

Hija *ptr = new ( &h ) Hija( h ); // Reutilizamos el espacio de h, fin de su vida.

    2. The destructor of Hijais non-trivial since its direct base class lacks a trivial destructor because in addition to being a virtual destructor, it is provided by the user.

      struct Padre {
  Dato datos;

  virtual ~Padre( ) { // Destructor no trivial
  }
};

struct Hija : public Padre { // Hereda de Padre
};

    By engaging in undefined behavior, the code might be portable, it might not be portable, it might be both, and it might be neither.

    1. isocpp.org has stopped sharing drafts of the C++ standard for free, the linked document is a 2014 draft standard.
    • 3
  2. Best Answer

    How portable is this?

    If you have retrieved an object but the virtual information is incorrect, I understand that a raw binary dump of the object's memory has been made and therefore what you have is basically garbage.

    Why?

    The first reason is that if the memory of an object is flushed, if it makes use of dynamic memory (it does not matter if it is the object directly or an internal object of the object), it is quite likely that this memory is not being used. dumping which will cause a malfunction of the program.

    On the other hand, virtuality management is left to compilers so the source code of a class can generate two incompatible binaries when using different compilers.

    Imagine the following scenario:

    • Compiler A: Stores all information regarding virtuality in a single region of memory. Access to that memory is done with a pointer that the compiler inserts at the start of the object.

    • Compiler B: Generates a table of virtual functions and, additionally, manages a parallel table with relevant information for type conversions ( dynamic_cast). That's two pointers that are inserted at the start of the object.

    In these contexts the data referring to the state of the object is not aligned in any way and any attempt to force the virtuality information to be restored will not succeed in fixing the state of the object.

    And we must not lose sight of the fact that binary information is sensitive to the architecture of the equipment: big-endian vs. little-endian. Incompatible architectures versus binary data.

    I understand that a recursive call is made to the various constructors involved. Is there another method that gives the same result, bypassing those calls?

    The best solution is to serialize the state of the object and send and store only that state. Binary storage of an object can only give you problems as soon as multiple computers with different hardware/software are involved.

    I am aware that serializing objects is more work, but no one said that programming was going to be easy and beautiful... well, okay, yes, it's something that sells... but it's a lie!!!

    • 2