Which of the two programs is better and why?

Question

Code 1

int A, B, MAX;
cout << "Give two numbers:" << endl;
cin >> A >> B;

if (A > B)
{ 
  MAX = A;
}
else 
{
  MAX = B;
}
cout << "Largest amongst given numbers is: ";
cout << MAX << endl;
return 0;

Code 2

int A, B, MAX;
cout << "Give two numbers:" << endl;
cin >> A >> B;

MAX = A;
if (B > MAX)
{
  MAX = B;
}
cout << "Largest amongst given numbers is: ";
cout << MAX << endl;
return 0;

In above program logic, which one is best and why? is there any difference between them.? it is my exam question i would like to ask stack overflow to know best opinion.

Answer 1

MAX = std::max(A, B);

Is better than both in terms of clarity.

In terms of speed, the compiler should be able to optimise any of these methods to be equivalent; but again I'd favour std::max because I'd sooner trust the compiler to optimise a standard function than some arbitrary made up code to perform the same task.

Answer 2

They are the same so I would prefer code 1 because it's more readable. In both cases you have to bring both A and B into a register (regardless) and then do a single comparison (regardless). And it won't write out to the variable MAX until after this segment is done (because it won't need to kick anything out of a register).

This isn't something that is going to cause any kind of performance gain. In fact, it's possible (although I doubt it) that the compiler would compile them the same (the compiler does all kinds of code modification to create an optimal set of instructions).

As suggested the only thing that likely would give a performance gain is using the library function std::max. This is because the compiler will basically perform the comparison in the most efficient way (likely without even calling a conditional jump). If your two values are integers, then you can see here that it's possible to find the max with five integer operations (all of which, except the multiplication can generally be done in a single cycle). You generally want to avoid conditional jumps as much as possible and this algorithm does that. Most likely the max function does something like this or similar (but it would have to be different for floating point values).

Answer 3

After MAX = std::max(A,B), the next best code is:

MAX = A > B ? A : B;

If you don't want to use that, then I prefer your "code 1" because:

• code 2 always sets MAX = A, which is momentarily misleading and only becomes clear as the later code is studied; while this issue is common in C++ and many other languages, there's no particular reason to embrace that complication when it's easily avoided

• for some types　(the question didn't originally specify int), an assignment may be an expensive operation (e.g. copying a lot of data), so always assigning once is better than potentially assigning twice

For both those reasons, it also desirable to declare and define MAX in one step. It may not be practical if say it's a non-const reference accepted as a function argument, but when it is possible it's another good reason to prefer std::max or the ternary ? approach: you won't need a misleading and potentially inefficient or unavailable default construction. (Now you've changed the question to be int specific, the expense of copying and construction is known and trivial, and the optimiser can be counted on to remove them in most cases).

Answer 4

I would say use code 2. It is better because you explicitly say that if MAX B is greater than MAX A, then change MAX to B. In the other one, you don't have any defining factors about why MAX A is greater than MAX B. From what I see, you will probably have a harder time using code 1 than code 2.