Améliorations des performances C++0x

Oui, C++ résout le problème grâce à quelque chose appelé déplacer la sémantique .

Fondamentalement, cela permet à un objet de prendre la représentation interne d'un autre objet si cet objet est temporaire. Au lieu de copier chaque octet de la chaîne via un constructeur de copie, par exemple, vous pouvez souvent simplement autoriser la chaîne de destination à prendre la représentation interne de la chaîne source. Ceci n'est autorisé que lorsque la source est une valeur r.

Cela se fait grâce à l'introduction d'un constructeur de mouvement . C'est un constructeur où vous savez que l'objet src est temporaire et va disparaître. Par conséquent, il est acceptable que la destination adopte la représentation interne de l'objet src.

Il en va de même pour les opérateurs d'affectation de déplacement .

Pour distinguer un constructeur de copie d'un constructeur de déplacement, le langage a introduit des références rvalue . Une classe définit son constructeur de déplacement pour prendre une référence rvalue qui ne sera lié qu'aux rvalues ​​(temporaires). Ainsi, ma classe définirait quelque chose dans le sens :

 class CMyString
 {
 private:
     char* rawStr;
 public:

     // move constructor bound to rvalues
     CMyString(CMyString&& srcStr) 
     {
         rawStr = srcStr.rawStr
         srcStr.rawStr = NULL;             
     }

     // move assignment operator 
     CMyString& operator=(CMyString&& srcStr) 
     {
         if(rawStr != srcStr.rawStr) // protect against self assignment
         {
             delete[] rawStr;
             rawStr = srcStr.rawStr
             srcStr.rawStr = NULL;
         }
         return *this;
     }

     ~CMyString()
     {
         delete [] rawStr;
     }
 }

Voici un très bon article détaillé sur la sémantique des déplacements et la syntaxe qui permet de le faire.

Une amélioration des performances sera les expressions constantes généralisées, qui sont introduites par le mot-clé constexpr.

constexpr int returnSomething() {return 40;}

int avalue[returnSomething() + 2]; 

Ce n'est pas du code C++ légal, car returnSomething()+2 n'est pas une expression constante.

Mais en utilisant le mot-clé constexpr, C++0x peut indiquer au compilateur que l'expression est une constante de compilation.