Constructeur

Bonjour , Merci pour l’éclaircissement et tes remarques assez intéressantes. Mais justement là où c'est confus c'est comme tu le dis on peut vérifié la validité après donc j'entends par là le faire de cette manière

Armoire(int l=1,int h=1):largeur(l),hauteur(h){
while(largeur<1 || hauteur<1){
cout << "Dimension incorrecte ( dim < 1)" << endl;
cout << "Largeur ? ";
cin >> largeur;
cout << "hauteur ? ";
cin >> hauteur;
} 
}

Mais on est d'accord que même en supposant des valeurs incorrectes la liste d'initialisation est inutile , on aurait très bien pu sans passer ? Sachant que dans tout les cas on vérifiera les valeurs des attributs. Pour ce qui est des types complexe(objets) l'issu est assez similaire non ?

Armoire( std::string nm ) : nom(nm) {}
#include "Armoire.h"
#include <iostream>
using namespace std;
int main(){
Armoire a1 (" ") // On crée également une Armoire avec une chaîne vide 
return 0;
}

Certes , une il y'a différence considérable et non négligeable en ayant recours a la liste d'initialisation mais ce que je veux dire c'est que sa ne garanti pas toujours une intégrité sur les valeurs saisies. Désolé si je suis borné mais sa m’intéresse vraiment de pouvoir peser le pour et le contre concernant certaines subtilité en programmation. Merci d'avance !

Ton premier exemple est non naturel. On suppose qu'en entrée on a des valeurs et que le constructeur peut en changer spontanément. Il est plus sain d'avoir : soit le constructeur gère en interne ses valeurs initiales, soit elles sont fournies et il pourra les accepter ou les refuser.

On est d'accord, dans le cas de variables simple on peut se passer de la liste d'initialisation.

Pour les types complexes, non on ne peut pas s'en passer pour les 2 raisons que j'ai déjà indiqué.
Et ton 2nd exemple, on a les deux possibilités :

Armoire( std::string nm ) : nom(nm) {
   if ( nom == "toto") throw "erreur la chaîne \"toto\" n'est pas autorisée";
}
Armoire( std::string nm ) {
   if ( nm == "toto") throw "erreur la chaîne \"toto\" n'est pas autorisée";
    nom = nm;  // finalement la chaîne vaut nm
}

En reprenant le code du constructeur sans liste d'initialisation, on aura 3 étapes :
- création de l'objet avec le constructeur par défaut d'une chaîne qui crée une chaîne vide (appel de

std::string::string()

)
- stopper la création si la création n'a pas de sens
- mise à jour de la chaîne en lui affectant une chaîne vide (appel de

std::string::operator=( const char *prm)

avec

prm=""

)
Avec la liste d'initialisation, il n'y a que deux étapes :
- création de l'objet avec le constructeur

std::string::string(const char*prm)

avec

prm = ""

)
- stopper la création si la création n'a pas de sens.
Mais supposer que cela se passe comme ton premier exemple où il y a des prises de décisions en amont et en interne au constructeur, c'est cela ne serait ni sain ni optimum sans liste d'initialisation.