C ++, déclaration de variable dans l'expression 'if'

Que se passe t-il ici?

if(int a = Func1())
{
    // Works.
}

if((int a = Func1()))
{
    // Fails to compile.
}

if((int a = Func1())
    && (int b = Func2()))
)
{
    // Do stuff with a and b.
    // This is what I'd really like to be able to do.
}

La section 6.4.3 de la norme 2003 explique comment les variables déclarées dans une condition d'énoncé de sélection ont une portée qui s'étend jusqu'à la fin des sous-instructions contrôlées par la condition. Mais je ne vois pas où cela dit quoi que ce soit sur le fait de ne pas pouvoir mettre de parenthèses autour de la déclaration, ni sur une seule déclaration par condition.

Cette limitation est ennuyeuse même dans les cas où une seule déclaration dans la condition est requise. Considère ceci.

bool a = false, b = true;

if(bool x = a || b)
{

}

Si je veux entrer la portée 'if' -body avec x défini sur false, la déclaration a besoin de parenthèses (puisque l'opérateur d'affectation a une priorité inférieure à l'OR logique), mais comme la parenthèse ne peut pas être utilisée, elle nécessite la déclaration de x à l'extérieur le corps, la fuite de cette déclaration à une portée plus grande que ce qui est souhaité. Évidemment, cet exemple est trivial mais un cas plus réaliste serait celui où a et b sont des fonctions renvoyant des valeurs qui doivent être testées

Est-ce que ce que je veux faire est non conforme à la norme, ou est-ce que mon compilateur ne fait que me casser les couilles (VS2008)?

Depuis C ++ 17, ce que vous essayez de faire est enfin possible :

if (int a = Func1(), b = Func2(); a && b)
{
    // Do stuff with a and b.
}

Notez l'utilisation de ;au lieu de ,pour séparer la déclaration et la condition réelle.

Je pense que vous avez déjà fait allusion à la question. Que doit faire le compilateur avec ce code?

if (!((1 == 0) && (bool a = false))) {
    // what is "a" initialized to?

L'opérateur "&&" est un ET logique de court-circuit. Cela signifie que si la première partie (1==0)s'avère fausse, la deuxième partie (bool a = false)ne doit pas être évaluée car on sait déjà que la réponse finale sera fausse. Si ce (bool a = false)n'est pas évalué, que faire plus tard avec le code qui utilise a? Ne devrions-nous tout simplement pas initialiser la variable et la laisser non définie? Pourrions-nous l'initialiser à la valeur par défaut? Et si le type de données était une classe et que cela avait des effets secondaires indésirables? Et si au lieu de boolvous utilisiez une classe et qu'elle n'avait pas de constructeur par défaut tel que l'utilisateur doit fournir des paramètres - que faisons-nous alors?

Voici un autre exemple:

class Test {
public:
    // note that no default constructor is provided and user MUST
    // provide some value for parameter "p"
    Test(int p);
}

if (!((1 == 0) && (Test a = Test(5)))) {
    // now what do we do?!  what is "a" set to?

Il semble que la limitation que vous avez trouvée semble parfaitement raisonnable - elle empêche ce genre d'ambiguïtés de se produire.

La condition dans une instruction ifor whilepeut être soit une expression , soit une déclaration de variable unique (avec initialisation).

Vos deuxième et troisième exemples ne sont ni des expressions valides, ni des déclarations valides, car une déclaration ne peut pas faire partie d'une expression. S'il serait utile de pouvoir écrire du code comme votre troisième exemple, cela nécessiterait une modification significative de la syntaxe du langage.

Je ne vois pas où cela dit quoi que ce soit sur l'impossibilité de mettre entre parenthèses la déclaration, ni sur une seule déclaration par condition.

La spécification de syntaxe en 6.4 / 1 donne ce qui suit pour la condition:

condition:
    expression
    type-specifier-seq declarator = assignment-expression

spécifiant une seule déclaration, sans parenthèses ni autres ornements.

Si vous souhaitez inclure des variables dans une portée plus étroite, vous pouvez toujours utiliser des { }

//just use { and }
{
    bool a = false, b = true;

    if(bool x = a || b)
    {
        //...
    }
}//a and b are out of scope

La dernière section fonctionne déjà, il vous suffit de l'écrire légèrement différemment:

if (int a = Func1())
{
   if (int b = Func2())
   {
        // do stuff with a and b
   }
}

Voici une solution de contournement laide utilisant une boucle (si les deux variables sont des entiers):

#include <iostream>

int func1()
{
    return 4;
}

int func2()
{
    return 23;
}

int main()
{
    for (int a = func1(), b = func2(), i = 0;
        i == 0 && a && b; i++)
    {
        std::cout << "a = " << a << std::endl;
        std::cout << "b = " << b << std::endl;
    }

    return 0;
}

Mais cela déroutera les autres programmeurs et c'est un code plutôt mauvais, donc déconseillé.

Un simple {}bloc englobant (comme déjà recommandé) est beaucoup plus facile à lire:

{
    int a = func1();
    int b = func2();

    if (a && b)
    {
        std::cout << "a = " << a << std::endl;
        std::cout << "b = " << b << std::endl;
    }
}

Une chose à noter est également que les expressions à l'intérieur du plus grand bloc if

if (!((1 == 0) && (bool a = false)))

ne sont pas nécessairement garantis d'être évalués de gauche à droite. Un bogue assez subtil que j'ai eu à l'époque était lié au fait que le compilateur testait en fait de droite à gauche au lieu de gauche à droite.

Avec un peu de magie de modèle, vous pouvez en quelque sorte contourner le problème de ne pas pouvoir déclarer plusieurs variables:

#include <stdio.h>

template <class LHS, class RHS>
struct And_t {
  LHS lhs;
  RHS rhs;

  operator bool () {
    bool b_lhs(lhs);
    bool b_rhs(rhs);
    return b_lhs && b_rhs;
  }
};
template <class LHS, class RHS> 
And_t<LHS, RHS> And(const LHS& lhs, const RHS& rhs) { return {lhs, rhs}; }

template <class LHS, class RHS>
struct Or_t {
LHS lhs;
RHS rhs;

  operator bool () {
    bool b_lhs(lhs);
    bool b_rhs(rhs);
    return b_lhs || b_rhs;
  }
};
template <class LHS, class RHS> 
Or_t<LHS, RHS> Or(const LHS& lhs, const RHS& rhs) { return {lhs, rhs}; }

int main() {
  if (auto i = And(1, Or(0, 3))) {
    printf("%d %d %d\n", i.lhs, i.rhs.lhs, i.rhs.rhs);
  }
  return 0;
}

(Notez que cela perd l'évaluation du court-circuit.)