Pro/con: Initializing a variable in a conditional statement

Question

In C++ you can initialize a variable in an if statement, like so:

if (CThing* pThing = GetThing())
{
}

Why would one consider this bad or good style? What are the benefits and disadvantages?

Personally i like this style because it limits the scope of the pThing variable, so it can never be used accidentally when it is NULL. However, i don't like that you can't do this:

if (CThing* pThing = GetThing() && pThing->IsReallySomeThing())
{
}

If there's a way to make the above work, please post. But if that's just not possible, i'd still like to know why.

Question borrowed from here, similar topic but PHP.

Answer 1

The important thing is that a declaration in C++ is not an expression.

bool a = (CThing* pThing = GetThing()); // not legit!!

You can't do both a declaration and boolean logic in an if statement, C++ language spec specifically allows either an expression or a declaration.

if(A *a = new A)
{
    // this is legit and a is scoped here
}

How can we know whether a is defined between one term and another in an expression?

if((A *a = new A) && a->test())
{
    // was a really declared before a->test?
}

Bite the bullet and use an internal if. The scope rules are useful and your logic is explicit:

if (CThing* pThing = GetThing())
{
    if(pThing->IsReallySomeThing())
    {
    }
}

Answer 2

About the advantages:

It's always recommended to define variables when you first need them, not a line before. This is for improved readability of your code, since one can tell what CThing is without scrolling and searching where it was defined.

Also reducing scope to a loop/if block, causes the variable to be unreferenced after the execution of the code block, which makes it a candidate for Garbage Collection (if the language supports this feature).

Answer 3

if (CThing* pThing = GetThing())

It is bad style, because inside the if you are not providing a boolean expression. You are providing a CThing*.

CThing* pThing = GetThing();
if (pThing != NULL)

This is good style.

Answer 4

One reason I don't normally do that is because of the common bug from a missed '=' in a conditional test. I use lint with the error/warnings set to catch those. It will then yell about all assignments inside conditionals.

Answer 5

Just an FYI some of the older Microsoft C++ compliers(Visual Studios 6, and .NET 2003 I think) don't quite follow the scoping rule in some instances.

for(int i = 0; i > 20; i++) {
     // some code
}

cout << i << endl;

I should be out of scope, but that was/is valid code. I believe it was played off as a feature, but in my opinion it's just non compliance. Not adhering to the standards is bad. Just as a web developer about IE and Firefox.

Can someone with VS check and see if that's still valid?

Answer 6

This shoulddoesn't work in C++ sinceeven though it supports short circuiting evaluation. MaybeDon't try the following:

if ((CThing* pThing = GetThing()) && (pThing->IsReallySomeThing()))
{
}

err.. see Wesley Tarle's answer

Answer 7

You can also enclose the assignment in an extra set of ( ) to prevent the warning message.

Answer 8

I see that as kind of dangerous. The code below is much safer and the enclosing braces will still limit the scope of pThing in the way you want.

I'm assuming GetThing() sometimes returns NULL which is why I put that funny clause in the if() statement. It prevents IsReallySomething() being called on a NULL pointer.

{
    CThing *pThing = GetThing();
    if(pThing ? pThing->IsReallySomeThing() : false)
    {
    // Do whatever
    }
}

Answer 9

also notice that if you're writing C++ code you want to make the compiler warning about "=" in a conditional statement (that isn't part of a declaration) an error.

Answer 10

It's acceptable and good coding practice. However, people who don't come from a low-level coding background would probably disagree.

Answer 11

So many things. First of all, bare pointers. Please avoid them by all means. Use references, optional, unique_ptr, shared_ptr. As the last resort, write your own class that deals with pointer ownership and nothing else.

Use uniform initialization if you can require C++11 (C++14 preferred to avoid C++11 defects): - it avoids = vs == confusion and it's stricter at checking the arguments if there are any.

if (CThing thing {})
{
}

Make sure to implement operator bool to get predictable conversion from CThing to bool. However, keep in mind that other people reading the code would not see operator bool right away. Explicit method calls are generally more readable and reassuring. If you can require C++17, use initializer syntax.

if (CThing thing {}; thing.is_good())
{
}

If C++17 is not an option, use a declaration above if as others have suggested.

{
  CThing thing {};
  if (thing.is_good())
  {
  }
}