Placement-new vs gcc 4.4.3 streng-Aliasing Regeln

Question

Ich habe einige Codes, die ich schon seit einigen Jahren erfolgreich mit einem „Variante Objekt vom Typ“ umzusetzen; Das heißt, ein C ++ Objekt, das eine Werte von verschiedenen Typen enthalten kann, jedoch nur verwendet (ungefähr) so viel Speicher wie der größte der möglichen Typen. Der Code ist im Geist auf einen getaggt gewerkschafts, mit der Ausnahme, dass es nicht-POD-Datentypen als auch unterstützt. Es führt diese Magie durch einen char Puffer, Platzierung neu / löschen und reinterpret_cast <>.

ich diesen Code vor kurzem versucht, unter gcc kompilieren 4.4.3 (mit O3 und -Wall) und bekam viele Warnungen wie folgt aus:

warning: dereferencing type-punned pointer will break strict-aliasing rules

Von dem, was ich gelesen habe, ist dies ein Hinweis darauf, dass der neuen Optimierer gcc könnten ‚Buggy‘ Code generieren, die ich offensichtlich zu vermeiden möchte.

Ich habe eine ‚Spielzeug-Version‘ von meinem Code unten eingefügt; gibt es alles, was ich zu meinem Code ist es sicherer unter gcc 4.4.3, zu machen, während nach wie vor nicht-POD-Datentypen unterstützen kann? Ich weiß, dass als letztes habe ich immer den Code mit -fno-strict-aliasing kompilieren können, aber es wäre schön, Code zu haben, die nicht unter Optimierung nicht bricht, so möchte ich lieber nicht tun.

(Beachten Sie, dass ich einen Schub oder C ++ 0X Abhängigkeit in die Code-Basis vermeiden möchten, dass die Einführung, so dass während boost / C ++ 0X Lösungen interessant sind, ich etwas mehr altmodisch lieber)

#include <new>

class Duck
{
public:
   Duck() : _speed(0.0f), _quacking(false) {/* empty */}
   virtual ~Duck() {/* empty */}  // virtual only to demonstrate that this may not be a POD type

   float _speed;
   bool _quacking;
};

class Soup
{
public:
   Soup() : _size(0), _temperature(0.0f) {/* empty */}
   virtual ~Soup() {/* empty */}  // virtual only to demonstrate that this may not be a POD type

   int _size;
   float _temperature;
};

enum {
   TYPE_UNSET = 0,
   TYPE_DUCK,
   TYPE_SOUP
};

/** Tagged-union style variant class, can hold either one Duck or one Soup, but not both at once. */
class DuckOrSoup
{
public:
   DuckOrSoup() : _type(TYPE_UNSET) {/* empty*/}
   ~DuckOrSoup() {Unset();}

   void Unset() {ChangeType(TYPE_UNSET);}
   void SetValueDuck(const Duck & duck) {ChangeType(TYPE_DUCK); reinterpret_cast<Duck*>(_data)[0] = duck;}
   void SetValueSoup(const Soup & soup) {ChangeType(TYPE_SOUP); reinterpret_cast<Soup*>(_data)[0] = soup;}

private:
   void ChangeType(int newType);

   template <int S1, int S2> struct _maxx {enum {sz = (S1>S2)?S1:S2};};
   #define compile_time_max(a,b) (_maxx< (a), (b) >::sz)
   enum {STORAGE_SIZE = compile_time_max(sizeof(Duck), sizeof(Soup))};

   char _data[STORAGE_SIZE];
   int _type;   // a TYPE_* indicating what type of data we currently hold
};

void DuckOrSoup :: ChangeType(int newType)
{
   if (newType != _type)
   {
      switch(_type)
      {
         case TYPE_DUCK: (reinterpret_cast<Duck*>(_data))->~Duck(); break;
         case TYPE_SOUP: (reinterpret_cast<Soup*>(_data))->~Soup(); break;
      }
      _type = newType;
      switch(_type)
      {
         case TYPE_DUCK: (void) new (_data) Duck();  break;
         case TYPE_SOUP: (void) new (_data) Soup();  break;
      }
   }
}

int main(int argc, char ** argv)
{
   DuckOrSoup dos;
   dos.SetValueDuck(Duck());
   dos.SetValueSoup(Soup());
   return 0;
}

Answer 1

OK, Sie können es tun, wenn Sie bereit sind, eine zusätzliche void * zu speichern. Ich umformatiert Ihre Probe ein bisschen so war es einfacher für mich zu arbeiten. Schauen Sie sich diese und sehen, ob es Ihren Bedürfnissen entspricht. Auch dieser Vermerk versehen ich ein paar Proben, so dass Sie einige Vorlagen, um es diesen Willen Hilfe Usability hinzufügen können. Sie können viel mehr verlängert werden, aber das sollte Ihnen eine gute Idee geben.

Es gibt auch einige Ausgänge Zeug, um Ihnen zu sehen, was los ist.

Eine weitere Sache, ich nehme an, Sie wissen, dass Sie entsprechenden Kopie-Ctor und Zuordnung-Operator zur Verfügung stellen müssen, aber das ist nicht der Kern des Problems.

Meine g ++ Version Info:

  

g ++ --version   g ++ (SUSE Linux) 4.5.0 20100604 [gcc-4_5-Zweigrevisions 160292]

#include <new>
#include <iostream>

class Duck
{
public:
   Duck(float s = 0.0f, bool q = false) : _speed(s), _quacking(q)
  {
    std::cout << "Duck::Duck()" << std::endl;
  }
   virtual ~Duck() // virtual only to demonstrate that this may not be a POD type
   {
     std::cout << "Duck::~Duck()" << std::endl;
   }

   float _speed;
   bool _quacking;
};

class Soup
{
public:
   Soup(int s = 0, float t = 0.0f) : _size(s), _temperature(t)
  {
    std::cout << "Soup::Soup()" << std::endl;
  }
   virtual ~Soup() // virtual only to demonstrate that this may not be a POD type
   {
     std::cout << "Soup::~Soup()" << std::endl;
   }

   int _size;
   float _temperature;
};

enum TypeEnum {
   TYPE_UNSET = 0,
   TYPE_DUCK,
   TYPE_SOUP
};
template < class T > TypeEnum type_enum_for();
template < > TypeEnum type_enum_for< Duck >() { return TYPE_DUCK; }
template < > TypeEnum type_enum_for< Soup >() { return TYPE_SOUP; }

/** Tagged-union style variant class, can hold either one Duck or one Soup, but not both at once. */
class DuckOrSoup
{
public:
   DuckOrSoup() : _type(TYPE_UNSET), _data_ptr(_data) {/* empty*/}
   ~DuckOrSoup() {Unset();}

   void Unset() {ChangeType(TYPE_UNSET);}
   void SetValueDuck(const Duck & duck)
   {
     ChangeType(TYPE_DUCK);
     reinterpret_cast<Duck*>(_data_ptr)[0] = duck;
   }
   void SetValueSoup(const Soup & soup)
   {
     ChangeType(TYPE_SOUP);
     reinterpret_cast<Soup*>(_data_ptr)[0] = soup;
   }

   template < class T >
   void set(T const & t)
   {
     ChangeType(type_enum_for< T >());
     reinterpret_cast< T * >(_data_ptr)[0] = t;
   }

   template < class T >
   T & get()
   {
     ChangeType(type_enum_for< T >());
     return reinterpret_cast< T * >(_data_ptr)[0];
   }

   template < class T >
   T const & get_const()
   {
     ChangeType(type_enum_for< T >());
     return reinterpret_cast< T const * >(_data_ptr)[0];
   }

private:
   void ChangeType(int newType);

   template <int S1, int S2> struct _maxx {enum {sz = (S1>S2)?S1:S2};};
   #define compile_time_max(a,b) (_maxx< (a), (b) >::sz)
   enum {STORAGE_SIZE = compile_time_max(sizeof(Duck), sizeof(Soup))};

   char _data[STORAGE_SIZE];
   int _type;   // a TYPE_* indicating what type of data we currently hold
   void * _data_ptr;
};

void DuckOrSoup :: ChangeType(int newType)
{
   if (newType != _type)
   {
      switch(_type)
      {
         case TYPE_DUCK: (reinterpret_cast<Duck*>(_data_ptr))->~Duck(); break;
         case TYPE_SOUP: (reinterpret_cast<Soup*>(_data_ptr))->~Soup(); break;
      }
      _type = newType;
      switch(_type)
      {
         case TYPE_DUCK: (void) new (_data) Duck();  break;
         case TYPE_SOUP: (void) new (_data) Soup();  break;
      }
   }
}

int main(int argc, char ** argv)
{
   Duck sample_duck; sample_duck._speed = 23.23;
   Soup sample_soup; sample_soup._temperature = 98.6;
   std::cout << "Just saw sample constructors" << std::endl;
   {
     DuckOrSoup dos;
     std::cout << "Setting to Duck" << std::endl;
     dos.SetValueDuck(sample_duck);
     std::cout << "Setting to Soup" << std::endl;
     dos.SetValueSoup(sample_soup);
     std::cout << "Should see DuckOrSoup destruct which will dtor a Soup"
       << std::endl;
   }
   {
     std::cout << "Do it again with the templates" << std::endl;
     DuckOrSoup dos;
     std::cout << "Setting to Duck" << std::endl;
     dos.set(sample_duck);
     std::cout << "duck speed: " << dos.get_const<Duck>()._speed << std::endl;
     std::cout << "Setting to Soup" << std::endl;
     dos.set(sample_soup);
     std::cout << "soup temp: " << dos.get_const<Soup>()._temperature << std::endl;
     std::cout << "Should see DuckOrSoup destruct which will dtor a Soup"
       << std::endl;
   }
   {
     std::cout << "Do it again with only template get" << std::endl;
     DuckOrSoup dos;
     std::cout << "Setting to Duck" << std::endl;
     dos.get<Duck>() = Duck(42.42);
     std::cout << "duck speed: " << dos.get_const<Duck>()._speed << std::endl;
     std::cout << "Setting to Soup" << std::endl;
     dos.get<Soup>() = Soup(0, 32);
     std::cout << "soup temp: " << dos.get_const<Soup>()._temperature << std::endl;
     std::cout << "Should see DuckOrSoup destruct which will dtor a Soup"
       << std::endl;
   }
   std::cout << "Get ready to see sample destructors" << std::endl;
   return 0;
}

Answer 2

ich hätte den Code wie so geschrieben:

typedef boost::variant<Duck, Soup> DuckOrSoup;

, aber ich denke, jeder seinen eigenen Geschmack bekam.

Übrigens, Ihr Code Buggy ist, haben Sie nicht von möglichen Ausrichtungsprobleme gesorgt, können Sie nicht nur an einer beliebigen Stelle ein Objekt setzen im Speicher, gibt es eine Einschränkung zu beachten, die Änderung mit jeder Art. In C ++ 0x gibt es das alignof Schlüsselwort es zu bekommen, und ein paar andere Dienstprogramme ausgerichtet Lagerung zu erhalten.

Answer 3

Ich habe es geschafft, GCC (4.2.4, laufen mit -Wstrict-aliasing=2) davon zu überzeugen, nicht durch die Verwendung eines void * vorübergehend zu beschweren, das heißt.

void SetValueDuck(const Duck & duck) {ChangeType(TYPE_DUCK); void *t=&_data; reinterpret_cast<Duck*>(t)[0] = duck;}

Answer 4

Ich kann immer noch nicht verstehen, die Notwendigkeit oder Nutzung für diese aber g ++ 4.4.3 mit O3 -Wall arbeitet mit dem folgenden Patch. Wenn es funktioniert, können Sie den Anwendungsfall teilen, warum müssen Sie das?

class DuckOrSoup
{
public:
   DuckOrSoup() : _type(TYPE_UNSET) {_duck = NULL; _soup = NULL;/* empty*/}
   ~DuckOrSoup() {Unset();}

   void Unset() {ChangeType(TYPE_UNSET);}
   void SetValueDuck(const Duck & duck) {ChangeType(TYPE_DUCK); _duck = new (&_data[0])Duck (duck); }
   void SetValueSoup(const Soup & soup) { ChangeType(TYPE_SOUP); _soup = new (&_data[0])Soup (soup); }

private:
   void ChangeType(int newType);

   template <int S1, int S2> struct _maxx {enum {sz = (S1>S2)?S1:S2};};
   #define compile_time_max(a,b) (_maxx< (a), (b) >::sz)
   enum {STORAGE_SIZE = compile_time_max(sizeof(Duck), sizeof(Soup))};

   char _data[STORAGE_SIZE];
   int _type;   // a TYPE_* indicating what type of data we currently hold
   Duck* _duck;
   Soup* _soup;
};

void DuckOrSoup :: ChangeType(int newType)
{
   if (newType != _type)
   {
      switch(_type)
      {
         case TYPE_DUCK:
             _duck->~Duck();
             _duck = NULL;
             break;
         case TYPE_SOUP:
             _soup->~Soup();
             _soup = NULL;
             break;
      }
      _type = newType;
      switch(_type)
      {
         case TYPE_DUCK: _duck = new (&_data[0]) Duck();  break;
         case TYPE_SOUP: _soup = new (&_data[0]) Soup();  break;
      }
   }
}