C ++, declaración de variable en la expresión 'if'

¿Que está pasando aqui?

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 sección 6.4.3 de la norma de 2003 explica cómo las variables declaradas en una condición de declaración de selección tienen un alcance que se extiende hasta el final de las subdestaciones controladas por la condición. Pero no veo dónde dice nada sobre no poder poner paréntesis alrededor de la declaración, ni dice nada sobre una sola declaración por condición.

Esta limitación es molesta incluso en los casos en los que solo se requiere una declaración en la condición. Considera esto.

bool a = false, b = true;

if(bool x = a || b)
{

}

Si quiero ingresar el alcance 'if' -body con x establecido en falso, entonces la declaración necesita paréntesis (ya que el operador de asignación tiene menor precedencia que el OR lógico), pero dado que no se puede usar el paréntesis, requiere la declaración de x fuera el cuerpo, filtrando esa declaración a un alcance mayor del deseado. Obviamente, este ejemplo es trivial, pero un caso más realista sería aquel en el que a y b son funciones que devuelven valores que deben probarse

Entonces, ¿lo que quiero hacer es no conforme con el estándar, o mi compilador simplemente me está rompiendo las bolas (VS2008)?

A partir de C ++ 17, lo que estaba intentando hacer finalmente es posible :

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

Tenga en cuenta el uso de ;en lugar de ,para separar la declaración y la condición real.

Creo que ya insinuó el tema. ¿Qué debería hacer el compilador con este código?

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

El operador "&&" es un Y lógico de cortocircuito. Eso significa que si la primera parte (1==0)resulta ser falsa, entonces la segunda parte (bool a = false)no debe evaluarse porque ya se sabe que la respuesta final será falsa. Si (bool a = false)no se evalúa, ¿qué hacer más adelante con el código que se usa a? ¿No inicializaríamos la variable y la dejaríamos sin definir? ¿Lo inicializaríamos con el valor predeterminado? ¿Qué pasa si el tipo de datos es una clase y hacer esto tiene efectos secundarios indeseables? ¿Qué pasa si en lugar de boolusar una clase y no tiene un constructor predeterminado de modo que el usuario debe proporcionar parámetros? ¿Qué hacemos entonces?

Aquí hay otro ejemplo:

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?

Parece que la limitación que ha encontrado parece perfectamente razonable: evita que sucedan este tipo de ambigüedades.

La condición en una declaración ifo whilepuede ser una expresión o una declaración de variable única (con inicialización).

Su segundo y tercer ejemplo no son expresiones válidas ni declaraciones válidas, ya que una declaración no puede formar parte de una expresión. Si bien sería útil poder escribir código como su tercer ejemplo, requeriría un cambio significativo en la sintaxis del lenguaje.

No veo dónde dice nada sobre no poder poner paréntesis alrededor de la declaración, ni dice nada sobre solo una declaración por condición.

La especificación de sintaxis en 6.4 / 1 da lo siguiente para la condición:

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

especificando una sola declaración, sin paréntesis ni otros adornos.

Si desea incluir variables en un ámbito más estrecho, siempre puede utilizar adicionales { }

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

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

La última sección ya funciona, solo tienes que escribirla ligeramente diferente:

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

Aquí hay una solución fea usando un bucle (si ambas variables son enteros):

#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;
}

Pero esto confundirá a otros programadores y es un código bastante malo, por lo que no se recomienda.

Un {}bloque envolvente simple (como ya se recomendó) es mucho más fácil de leer:

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

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

Una cosa a tener en cuenta, también es que las expresiones dentro del bloque if más grande

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

no están necesariamente garantizados para ser evaluados de izquierda a derecha. Un error bastante sutil que tuve en su día tenía que ver con el hecho de que el compilador en realidad estaba probando de derecha a izquierda en lugar de de izquierda a derecha.

Con un poco de magia de plantilla, puede evitar el problema de no poder declarar múltiples 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;
}

(Tenga en cuenta que esto pierde la evaluación de cortocircuito).