Nouvelle norme du C++

C++0x est la nouvelle norme prévue pour le langage C++ en informatique. Elle a pour but de remplacer la norme existante, ISO/IEC 14882, publiée en 1998 et mise à jour en 2003. Ces dernières sont plus connues sous le nom informel de C++98 et C++03. La nouvelle norme introduira plusieurs nouveautés au langage initial, ainsi que de nouvelles fonctionnalités à la bibliothèque standard du C++ comme la plupart des bibliothèques du "Technical Report 1", à l'exception de la bibliothèque de fonctions mathématiques spéciales. Cette norme n'étant pas à l'heure actuelle finalisée, cet article pourrait ne pas refléter l'état d'avancement courant de C++0x, qui est publié sur le site de comité de la norme ISO C++.Le rapport le plus récent, N2432, a été publié en Octobre 2007.

Le comité de normalisation ISO/CEI JTC1/SC22/WG21 du C++ a pour but de présenter la nouvelle norme en 2009 (par conséquent la norme appellée actuellement C++0x s'appellera C++09), ce qui signifie que le document doit être prêt pour ratification par les membres de l'ISO en 2008. Pour pouvoir finir en temps et en heures, le comité a décidé de concentrer ses efforts sur les solutions apportés jusqu'a 2006 et d'ignorer toutes les nouvelles propositions.

Un langage de programmation comme le C++ suit une évolution qui permettra aux programmeurs de coder plus rapidement, de façon plus élégante et permettant de faire du code maintenable. Ce processus soulève inévitablement des questions de compatibilité avec le code existant, ce qui s'est produit de temps en temps pendant le processus de développement du C++. Cependant, d'après l'annonce faite par Bjarne Stroustrup (l'inventeur du langage C++ et membre du comité), la nouvelle norme sera presque compatible à 100% avec la norme actuelle.

Classes are an important feature of C++. The C++0x changes to class features focus on making class hierarchies easier to work with and less fragile.


[edit] Constructor delegation
In standard C++, constructors are not allowed to call other constructors - each constructor must construct all of its class members itself, which often results in duplicate initialization code.

C++0x will allow constructors to call other peer constructors (known as delegation). This will allow constructors to utilize another constructor's behavior with a minimum of added code. Other languages, such as Java, provide this.

The syntax will be:

class SomeType
{
int number;

public:
SomeType(int newNumber) : number(newNumber) {}
SomeType() : SomeType(42) {}
};
This comes with a caveat: C++03 considers an object to be constructed when its constructor finishes executing, but C++0x will consider an object constructed once any constructor finishes execution. Since multiple constructors will be allowed to execute, this will mean that each delegate constructor will be executing on a fully-constructed object of its own type. Derived class constructors will execute after all delegation in their base classes is complete.


[edit] Constructor inheritance
In standard C++, when a derived class is created from a base class, the derived class has an entirely separate set of constructors. The derived class may call base class constructors and forward parameters to them, but the user must create each constructor separately. Since this is merely rote work, it can be prone to causing user error.

C++0x will allow a class to specify that constructors will be forwarded. This means that the C++0x compiler will generate code to perform the forwarding of the call. Note that this is an all-or-nothing feature; either all of that base class's constructors are forwarded or none of them are. Also, note that there are restrictions for multiple inheritance, such that you cannot forward from two classes that use constructors with the same signature. Nor can you later declare a constructor with a signature that matches a forwarded constructor.

The syntax will be as follows:

class BaseClass
{
public:
BaseClass(int iValue);
};

class DerivedClass : public BaseClass
{
public:
using default BaseClass;
};

[edit] Member initializers
In standard C++, members of classes are initialized only in constructors. C++0x will allow the following syntax for initializing members:

class SomeClass
{
private:
int iValue = 5;
};
Any constructor will initialize iValue with 5 if the constructor does not override the initialization with its own, as follows:

class SomeClass
{
public:
SomeClass() {}
explicit SomeClass(int iNewValue) : iValue(iNewValue) {}

private:
int iValue = 5;
};
The empty constructor will initialize iValue as the class states, but the constructor that takes an int will initialize it to the given parameter.


[edit] Allow 'sizeof' to work on members of classes without an explicit object
In standard C++, the sizeof operation can be used on types and objects. But it cannot be used to do the following:

struct SomeType { OtherType member; };

sizeof(SomeType::member); //Does not work.
This should return the size of OtherType. C++03 does not allow this, so it is a compile error. C++0x will allow it.


[edit] Defaulting/deleting of standard functions on C++ objects
In standard C++, the compiler will provide, for objects that do not provide for themselves, a default constructor, a copy constructor, a copy assignment operator operator=, and a destructor. As mentioned, the user can override these defaults by defining their own version. C++ also defines several global operators (such as operator=, and operator new) that work on all classes, which the user can override.

The problem is that there are very few controls over the creation of these defaults. Making a class inherently non-copyable, for example, requires declaring a private copy constructor and copy assignment operator and not defining them. Attempting to use these functions will cause a compiler or linker error. However, this is not an ideal solution.

Further, in the case of the default constructor, it is useful to want to explicitly tell the compiler to generate it. The compiler will not generate a default constructor if the object is defined with any constructors. This is useful in many cases, but it is also useful to be able to have both a specialized constructor and the compiler-generated default.

C++0x will allow the explicit use, or disuse, of these standard object functions. For example, the following type explicitly declares that it is using the default constructor:

struct SomeType
{
SomeType() = default; //The default constructor is explicitly stated.
SomeType(OtherType value);
};
Alternatively, certain features can be explicitly disabled. For example, the following type is non-copyable:

struct NonCopyable
{
NonCopyable & operator=(const NonCopyable&) = delete;
NonCopyable(const NonCopyable&) = delete;
NonCopyable() = default;
};
A type can be made impossible to allocate with operator new:

struct NonNewable
{
void *operator new(std::size_t) = delete;
};
This object can only ever be allocated as a stack object or as a member of another type. It cannot be directly heap allocated without non-portable trickery. (Since placement new is the only way to call a constructor on user-allocated memory and this use has been forbidden as above, the object cannot be properly constructed.)

The = delete specifier can be used to prohibit calling any function, which can be used to disallow calling a member function with particular parameters. For example:

struct NoDouble
{
void f(int i);
void f(double) = delete;
};
An attempt to call f() with a double will be rejected by the compiler, instead of performing a silent conversion to int. This can be generalised to disallow calling the function with any type other than int as follows:

struct NoDouble
{
void f(int i);
template<class T> void f(T) = delete;
};

[edit] Explicit conversion operators
Standard C++ added the explicit keyword as a modifier on constructors to prevent single-argument constructors to be used as implicit type conversion operators. However, this does nothing for actual conversion operators. For example, a smart pointer class may have an operator bool() to allow it to act more like a primitive pointer: if it includes this conversion, it can be tested with if(smart_ptr_variable) (which would be true if the pointer was non-null and false otherwise). However, this allows other, unintended conversions as well. Because C++ bool is defined as an arithmetic type, it can be implicitly converted to integral or even floating-point types, which allows for mathematical operations that are not intended by the user.

In C++0x, the explicit keyword can now be applied to conversion operators. As with constructors, they prevent further implicit conversion.


[edit] Modification to the definition of plain old data
In standard C++, a struct must follow a number of rules in order for it to be considered a plain old data (POD) type. There are good reasons for wanting a number of types to fit this definition, as doing so causes implementations to produce object layouts that are compatible with C, as well as using initializer lists. However, the list of rules in C++03 is very strict, moreso than is necessary to gain the benefits of POD types.

C++0x will relax several rules with regard to the POD definition.

A class/struct is considered a POD if it is trivial, standard-layout, and it has no non-static members that are not PODs. A trivial class or struct is defined as one that:

Has a trivial default constructor. This may use the aforementioned default constructor syntax (SomeConstructor() = default;).
Has a trivial copy constructor, which may use the default syntax.
Has a trivial copy assignment operator, which may use the default syntax.
Has a trivial destructor, which may not be virtual.
A standard-layout class or struct is defined as one that:

Has only non-static data members that are of standard-layout type
Has the same access control (public, private, protected) for all non-static members
Has no virtual functions
Has no virtual base classes
Has only base classes that are of standard-layout type
Has no bases classes of the same type as the first defined non-static member
Either has no base classes with non-static members, or has no non-static data members in the most derived class and at most one base class with non-static members. In essence, there may be only one class in this classes hierarchy that has non-static members.

class SomeType
{
  int number;
 
public:
  SomeType(int newNumber) : number(newNumber) {}
  SomeType() : SomeType(42) {}
};

template <class... Types> class tuple;
Un exemple de définition et d'utilisation du type tuple :

typedef tuple< int, double, long &, const char * > test_tuple ;
long lengthy = 12 ;
test_tuple proof( 18, 6.5, lengthy, "Ciao!" ) ;
lengthy = get<0>(proof) ;  // Assigne à 'lengthy' la valeur 18.
get<3>(proof) = " Beautiful!" ;  // Modifie la 4ème valeur du tuple

typedef tuple< int , double, string       > tuple_1 t1 ;
typedef tuple< char, short , const char * > tuple_2 t2( 'X', 2, "Hola!" ) ;
t1 = t2 ;  // Ok, les deux premiers élément peuvent être convertis
           // Le troisième peut être construit à partir du 'const char *'.

tuple_size<T>::value retourne le nombre d'éléments du tuple T, 
tuple_element<I, T>::type retourne le type de l'objet placé en position I du tuple T. 

par contre wxWidgets