Comment mettre en œuvre constructeur de copie en toute sécurité pour la classe qui a le placement interne nouveau (avec std :: string)

Question

Voici mon code:

struct RS_Token 
{ 
    char id; 
    char cleanup; 
    unsigned char array[sizeof (std::string) > sizeof (double) ? sizeof (std::string) : sizeof (double)]; 

    RS_Token(int a) : 
     id(a), 
     cleanup(0) 
    { 
    } 
    RS_Token(int a, const char* pstr) : // identifier or text 
     id(a), 
     cleanup(1) 
    { 
     new (array) std::basic_string<unsigned char>((unsigned char*)pstr); 
    } 
    RS_Token(int a, int b) : // integer 
     id(a), 
     cleanup(0) 
    { 
     new (array) int(b); 
    } 
    RS_Token(int a, double b) : // float (double) 
     id(a), 
     cleanup(0) 
    { 
     new (array) double(b); 
    } 

    ~RS_Token() 
    { 
     if (cleanup) 
     { 
      std::basic_string<unsigned char>* p = reinterpret_cast<std::basic_string<unsigned char>*>(array); 

      p->~basic_string(); 
     } 
    } 
}; 

Toutes les suggestions sur la façon d'ajouter un constructeur de copie qui gère correctement le cas où un std :: string a été attribué en interne, serait apprécié.

Answer 1

Je ne suis pas sûr que ce que vous faites est du tout une bonne conception, mais pour répondre à votre question de placement nouvelle sur: Vous fournissez les arguments du constructeur comme dans toute autre expression new:

construire une nouvelle chaîne:

typedef std::basic_string<unsigned char> ustring; 

RS_Token(const char* pstr) 
{ 
    void * p = static_cast<void*>(array); 
    new (p) ustring(pstr, pstr + std::strlen(pstr)); 
} 

Copy-construction:

RS_Token(const RS_Token & other) 
{ 
    void * p = static_cast<void*>(array); 
    new (p) ustring(*reinterpret_cast<const ustring *>(other.array)); 
} 

Assign:

RS_Token & operator=(const RS_Token & other) 
{ 
    ustring & s = *reinterpret_cast<ustring *>(array); 
    s = *reinterpret_cast<const ustring *>(other.array); 
    return this; 
}