Concept behind these 4 lines of tricky C++ code

More readable version:

double m[2] = {7709179928849219.0, 771};
// m[0] = 7709179928849219.0;
// m[1] = 771;    

int main()
{
    if (m[1]-- != 0)
    {
        m[0] *= 2;
        main();
    }
    else
    {
        printf((char*) m);
    }
}

It recursively calls main() 771 times. In the beginning m[0] = 7709179928849219.0, which stands for C++Suc;C. In every call, m[0] gets doubled, to "repair" last two letters. In the last call, m[0] contains ASCII char representation of C++Sucks. It's assuming that m[0] is stored on 8 bytes, so each char takes 1 byte. m[1] contains all zeros, so it has a null terminator for C++Sucks string.

Without recursion and illegal main() calling it will look like this:

double m[] = {7709179928849219.0, 0};
for (int i = 0; i < 771; i++)
{
    m[0] *= 2;
}
printf((char*) m);

Formally speaking, it's impossible to reason about this program because it's ill-formed (i.e. it's not legal C++). It violates C++11[basic.start.main]p3:

The function main shall not be used within a program.

This aside, it relies on the fact that on a typical consumer computer, a double is 8 bytes long, and uses a certain well-known internal representation. The initial values of the array are computed so that when the "algorithm" is performed, the final value of the first double will be such that the internal representation (8 bytes) will be the ASCII codes of the 8 characters C++Sucks. The second element in the array is then 0.0, whose first byte is 0 in the internal representation, making this a valid C-style string. This is then sent to output using printf().

Running this on HW where some of the above doesn't hold would result in garbage text (or perhaps even an access out of bounds) instead.

It is just building up a double array (16 bytes) which - if interpreted as a char array - build up the ASCII codes for the string "C++Sucks"

However, the code is not working on each system, it relies on some of the following undefined facts:

• double has exactly 8 bytes
• double is represented in a certain way

The following code prints C++Suc;C, so the whole multiplication is only for the last two letters

double m[] = {7709179928849219.0, 0};
printf("%s\n", (char *)m);

The others have explained the question pretty thoroughly, I'd like to add a note that this is undefined behavior according to the standard.

C++11 3.6.1/3 Main function

The function main shall not be used within a program. The linkage (3.5) of main is implementation-defined. A program that defines main as deleted or that declares main to be inline, static, or constexpr is ill-formed. The name main is not otherwise reserved. [ Example: member functions, classes, and enumerations can be called main, as can entities in other namespaces. —end example ]

The code could be re-written like this:

void f()
{
    if (m[1]-- != 0)
    {
        m[0] *= 2;
        f()
    } else {
          printf((char*)m);
    }
}

What it's doing is producing a set of bytes in the double array m that happen to correspond to the characters 'C++Sucks' followed by a null-terminator. They've obfuscated the code by choosing a double value which when doubled 771 times produces, in the standard representation, that set of bytes with the null terminator provided by the second member of the array.

Note that this code wouldn't work under a different endian representation. Also, calling main() is not strictly allowed.

Its basically just a clever way to hide the String "C++Sucks" (note the 8 Bytes) within the first double value, which is recursively multiplied with 2 until the seconds double values reaches zero. (771 times)

Multiplying the double values 7709179928849219.0 * 2 * 711 results in "C++Sucks" if you interpret the byte-value of the double as string, which printf() does with the cast. And printf() doesn't fail, because the second double value is "0" and interpreted as "\0" by printf().