Can (a==1 && a==2 && a==3) ever evaluate to true in C or C++?

Question

We know it can in Java and JavaScript.

But the question is, can the condition below ever evaluate to true in C or C++?

if(a==1 && a==2 && a==3) 
    printf("SUCCESS");

EDIT

If a was an integer.

Answer 1

Depends on your definition of "a is an integer":

int a__(){ static int r; return ++r; }
#define a a__()  //a is now an expression of type `int`
int main()
{
    return a==1 && a==2 && a==3; //returns 1
}

Of course:

int f(int b) { return b==1&&b==2&&b==3; }

will always return 0; and optimizers will generally replace the check with exactly that.

Answer 2

If a is of a primitive type (i.e all == and && operators are built in) and you are in defined behavior, and there's no way for another thread to modify a in the middle of execution (this is technically a case of undefined behavior - see comments - but I left it here anyway because it's the example given in the Java question), and there is no preprocessor magic involved (see chosen answer), then I don't believe there is anything way for this to evaluate to true. However, as you can see by that list of conditions, there are many scenarios in which that expression could evaluate to true, depending on the types used and the context of the code.

Answer 3

If we put macro magic aside, I can see one way that could positively answer this question. But it will require a bit more than just standard C. Let's assume we have an extension allowing to use the __attribute__((at(ADDRESS))); attribute, which is placing a variable at some specific memory location (available in some ARM compilers for example, like ARM GCC). Lets assume we have a hardware counter register at the address ADDRESS, which is incrementing each read. Then we could do something like this:

volatile int a __attribute__((at(ADDRESS)));

The volatile is forcing the compiler to generate the register read each time the comparison is performed, so the counter will increment 3 times. If the initial value of the counter is 1, the statement will return true.

P.S. If you don't like the at attribute, same effect can be achieved using linker script by placing a into specific memory section.

Answer 4

In C, yes it can. If a is uninitialised then (even if there is no UB, as discussed here), its value is indeterminate, reading it gives indeterminate results, and comparing it to other numbers therefore also gives indeterminate results.

As a direct consequence, a could compare true with 1 in one moment, then compare true with 2 instead the next moment. It can't hold both those values simultaneously, but it doesn't matter, because its value is indeterminate.

In practice I'd be surprised to see the behaviour you describe, though, because there's no real reason for the actual storage to change in memory in the time between the two comparisons.

---

In C++, sort of. The above is still true there, but reading an indeterminate value is always an undefined operation in C++ so really all bets are off.

Optimisations are allowed to aggressively bastardise your code, and when you do undefined things this can quite easily result in all manner of chaos.

So I'd be less surprised to see this result in C++ than in C but, if I did, it would be an observation without purpose or meaning because a program with undefined behaviour should be entirely ignored anyway.

---

And, naturally, in both languages there are "tricks" you can do, like #define a (x++), though these do not seem to be in the spirit of your question.

Answer 5

The following program randomly prints seen: yes or seen: no, depending on whether at some point in the execution of the main thread (a == 0 && a == 1 && a == 2) evaluated to true.

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

_Atomic int a = 0;
_Atomic int relse = 0;

void *writer(void *arg)
{
  ++relse;
  while (relse != 2);
  for (int i = 100; i > 0; --i)
    {
      a = 0;
      a = 1;
      a = 2;
    }
  return NULL;
}

int main(void)
{
  int seen = 0;
  pthread_t pt;
  if (pthread_create(&pt, NULL, writer, NULL)) exit(EXIT_FAILURE);
  ++relse;
  while (relse != 2);
  for (int i = 100; i > 0; --i)
    seen |= (a == 0 && a == 1 && a == 2);
  printf("seen: %s\n", seen ? "yes":"no");
  pthread_join(pt, NULL);
  return 0;
}

As far as I am aware, this does not contain undefined behavior at any point, and a is of an integer type, as required by the question. Obviously this is a race condition, and so whether seen: yes or seen: no is printed depends on the platform the program is run on. On Linux, x86_64, gcc 8.2.1 both answers appear regularly. If it doesn't work, try increasing the loop counters.