Different outputs in different compilers

Your code uses a main function with the signature int main(int) , which is illegal , as other answers have already quoted. However, GCC accepts such a signature by generating only a warning, not an error. The code is compiled smoothly and does as expected. The reason for the behavior is not there. (although it's something that should be fixed anyway).

Passing a default value for this argument makes no sense since the system will always call the main function by explicitly passing the value. In case it will be 1 if you call the program without any parameters on the command line, 2 if you use a parameter, 3 for two parameters and so on. Note that in assmbly it is clear and no shadow of doubt that the first value displayed on the screen is the argument passed to the function main .

main:                              // Início da função 'main'
.LFB969:                           // Prólogo: Alocar 16 bytes de stack
    .cfi_startproc
    pushl   %ebp
    .cfi_def_cfa_offset 8
    .cfi_offset 5, -8
    movl    %esp, %ebp
    .cfi_def_cfa_register 5
    andl    $-16, %esp
    subl    $16, %esp              // Fim do prólogo.
.L4:
    cmpl    $1000, 8(%ebp)         // Comparar o argumento com 1000
    jg  .L2                        // Se for maior, pule para L2. Não é.
    movl    8(%ebp), %eax          // Copie o argumento para EAX
    addl    $1, 8(%ebp)            // Incremente o argumento
    movl    %eax, 4(%esp)          // Prepare para passar EAX como argumento
    movl    $_ZSt4cout, (%esp)     // Prepare para passar std::cout como argumento
    call    _ZNSolsEi              // Chame 'std::cout << EAX';

Given this, there is no question that the first value that exits the screen is the argument of the main function. If you see 2 is why you passed a parameter on the command line when you invoked your executable. There is no other possibility.

The problem is that the main function should only receive 0 or 2 arguments (int argc, char ** argv), according to the C ++ standard. Because your code does not conform to the C ++ rules, each compiler can treat you differently. G ++, for example, generates a warning with its prototype (use -Wmain, if it is not showing for you), but it seems to treat it as if it were argc.

As a general rule, make sure your code conforms to the C ++ standard and you will have less trouble switching compiler / platform.

The shapes defined by the pattern are as follows: int main() {

or

int main(int argc, char** argv) {

When building your program in C ++ you have some options for declaring the input function called main . The two most common ones are:

1 - Without worrying about receiving and handling binary / executable command line arguments. For example:

#include <iostream>
int main() {
    std::cout << "Ola mundo!" << std::endl;
    return 0;
}

2 - Receiving and handling binary / executable command line arguments. For example:

#include <iostream>
int main(int argc, char** argv) {
    std::cout << "Ola mundo!" << std::endl;
    std::cout << "Total de argumentos: " << argc << std::endl;
    for(int i = 0; i < argc; i++)
        std::cout << "Argumento #" << i << " = [" << argv[i] << "]" << std::endl;
    return 0;
}

But the fact is that the definition of the prototype of this function in many compilers allows some variations. In Visual Studio 2013, for example, the "signature" of the prototype is described as in the documentation :

  

int main (int argc [ char * argv [] [ char * envp []]]);

The brackets (characters [ and ] ) serve in this context only to indicate the optionality of the function parameters (that is, parameters in brackets are optional).

Note: Note that it is also possible to receive and treat environment variables with the parameter envp .

Another detail is that the C ++ language allows you to indicate, when defining your own functions, parameters that are optional. This is done simply by setting a default value that should be used if the parameter is not used / informed in the call.

So when building your code the way you did, you simply used only the first parameter ( argc , which contains the number of binary command line arguments / executable, although you have renamed it to x ). Since the second (and third) parameter of main is optional, it will (most likely - this depends on the compiler implementation) receive the NULL value.

In addition, you simply reset the default value of this argument to 1 . In practice, simply having it there always means that you always get the path and name of your own binary / executable (according to the documentation, this is always the value of argv [0], regardless of whether you provide it or no additional arguments on the command line), so this default value is simply useless.

This all I've argued does not answer the fact (alleged by you, but still unproven: I simply could not reproduce in my local tests with VS 2013) of the result change depending on the use of minor ( < ) or less or equal (% with%). Still, knowing the documentation and the expected behavior of the <= function, I tend to believe that the value variation of its main variable between x and 1 stems from you being passing some argument on the command line (even without realizing it).

Anyway, if your interest is to receive via the command line the number that should be used to start your count, you can do as follows:

#include <iostream>
int main(int argc, char** argv)
{
    // Validação dos argumentos da linha de comando
    if(argc != 2)
    {
        std::cerr << "Sintaxe: " << argv[0] << " <valor inicial>" << std::endl;
        return -1;
    }

    int x = atoi(argv[1]);
    while (x <= 1000 && std::cout << x++ << std::endl) {}
    return 0;
}