Déclarer et initialiser une variable dans une instruction conditionnelle ou de contrôle en C++

je le considère comme un bon style lorsqu'il est utilisé avec éventuellement null pointeur:

if(CObj* p = GetOptionalValue()) {
   //Do something with p
}

de cette façon, que p soit déclaré, c'est un pointeur valide. Pas de danger d'accès au pointeur.

d'un autre côté au moins en VC++ c'est la seule utilisation supportée (c'est-à-dire vérifier si l'assignation est vraie)

j'utilise const autant que possible dans ces situations. Au lieu de votre exemple, je ferais:

const int readResult = read(socket);
if(readResult < 0) {
    // handle error
} 
else if(readResult > 0)
{
    // handle input
} 
else {
    return true;
} 

donc bien que la portée ne soit pas contenue, elle n'a pas vraiment d'importance, puisque la variable ne peut pas être modifiée.

j'ai rencontré un similaire problème :

le problème semble être les parenthèses autour de la déclaration int . Cela devrait fonctionner si vous pouvez exprimer l'affectation et le test sans eux, i.e.

if (int i = read(socket)) {

devrait fonctionner, mais cela signifie que le test est != 0 , ce qui n'est pas ce que vous voulez.

Alors que vous pouvez utiliser une déclaration comme une expression booléenne, vous ne pouvez pas placer une déclaration au moyen d'une expression. Je ne peux m'empêcher de penser que vous lisez mal ce que dit Bjarne.

la technique est utile et désirable surtout pour les variables de contrôle de pour les boucles, mais dans ce cas je crois est mal avisé et ne sert pas la clarté. Et bien sûr, cela ne fonctionne pas! ;)

if( <type> <identifier> = <initialiser> ) // valid, but not that useful IMO

if( (<type> <identifier> = <initialiser>) <operator> <operand> )  // not valid

for( <type> <identifier> = <initialiser>; 
     <expression>; 
     <expression> )  // valid and desirable

Dans votre exemple, vous avez appelé un fonction avec des effets secondaires dans un conditionnel, qui IMO est une mauvaise idée indépendamment de ce que vous pourriez penser de déclarer la variable là.

ajoute à ce que RedGlyph et Ferruccio ont dit. Peut-être pouvons-nous faire ce qui suit pour déclarer encore dans une déclaration conditionnelle pour limiter son utilisation:

if(int x = read(socket)) //x != 0
{
  if(x < 0) //handle error
  {}
  else //do work
  {}
}
else //x == 0  
{
  return true;
}

ils le réparent en c++17:

if (int i = read(socket); i < 0)

où if peut avoir une déclaration d'initialiseur.

voir http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0305r0.html

pour compléter les bonnes réponses des autres, vous pouvez toujours limiter la portée de la variable par des accolades:

{    
  const int readResult = read(socket);
  if(readResult < 0) {
    // handle error
  } 
  else if(readResult > 0)
  {
    // handle input
  } 
  else {
    return true;
  } 
}

bien qu'ils ne soient pas directement liés à la question, tous les exemples donnent la première place au traitement des erreurs. Puisqu'il y a 3 Cas (>0 -> data, ==0 -> connection closed et <0 -> error), cela signifie que le cas le plus commun d'obtenir de nouvelles données nécessite deux tests. La vérification de >0 Tout d'abord réduirait le nombre prévu d'essais de près de la moitié. Malheureusement L'approche" if(int x = read(socket)) " donnée par White_Pawn nécessite encore 2 tests pour le cas des données, mais la proposition C++17 pourrait être utilisée pour tester >0.