C++, deklaracja zmiennej w wyrażeniu "if"

Myślę, że już wspomniałeś o tym problemie. Co powinien zrobić kompilator z tym kodem?

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

Operator "&&" jest zwarciem logicznym i. Oznacza to, że jeśli pierwsza część (1==0) okaże się fałszywa, to druga część (bool a = false) nie powinna być oceniana, ponieważ wiadomo już, że ostateczna odpowiedź będzie fałszywa. Jeśli (bool a = false) nie jest oceniany, to co później zrobić z kodem, który używa a? Czy po prostu nie zainicjalizujemy zmiennej i nie pozostawiamy jej niezdefiniowanej? Would inicjalizujemy go na domyślne? Co zrobić, jeśli typ danych był klasą i robi to miało niepożądane skutki uboczne? Co jeśli zamiast bool użyłeś klasy i nie miała ona domyślnego konstruktora, tak że użytkownik musi podać parametry - co wtedy zrobimy?

Oto kolejny przykład:

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?

Wydaje się, że ograniczenie, które znalazłeś, wydaje się całkowicie rozsądne - zapobiega powstawaniu tego rodzaju niejasności.

Warunek w instrukcji if lub while może być albo wyrażeniem , albo pojedynczą zmiennądeklaracją (z inicjalizacją).

Twój drugi i trzeci przykład nie są ani poprawnymi wyrażeniami, ani poprawnymi deklaracjami, ponieważ deklaracja nie może stanowić części wyrażenia. Chociaż byłoby przydatne, aby móc pisać kod, jak twój trzeci przykład, wymagałoby to znaczącej zmiany składni języka.

Nie widzę, gdzie jest napisane nic o tym, że nie jest w stanie umieścić nawiasu wokół deklaracji, ani nie mówi nic o tylko jednej deklaracji na warunek.

Specyfikacja składni w 6.4 / 1 daje następujący warunek:

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

Określenie pojedynczej deklaracji, bez nawiasów i innych ozdobników.

Jeśli chcesz załączyć zmienne w węższym zakresie, zawsze możesz użyć dodatkowego { }

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

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

Ostatni dział już działa, Wystarczy napisać trochę inaczej:

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

Oto brzydkie obejście za pomocą pętli (jeśli obie zmienne są liczbami całkowitymi):

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

Ale to myli innych programistów i jest to raczej zły kod, więc nie zaleca się.

Prosty blok {} (Jak już zalecono) jest znacznie łatwiejszy do odczytania:

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

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

Należy również zauważyć, że wyrażenia wewnątrz większego bloku if

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

Niekoniecznie muszą być oceniane w sposób od lewej do prawej. Jeden dość subtelny błąd, który miałem kiedyś, miał związek z faktem, że kompilator testował od prawej do lewej zamiast od lewej do prawej.

Z odrobiną magii szablonów można jakoś obejść problem braku możliwości deklarowania wielu zmiennych:

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

(Uwaga, powoduje to utratę oceny zwarcia.)