Why would you use an assignment in a condition?

Question

In many languages, assignments are legal in conditions. I never understood the reason behind this. Why would you write:

if (var1 = var2) {
  ...
}

instead of:

var1 = var2;
if (var1) {
  ...
}

?

Inflated

Is this question really so language-agnostic? Which languages are affected by this? I know C and C++ are, what else? – Scan

What other languages besides C and C++ allow this (without a compile-time or run-time error)? PHP? Perl? – Macdougall

Note: The canonical question for the common programming error associated with this (unintentional assignment) is Variable assignment in "if" condition (even if it is from 2013). – Macdougall

As expected, there is also a question from 2008 (but search engines don't like to point to it). – Macdougall

Tell me about it. Just wasted 1 hour as there isnt even a warning in vscode that I had used = instead of == for a normal conditional test. – Vocational

Answer 1

It's more useful for loops than if statements.

while(var = GetNext())
{
  ...do something with 'var' 
}

Which would otherwise have to be written

var = GetNext();
while(var)
{
  ...do something
  var = GetNext();
}

Comenius

I agree - but would write: while ((var = GetNext()) != 0) { ... } without thinking twice, partly because GCC complains if I don't with my default compilation options. – Longfellow

True. Assuming you're using a language that supports for-loop declarations, and you're not already using var outside of the loop. – Comenius

in Some languages, like ANSI C, scoping rules don't permit this approach, @KerrekSB – Justification

@wirrbel: You mean ANSI C from what, 1989? Like when they had steam engines and punch cards? That may be the case, but is that relevant? – Mccary

Is this a bad practice? My javascript linter gives me warning: 'expected conditional expression and instead saw an assignment' when I do while(item = stream.read()) { ... } – Dolora

That warning is not because there is anything wrong with an assignment in a while, but because doing an assignment when you really meant to do a comparison is a common bug. If you want to get rid of the warning you can do the JS equivalent of what @Jonathan Leffler suggests. Personally I would probably do that anyway because of how much I mistrust the JavaScript truthy rules :) It should also be noted in some languages like C# and Java that is the only way. – Comenius

Answer 2

I find it most useful in chains of actions which often involve error detection, etc.

if ((rc = first_check(arg1, arg2)) != 0)
{
    report error based on rc
}
else if ((rc = second_check(arg2, arg3)) != 0)
{
    report error based on new rc
}
else if ((rc = third_check(arg3, arg4)) != 0)
{
    report error based on new rc
}
else
{
    do what you really wanted to do
}

The alternative (not using the assignment in the condition) is:

rc = first_check(arg1, arg2);
if (rc != 0)
{
    report error based on rc
}
else
{
    rc = second_check(arg2, arg3);
    if (rc != 0)
    {
        report error based on new rc
    }
    else
    {
        rc = third_check(arg3, arg4);
        if (rc != 0)
        {
            report error based on new rc
        }
        else
        {
            do what you really wanted to do
        }
    }
}

With protracted error checking, the alternative can run off the RHS of the page whereas the assignment-in-conditional version does not do that.

The error checks could also be 'actions' — first_action(), second_action(), third_action() — of course, rather than just checks. That is, they could be checked steps in the process that the function is managing. (Most often in the code I work with, the functions are along the lines of pre-condition checks, or memory allocations needed for the function to work, or along similar lines).

Longfellow

Yeah, I actually did just this to avoid excessive nesting and then searched online to see if it was a common practice. In the end I decided against it because I actually only had one else case, but this seems like a legitimate reason to put the assignment in the condition. – Bloomy

Coworkers hate it! To me, at least in most cases, is far more maintainable than a giant tree or many returns. I prefer single return from a function... – Canula

a reasonable example, the acompanion blocks make the pattern obvious, self-explanatory. But, well, the in-block ("pseudo") code looks a bit ugly, and the inverse style (placing what you really wanted to do at the end) isn't that great. – Scan

Answer 3

It's more useful if you are calling a function:

if (n = foo())
{
    /* foo returned a non-zero value, do something with the return value */
} else {
    /* foo returned zero, do something else */
}

Sure, you can just put the n = foo(); on a separate statement then if (n), but I think the above is a fairly readable idiom.

Meunier

I think you should enclose it in parenthesis or gcc will complain with: warning: suggest parentheses around assignment used as truth value [-Wparentheses] Like this: if ((n = foo())) { // do something with the return value } else { // foo returned zero/NULL, do something else } – Gilliland

Answer 4

It can be useful if you're calling a function that returns either data to work on or a flag to indicate an error (or that you're done).

Something like:

while ((c = getchar()) != EOF) {
    // process the character
}

// end of file reached...

Personally it's an idiom I'm not hugely fond of, but sometimes the alternative is uglier.

Rouse

Answer 5

GCC can help you detect (with -Wall) if you unintentionally try to use an assignment as a truth value, in case it recommends you write

if ((n = foo())) {
   ...
}

I.e. use extra parenthesis to indicate that this is really what you want.

Leveller

Good to know. I hope your co-workers read it in the same manner. – Scan

Me? Goodness, I would never try to use assignment as a truth value. I was referring to what GCC recommends. – Leveller

GCC can also compile Fortran. Perhaps be explicit about the programming language? – Macdougall

I much prefer the explicit if ((n = foo()) != 0) to avoid quite so many consecutive close parentheses, but I admit that you can increase the number of consecutive ) by notations such as if ((n = foo2(a, somefunc(b, sizeof(SomeType)))) != 0) – Longfellow

Answer 6

The idiom is more useful when you're writing a while loop instead of an if statement. For an if statement, you can break it up as you describe. But without this construct, you would either have to repeat yourself:

c = getchar();
while (c != EOF) {
    // ...
    c = getchar();
}

or use a loop-and-a-half structure:

while (true) {
    c = getchar();
    if (c == EOF) break;
    // ...
}

I would usually prefer the loop-and-a-half form.

Sea

For a while loop, prefer using: do { c = getchar(); ... } while (c != EOF); – Theurer

And for loops can be used instead: for (char c = getchar(); c != EOF; c= getchar()) { /* do something with c */ } -- this is the most concise, and for always says 'loop' to me, stylistically. Small downside is that you have to specify the function returning c twice. – Theurer

Answer 7

The short answer is that expression-oriented programming languages allow more succinct code. They don't force you to separate commands from queries.

Uncouth

It is a constant fight to enforce coding without assignments in if(), while(), and other similar statements. C/C++ are notorious for side effects of such that often turn out to be bugs, especially when we add the ++ and -- operators. – Pricillaprick

The first link is useless: C or C++ seem not to be such a language. – Scan

Answer 8

In PHP, for example, it's useful for looping through SQL database results:

while ($row = mysql_fetch_assoc($result)) {
    // Display row
}

This looks much better than:

$row = mysql_fetch_assoc($result);
while ($row) {
    // Display row
    $row = mysql_fetch_assoc($result);
}

Cuckooflower

This also has the neat side-effect of $row not living beyond that loop and therefore being eligible for garbage collection sooner (in languages that do GC anyway). – Sledgehammer

Answer 9

The other advantage comes during the usage of GDB.

In the following code, the error code is not known if we were to single step.

while (checkstatus() != -1) {
    // Process
}

Rather

while (true) {
    int error = checkstatus();
    if (error != -1)
        // Process
    else
        // Fail
}

Now during single stepping, we can know what was the return error code from the checkstatus().

Okie

You mean that it can be helpful for temporary changes when debugging code? – Scan

Answer 10

I find it very useful with functions returning optionals (boost::optional or std::optional in C++17):

std::optional<int> maybe_int(); // function maybe returns an int

if (auto i = maybe_int()) {
    use_int(*i);
}

This reduces the scope of my variable, makes code more compact and does not hinder readability (I find).

Same with pointers:

int* ptr_int();

if (int* i = ptr_int()) {
    use_int(*i);
}

Spall

By the way, if you want to limit the scope of variables, you can use if with initializers :) – Flooded

Answer 11

I used it today while programing in Arduino (Subset of C++ language).

Case

I have a transmitter and a receiver. The transmitter wants to send the data until it is received. I want to set a flag when the process is done.

while (!(newtork_joined = transmitter.send(data))) {
Serial.println("Not Joined");
}

Here:

• "transmitter.send" - returns true when the transmission is successful
• "newtork_joined " - is the flag I set when successful

Result

1. When the transmission is not successful, the flag is not set, while loop is true, it keeps executing

2. When successful, the flag is set, while loop is false, we exit

Isn't beautiful?

Haystack

Re "in Arduino (C language": Arduino's programming language is for the most part a subset of C++ (not C)—though it is not entirely clear what it is. For instance, it has class 'string' (e.g., operator "+= " defined for it). This is definitely not C. – Macdougall

@PeterMortensen, you are right. Let me edit. – Haystack

Answer 12

The reason is:

1. Performance improvement (sometimes)

2. Less code (always)

Take an example: There is a method someMethod() and in an if condition you want to check whether the return value of the method is null. If not, you are going to use the return value again.

If(null != someMethod()){
    String s = someMethod();
    ......
    //Use s
}

It will hamper the performance since you are calling the same method twice. Instead use:

String s;
If(null != (s = someMethod())) {
    ......
    //Use s
}

Heavyfooted

What language is this? It wouldn't compile in C# or C++ (capitalisation of "If"). – Macdougall