C ++, объявление переменной в выражении if

Что тут происходит?

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

В разделе 6.4.3 стандарта 2003 объясняется, как переменные, объявленные в условии оператора выбора, имеют область видимости, которая распространяется до конца подзапросов, контролируемых этим условием. Но я не вижу, где говорится что-либо о невозможности заключить объявление в круглые скобки, и при этом ничего не говорится об одном объявлении на условие.

Это ограничение раздражает даже в тех случаях, когда требуется только одно объявление в условии. Учти это.

bool a = false, b = true;

if(bool x = a || b)
{

}

Если я хочу войти в область 'if "-body с x, установленным в false, тогда для объявления нужны круглые скобки (поскольку оператор присваивания имеет более низкий приоритет, чем логическое ИЛИ), но поскольку скобки не могут использоваться, для него требуется объявление x вне тело, передавая это объявление в более широкую область видимости, чем требуется. Очевидно, что этот пример тривиален, но более реалистичным будет тот, где a и b - функции, возвращающие значения, которые необходимо протестировать

Итак, что я хочу сделать в соответствии со стандартом, или мой компилятор просто ломает мои яйца (VS2008)?

Начиная с C ++ 17, наконец, возможно то, что вы пытались сделать :

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

Обратите внимание на использование ;вместо вместо ,объявления объявления и фактического условия.

Я думаю, вы уже намекнули на проблему. Что компилятору делать с этим кодом?

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

Оператор «&&» представляет собой логическое И при коротком замыкании. Это означает, что если первая часть (1==0)окажется ложной, тогда вторая часть (bool a = false)не должна оцениваться, потому что уже известно, что окончательный ответ будет ложным. Если (bool a = false)не оценивается, что потом делать с кодом, который использует a? Не могли бы мы просто инициализировать переменную и оставить ее неопределенной? Будем ли мы инициализировать его по умолчанию? Что, если бы тип данных был классом, и это имело бы нежелательные побочные эффекты? Что, если бы вместо этого boolвы использовали класс и у него не было конструктора по умолчанию, так что пользователь должен был указать параметры - что нам тогда делать?

Вот еще один пример:

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?

Похоже, что обнаруженное вами ограничение кажется вполне разумным - оно предотвращает возникновение подобных двусмысленностей.

Условие в ifили whileзаявление может быть либо выражение , либо одной переменной декларации (с инициализацией).

Ваши второй и третий примеры не являются ни допустимыми выражениями, ни действительными объявлениями, поскольку объявление не может быть частью выражения. Хотя было бы полезно написать код, подобный вашему третьему примеру, это потребует значительного изменения синтаксиса языка.

Я не вижу, где что-либо говорится о невозможности заключить объявление в круглые скобки, и при этом ничего не говорится об одном объявлении для каждого условия.

Спецификация синтаксиса в 6.4 / 1 дает следующее условие:

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

указание единственного объявления без скобок или других украшений.

Если вы хотите заключить переменные в более узкую область, вы всегда можете использовать дополнительные { }

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

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

Последний раздел уже работает, вам просто нужно написать его немного иначе:

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

Вот уродливый обходной путь с использованием цикла (если обе переменные - целые числа):

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

Но это запутает других программистов, и это довольно плохой код, поэтому не рекомендуется.

Простой охватывающий {}блок (как уже рекомендовано) читать намного легче:

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

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

Следует также отметить, что выражения внутри большего блока if

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

не обязательно гарантируют, что они будут оцениваться слева направо. Одна довольно тонкая ошибка, которая у меня была в тот день, была связана с тем, что компилятор на самом деле тестировал справа налево, а не слева направо.

С помощью небольшой магии шаблонов вы можете как бы обойти проблему невозможности объявления нескольких переменных:

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

(Обратите внимание, это теряет оценку короткого замыкания.)