What is the cost of compiling a C program with a C++ compiler?

I want to use C with templates on a embedded environment and I wanted to know what is the cost of compiling a C开发者_开发百科 program with a C++ compiler?

I'm interested in knowing if there will be more code than the one the C compiler will generate.

Note that as the program is a C program, is expect to call the C++ compiler without exception and RTTI support.

Thanks, Vicente

The C++ compiler may take longer to compile the code (since it has to build data structures for overload resolution, it can't know ahead of time that the program doesn't use overloads), but the resulting binary should be quite similar.

Actually, one important optimization difference is that C++ follows strict aliasing rules by default, while C requires the restrict keyword to enable aliasing optimizations. This isn't likely to affect code size much, but it could affect correctness and performance significantly.

There's probably no 'cost', assuming that the two compilers are of equivalent quality. The traditional objection to this is that C++ is much more complex and so it's more likely that a C++ compiler will have bugs in it.

Realistically, this is much less of a problem that it used to be, and I tend to do most of my embedded stuff now as a sort of horrible C/C++ hybrid - taking advantage of stronger typing and easier variable declaration rules, without incurring RTTI or exception handling overheads. If you're taking a given compiler (GCC, etc) and switching it from C to C++ mode, then much of what you have to worry about is common to the two languages anyway.

The only way to really know is for you to try it with the compilers you care about. A quick experiment here on a trivial program shows that the output is the same.

Your program will be linked to the C++ runtime library, not the C one. The C++ is larger as well.

Also, there are a couple of differences between C and C++ (aliases were already pointed out) so it may happen that your C code just does not compile in C++.

If it's C, then you can expect it will be exactly the same.

To elaborate: both C and C++ will forward their parse tree into the same backend that generates code (possibly via another intermediate representation), which means that if the code is functionally identical, the output will look the same (or nearly so).

Templates do "inflate" code, but you would otherwise have to write the same code or use macros to the same effect, so this is no "extra cost". Contrarily, the compiler may be able to optimize templates better in some cases.

A C++ compiler cannot compile C code. It can only compile C++, including a very ugly language which is the intersection of C and C++ and the worst of both worlds. Some C code will fail to compile at all on a C++ compiler, for example:

char *s = malloc(len+1);

While other C code will be compiled to the wrong thing, for example:

sizeof 'a'

I have found this extra-ordinary document Technical Report on C++ Performance. I have found there all the answers i was looking for.

Thanks to all that have answered this question.

There will be more code because that is what templates do. They are a stencil for generating (more) code.

Otherwise, you should see no differences between compiling a C program with a C compiler versus compiling with a C++ compiler.

If you don't use any of the extra "features" there should be no difference in size or behavior of the end result.

Although the C code will likely compile to something very similar (assuming there's no exception support enabled), using templates can very rapidly result in large binaries - you have to be careful, because every template instantiation can recursively result in other templates being implicitly instantiated as well.

There was a time when the C++ compiler linked in a bunch of C++ stuff even if the program didnt use it and you would see binaries that were 10 to 100 times larger than the C compiler would produce. I think a lot of that has gone away.

Since this is tagged "embedded", I assume its for embedded systems?

In that case, the major difference between C and C++ is the way C++ treats structs. All structs will be treated like classes, meaning they will have constructors.

All instances of structs/classes declared at file scope or as static will then have their constructors called before main() is executed, in a similar manner to static initialization, which you already have there no matter C or C++.

All these constructor calls at bootup is a major disadvantage in efficiency for embedded systems, where the code resides in NVM and not in RAM. Just like static initialization, it will create an ugly, undesired workload peak at the start of the program, where values from NVM are copied into the RAM.

There are ways around the static initialization in C/C++: most embedded compilers have an option to disable it. But since that is a non-standard setup, all code using statics would then have to be written so that it never uses any initialization values, but instead sets all static variables in runtime.

But as far as I know, there is no way around calling constructors, without violating the standard.

EDIT: Here is source code executed in one such C++ system, Freescale HCS08 Codewarrior 6.3. This code is injected in the user program after static initialization, but before main() is executed:

static void Call_Constructors(void) {
  int i;
  ...
  i = (int)(_startupData.nofInitBodies - 1);
  while (i >= 0) {
    (&_startupData.initBodies->initFunc)[i]();  /* call C++ constructors */
    i--;
  }
  ...

At the very least, this overhead code must be executed at program startup, no matter how efficient the compiler is at converting constructors into static initializtion.

C++ runtime start-up differs slightly from C start-up because it must invoke the constructors for global static objects before main() is called. This call loop is trivial and should not add much.

In the case of C++ code that is also entirely C compilable no static constructors will be present so the loop will not iterate.

In most cases apart from that, you will normally see no significant difference, in C++ you only pay for what you use.