c99

After reading about VA_NARG I tried to implement function overloading depending on number of arguments in C using macros. Now the problem is: void hello1(char *s) { ... } void hello2(char *s, char *t) { ... } // PP_NARG(...) macro returns number of arguments :ref to link above // does not work #define hello(...) hello ## PP_NARG(__VA_ARGS__) int main(void) { hello("hi"); // call hello1("hi"); hello("foo","bar"); // call hello2("foo","bar"); return 0; } I've read this from C-faq. But still could not get it to work... Jens Gustedt This is because of the evaluation rules for macros. You would

C99 states integer types like uint32_t, int16_t etc, where it's easy to see the number of bits used. Good to know in for instance embedded programming. I have not found any similar types for floating point values. Is there a standard? If not, why? Kwariz I found the answer in Any guaranteed minimum sizes for types in C? Quoting Jed Smith (with corrected link to C99 standard): Yes, the values in float.h and limits.h are system dependent. You should never make assumptions about the width of a type, but the standard does lay down some minimums. See §6.2.5 and §5.2.4.2.1 in the C99 standard . For

I have this code which works: #include <stdio.h> #define A(x) x B #define B(x) C(x, #define C(x,y) y x) int main( void ) { printf( A("1") ("2") "3" ); } It prints 132 (the point of the A macro is to swap the thing which follows its parameters in brackets with everything after that until another closing bracket) But if I use that within another macro: #define Z(x) x printf( Z( A("1") ("2") "3" ) ); I get the compile error "Unterminated function-like macro invocation". I realise that this happens because the compiler is trying to process the arguments of Z independently, but I need to use its

Apparently (at least according to gcc -std=c99 ) C99 doesn't support function overloading. The reason for not supporting some new feature in C is usually backward compatibility, but in this case I can't think of a single case in which function overloading would break backward compatibility. What is the reasoning behind not including this basic feature? SingleNegationElimination To understand why you aren't likely to see overloading in C, it might help to better learn how overloading is handled by C++. After compiling code, but before it is ready to run, the intermediate object code must be

I just read: C Wikipedia entry . As far as I know there are 3 different versions of C that are widely used: C89, C99 and C11. My question concerns the compatibility of source code of different versions. Suppose I am going to write a program (in C11 since it is the latest version) and import a library written in C89. Are these two versions going to work together properly when compiling all files according to the C11 specification? Question 1 : Are the newer versions of C i.e. C99, C11 supersets of older C versions? By superset I mean, that old code will compile without errors and the same

A response to a comment I made here made me stop and think: "I don't really know what the state of C99 support is." Wikipedia gives details for a few compilers, but I'm not familiar enough with C99 to know all the bits and pieces of the standard, so I'm looking for a gestalt overview answer to the question: What is the state of C99 support in major compilers / toolchains? MSVC: Intentionally not implemented unless it overlaps with C++ GCC: Most of the useful parts are in (and have been for awhile). Some missing features. clang: Claims full C99 support 来源： https://stackoverflow.com/questions

I was coding on my project when I discovered that the anonymous structs I've been using for a while are actually only available in C11, not C99, the standard I want to code against. Given the following code: struct data { int a; struct { int b; int c; }; }; int main() { struct data d; d.a = 0; d.b = 1; d.c = 2; return 0; } This code should only compile in C11 (or if compiler extensions provide this feature and are enabled). So let's see the results on different compilers: clang 5 compiler: Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn) Target: x86_64-apple-darwin13.1.0 Thread