5 replies to this topic

[kruseborn]

What is the different when writing for example unsigned i = 0; and unsigned i = 0u; Does the compiler compile this two examples different?

The same question regarding big numbers, when for example long long i = 1LL << 35;

Should you always tell the compiler what kind of type you are using?

[Wernaeh]

See this discussion:
http://stackoverflow...e-or-at-runtime

As a short summary, your compiler is free to evaluate these constant expressions either at compile time or at runtime.

However, your compiler needs to at least evaluate the types of a given constant expression to provide compile-time typing errors.

Thus most compilers automatically perform the appropriate calculations as well for optimization purposes.

Thus,
long long i = 1LL << 35;
commonly is precalculated, but may also be explicitly calculated on weird compilers.

Just have a look at your compiler output for the appropriate line for the actual behaviour.

I generally don't bother with providing constant type specifiers, since I think code is more readable without them. However, I add them whereever required to solve typing problems.

I.e.
float myValue = 1;
But:
float myValueToo = MyInteger / 7.f;

Hope this helps,
Cheers,
- Wernaeh

[poita]

There is no difference. The compiler automatically converts them to the type you need.

The difference comes in when calling templated/overloaded functions.

e.g.

void foo(int i) {cout << "int" << endl;}
void foo(unsigned int i) {cout << "unsigned int" << endl;}

int main()
{
  foo(0); // prints "int"
  foo(0U); // prints "unsigned int"
}

[kruseborn]

Thank you

[kruseborn]

Well it is a different,
this code print different outputs:

#include <iostream>


using namespace std;


int main()

{

    long long temp = 1LL<<35;

    long long temp2 = 1<<35;

    cout << temp << endl;

    cout << temp2 << endl;

    return 0;

}

poita said:

There is no difference. The compiler automatically converts them to the type you need.

The difference comes in when calling templated/overloaded functions.

e.g.

void foo(int i) {cout << "int" << endl;}

void foo(unsigned int i) {cout << "unsigned int" << endl;}


int main()

{

  foo(0); // prints "int"

  foo(0U); // prints "unsigned int"

}

[poita]

Yes, it will matter in that case because you have an expression that will be evaluated as an int. 1<<35 cannot be represented as an int, so you get garbage. You need to promote the 1 to a long long so that it will be evaluated correctly.