C++11 initialiseur de membre de la liste de vs dans-classe d'initialiseur?

Non, ce sont des pas la même.

La différence entre eux est la même qui s'applique pour direct-initialisation vs copier-initialisation, ce qui est subtil, mais souvent très déroutant.

§12.6.2 [classe.de la base.init]:

1. La expression-liste ou moisa-init-liste dans un mem-initialiseur est utilisé pour initialiser la désignées sous-objet (ou, dans le cas de la délégation constructeur, l'ensemble de la classe object) selon les règles d'initialisation de 8,5 pour direct-initialisation. [...]

2. Dans un non-la délégation de constructeur, si un non-membre de données statiques ou de la classe de base n'est pas désigné par un mem-initialiseur-id (y compris dans le cas où il n'y a pas de mem-initialiseur-liste parce que le constructeur n'a pas ctor-initialiseur) et l'entité n'est pas une classe de base virtuelle d'une classe abstraite (10.4), puis

   — si l'entité est un non-membre de données statiques qui a un corset ou égal initialiseur, l'entité est initialisé comme spécifié dans les 8.5;

§8.5 [dcl.init]:

1. L'initialisation qui se produit dans la forme

   T x = a;

ainsi que dans l'argument de passage, de retour de la fonction, la levée d'une exception (15.1), de la gestion d'une exception (15.3), et d'agrégation de l'initialisation de membre (8.5.1) est appelé la copie d'initialisation.

De l'initialisation d'un non-membre de données statiques sur un membres de l'initialiseur-liste suit les règles de direct-initialisation, qui ne crée pas d'intermédiaire temporaires qui doivent être déplacés ou copiés (si compilé sans copier-élision), ni le type de la donnée membre doit être copiable/mobile (même si la copie est élidée). En outre, un direct-initialisation introduit un contexte explicite, tandis qu'un copier-initialisation est non-explicite (si un constructeur sélectionné pour l'initialisation est explicit, le programme ne compile pas).

En d'autres termes, la obj s = obj("value"); syntaxe ne compile pas si obj est déclarée comme suit:

struct obj
{
    obj(std::string) {}
    obj(const obj&) = delete;
};

ou:

struct obj
{
    obj(std::string) {}
    explicit obj(const obj&) {}
};

Comme un exemple concret, tandis que le dessous ne compile pas:

struct any
{
   std::atomic<int> a = std::atomic<int>(1); //ill-formed: non-copyable/non-movable
   std::atomic<int> b = 2; //ill-formed: explicit constructor selected
};

ce sera:

struct any
{
    std::atomic<int> a;
    std::atomic<int> b{ 2 };
    any() : a(1) {}
};

---

Qui est meilleure (performance) ?

Avec un copier-élision activé les deux ont des performances identiques. Avec copier-élision désactivé, il est une copie supplémentaire/constructeur de déplacement appeler chaque instanciation lorsque le copier-initialisation syntaxe est utilisée (que obj s = obj("value"); est l'une des).

---

Est-il une autre voie ?

La corset ou égal initialiseur syntaxe permet d'effectuer une direct de la liste d'initialisation ainsi:

class any {
public:
    obj s{ "value" };
    any() {}
};

---

Existe-il d'autres différences?

Quelques autres différences qui méritent d'être mentionnées sont:

1. Corset ou égal initialiseur doit résider dans un fichier d'en-tête avec une déclaration de classe.
2. Si les deux sont combinés, membres de l'initialiseur-liste prend la priorité sur corset ou égal initialiseur (qui est, corset ou égal initialiseur est ignoré).
3. (C++11) jusqu'à C++14) Une classe qui utilise corset ou égal initialiseur viole les contraintes pour un type de regroupement.
4. Avec le corset ou égal initialiseur syntaxe qu'il n'est pas possible d'effectuer une direct-initialisation autre qu'un direct de la liste d'initialisation.

Ils sont les mêmes.

N'est ni mieux que les autres en termes de performances, et il n'y a pas d'autre façon d'initialiser eux.

Au profit de la classe d'initialisation (le premier dans votre exemple), c'est que l'ordre d'initialisation est implicite. Dans initialiser la liste, vous devez explicitement état de la commande et les compilateurs pour les avertir de l'ordre d'initialisation si vous obtenez la commande incorrecte.

De la norme:

12.6.2.5
nonstatic data members shall be initialized in the order they were declared 
in the class definition

Si vous prenez la commande de mal dans votre liste, GCC va se plaindre:

main.cpp: In constructor 'C::C()':
main.cpp:51:9: warning: 'C::b' will be initialized after
main.cpp:51:6: warning:   'int C::a'

L'avantage d'initialiser les listes est peut-être une question de goût, et la liste est explicite, généralement dans le fichier source. Dans la classe est implicite (sans aucun doute), et se trouve généralement dans le fichier d'en-tête.