C ++, deklaracja zmiennej w wyrażeniu „if”

Co tu się dzieje?

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.
}

Sekcja 6.4.3 standardu z 2003 r. Wyjaśnia, w jaki sposób zmienne zadeklarowane w warunku instrukcji wyboru mają zakres, który rozciąga się do końca podstacji kontrolowanych przez warunek. Ale nie widzę, gdzie mówi cokolwiek o braku możliwości umieszczenia nawiasów wokół deklaracji, ani nie mówi nic o tylko jednej deklaracji na warunek.

To ograniczenie jest irytujące nawet w przypadkach, gdy wymagane jest tylko jedno oświadczenie w warunku. Rozważ to.

bool a = false, b = true;

if(bool x = a || b)
{

}

Jeśli chcę wprowadzić zakres „if” -body z x ustawionym na false, wtedy deklaracja wymaga nawiasu (ponieważ operator przypisania ma niższy priorytet niż logiczne OR), ale ponieważ nie można użyć nawiasu, wymaga deklaracji x na zewnątrz ciała, przeciekając tę ​​deklarację do większego zakresu niż jest to pożądane. Oczywiście ten przykład jest trywialny, ale bardziej realistycznym przypadkiem byłby ten, w którym a i b są funkcjami zwracającymi wartości, które muszą zostać przetestowane

Czy to, co chcę zrobić, jest niezgodne ze standardem, czy też mój kompilator po prostu niszczy mi jaja (VS2008)?

Od C ++ 17 to, co próbowałeś zrobić, jest wreszcie możliwe :

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

Zwróć uwagę na użycie ;zamiast w ,celu oddzielenia deklaracji od stanu faktycznego.

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

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

Operator „&&” to logiczne ORAZ zwarcie. Oznacza to, że jeśli pierwsza część (1==0)okaże się fałszywa, to drugiej części (bool a = false)nie należy oceniać, ponieważ już wiadomo, ż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 zainicjowalibyśmy zmiennej i pozostawilibyśmy ją niezdefiniowaną? Czy zainicjowalibyśmy go domyślnie? A co, jeśli typ danych był klasą i miałoby to niepożądane skutki uboczne? A co by było, gdybyś zamiast boolciebie użył klasy i nie miała ona domyślnego konstruktora takiego, że użytkownik musi podać parametry - co wtedy robimy?

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 uzasadnione - zapobiega występowaniu tego rodzaju niejasności.

Warunek w instrukcji iflub whilemoże być wyrażeniem lub deklaracją pojedynczej zmiennej (z inicjalizacją).

Twój drugi i trzeci przykład nie są ani prawidłowymi wyrażeniami, ani prawidłowymi deklaracjami, ponieważ deklaracja nie może stanowić części wyrażenia. Chociaż byłoby przydatne móc napisać kod podobny do trzeciego przykładu, wymagałoby to znaczącej zmiany składni języka.

Nie widzę, gdzie mówi cokolwiek o niemożności umieszczenia nawiasów wokół deklaracji, ani nie mówi nic o tylko jednej deklaracji na warunek.

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

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

określając jedną deklarację, bez nawiasów ani innych ozdób.

Jeśli chcesz zawrzeć zmienne w węższym zakresie, zawsze możesz użyć dodatkowych { }

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

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

Ostatnia sekcja już działa, wystarczy napisać ją nieco 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 zmyli innych programistów i jest to raczej zły kod, więc nie jest zalecany.

Prosty {}blok zamykający (jak już zalecamy) 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ś, był związany z faktem, że kompilator faktycznie testował od prawej do lewej zamiast od lewej do prawej.

Dzięki odrobinie magii szablonów można w pewnym sensie obejść problem braku możliwości zadeklarowania 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).