Thread: Just another C vs C+ vs C++ debate

Originally Posted by Elysia

Proof, please.
It is known that templates can cause bloat, but may not necessarily do so, and it's still a very, very poor argument.
People's hard drives today are so big anyway that size hardly matters, mostly.

I agree space is not a big problem but anyway the proof's here:

"C++" style

Code:

#include <iostream>

using namespace std;

int main() {
    cout << "Hello world!";
    return 0;
}

Result:

Code:

Output size is 269.50 KB

"C" style

Code:

#include <stdio.h>

int main() {
    puts("Hello world!");
    return 0;
}

Code:

Output size is 5.50 KB

Compile settings were exactly the same, I just changed the code.

Originally Posted by maxorator

Compile settings were exactly the same, I just changed the code.

What if you used printf() which is far more equivalent to an ostream in terms of its formatting capabilities? And are you linking dynamically or statically?

Originally Posted by brewbuck

What if you used printf() which is far more equivalent to an ostream in terms of its formatting capabilities? And are you linking dynamically or statically?

printf() results the same size.

And I was using MinGW.

gcc-mingw automatically links the libstdc++ as a static library, since it is not normally distributed to other machines, so your code would not necessarily work on those machines if it wasn't that way. Of course, if you link in the stdc library for you C executable, you would also end up with a fairly large executable. The latests MSVC version presumes that the library files are also installed on the target system, so you need to supply a few megabytes of DLL's if you distribute that code (unless you link statically, and then you end up with a LARGE executable).

Obviously, producing similar code many times over, as template code CAN do, that isn't actually particularly different. Say for example we write a templated function that produces a string from a number - now, we could simply produce the exact same piece of code for both signed and unsigned integer, short int, unsigned short, etc, etc, and another for double and float values. That would produce (say) four variants of the integer code, essentially identical, and two variants of essentially identical code for the float/double variants. With some clever use of specialization, you could do:

Code:

std::string tostring(int x)
{
   std::string result;
   if (x < 0)
   {
       result = '-';
       x = -x;
   }
   return result + tostring(static_cast<unsigned int>(x));
}

std::string tostring(short int x)
{
    return tostring(static_cast<int>(x));
}

std::string tostring(unsigned short int x)
{
    return tostring(static_cast<unsigned int>(x));
}

std::string tostring(float f)
{
    return tostring(static_cast<double>(f));
}

Now, we only need to implement a full version of unsigned int and double variants of the tostring functions - which I'm too lazy to do here [and admittedly, it's probably not a lot of difference between this way and the expand everything variant - but I think it shows that you MAY be able to reduce the overhead from templates by thinking about it a little bit].

--
Mats