Is C99 backward compatible with C89?_问答_开发者

I'm used to old-style C and and have just recently started to explore c99 features. I've just one question: Will my program compile successfully if I use c99 in my program, the c99 flag with gcc and link it with prior c99 libraries?

So, should I stick to old C开发者_JAVA技巧89 or evolve?

I believe that they are compatible in that respect. That is as long as the stuff that you are compiling against doesn't step on any of the new goodies. For instance, if the old code contains enum bool { false, true }; then you are in trouble. As a similar dinosaur, I am slowly embracing the wonderful new world of C99. After all, it has only been out there lurking for about 10 years now ;)

You should evolve. Thanks for listening :-)

Actually, I'll expand on that.

You're right that C99 has been around for quite a while. You should (in my opinion) be using that standard for anything other than legacy code (where you just fix bugs rather than add new features). It's probably not worth it for legacy code but you should (as with all business decisions) do your own cost/benefit analysis.

I'm already ensuring my new code is compatible with C1x - while I'm not using any of the new features yet, I try to make sure it won't break.

As to what code to look out for, the authors of the standards take backward compatibility very seriously. Their job was not ever to design a new language, it was to codify existing practices.

The phase they're in at the moment allows them some more latitude in updating the language but they still follow the Hippocratic oath in terms of their output: "first of all, do no harm".

Generally, if your code is broken with a new standard, the compiler is forced to tell you. So simply compiling your code base will be an excellent start. However, if you read the C99 rationale document, you'll see the phrase "quiet change" appear - this is what you need to watch out for.

These are behavioral changes in the compiler that you don't need to be informed about and may be the source of much angst and gnashing of teeth if your application starts acting strange. Don't worry about the "quiet change in c89" bits - if they were a problerm, you would have already been bitten by them.

That document, by the way, is an excellent read to understand why the actual standard says what it says.

Some C89 features are not valid C99

Arguably, those features exist only for historical reasons, and should not be used in modern C89 code, but they do exist.

The C99 N1256 standard draft foreword paragraph 5 compares C99 to older revisions, and is a good place to start searching for those incompatibilities, even though it has by far more extensions than restrictions.

Implicit int return and variable types

Mentioned by Lutz in a comment, e.g. the following are valid C89:

static i;
f() { return 1; }

but not C99, in which you have to write:

static int i;
int f() { return 1; }

This also precludes calling functions without prototypes in C99: Are prototypes required for all functions in C89, C90 or C99?

n1256 says:

remove implicit int

Return without expression for non void function

Valid C89, invalid C99:

int f() { return; }

I think in C89 it returns an implementation defined value. n1256 says:

return without expression not permitted in function that returns a value

Integer division with negative operand

C89: rounds to an implementation defined direction
C99: rounds to 0

So if your compiler rounded to -inf, and you relied on that implementation defined behavior, your compiler is now forced to break your code on C99.

https://stackoverflow.com/a/3604984/895245

n1256 says:

reliable integer division

Windows compatibility

One major practical concern is being able to compile in Windows, since Microsoft does not intend to implement C99 fully too soon.

This is for example why libgit2 limits allowed C99 features.

Respectfully: Try it and find out. :-)

Though, keep in mind that even if you need to fix a few minior compiling differences, moving up is probably worth it.

If you don't violate the explicit C99 features,a c90 code will work fine c99 flag with another prior c99 libraries.

But there are some dos based libraries in C89 like ,, that will certainly not work.

C99 is much flexible so feel free to migrate :-)

The calling conventions between C libraries hasn't changed in ages, and in fact, I'm not sure it ever has.

Operating systems at this point rely heavily on the C calling conventions since the C APIs tend to be the glue between the pieces of the OS.

So, basically the answer is "Yes, the binaries will be backwards compatible. No, naturally, code using C99 features can't later be compiled with a non-C99 compiler."

It's intended to be backwards compatible. It formalizes extensions that many vendors have already implemented. It's possible, maybe even probable, that a well written program won't have any issues when compiling with C99.

In my experience, recompiling some modules and not others to save time... wastes a lot of time. Usually there is some easily overlooked detail that needs the new compiler to make it all compatible.

There are a few parts of the C89 Standard which are ambiguously written, and depending upon how one interprets the rule about types of pointers and the objects they're accessing, the Standard may be viewed as describing one of two very different languages--one of which is semantically much more powerful and consequently usable in a wider range of fields, and one of which allows more opportunities for compiler-based optimization. The C99 Standard "clarified" the rule to make clear that it makes no effort to mandate compatibility with the former language, even though it was overwhelmingly favored in many fields; it also treats as undefined some things that were defined in C89 but only because the C89 rules weren't written precisely enough to forbid them (e.g. the use of memcpy for type punning in cases where the destination has heap duration).

C99 may thus be compatible with the language that its authors thought was described by C89, but is not compatible with the language that was processed by most C89 compilers throughout the 1990s.