c99

I'd like to use the C99 header file inttypes.h in a Visual Studio project (I'd like to printf 64 bit numbers). However, this file does not seem to exist in my install. Is this just not part of VS2005? Are there any alternatives? It's at google . VS doesn't come with <inttypes.h> No, it is not included in VS 2005. An alternative is Boost's implementation in the Boost::Integer library, specifically boost/cstdint.hpp For Visual Studio 2005 see the bug "C99 header <inttypes.h> missing" at http://connect.microsoft.com/VisualStudio/feedback/details/99133/c99-header-inttypes-h-missing#details where

§5.2.4.2.1 of C99 defines SCHAR_MIN as -127 and SCHAR_MAX as 127. Should not the range for an 8 bit signed integer be -128 to +127? The limits.h for my compiler defines SCHAR_MIN as (-1 << ((CHAR_BIT)-1)) , which is -128 given CHAR_BIT is 8. Is there any reason why SCHAR_MIN was defined -127 and not -128 ? It doesn't actually define SCHAR_MIN as -127, it defines the minimum range of signed characters to -127..127. It does this because it has to be able to handle the other two encoding schemes for signed numbers, those being ones' complement and sign/magnitude. Both of these have a positive and

I'm trying to generate a function declaration using a macro /* goal: generate int f(int a, float b) */ template<typename P> struct ptype; template<typename P> struct ptype<void(P)> { typedef P type; }; #define NAMEe #define COMMAe #define COMMA , #define NAME(N) N PARAMS #define PARAMS(P, ...) COMMA ## __VA_ARGS__ P NAME ## __VA_ARGS__ #define PARAM_ITER(P) P NAME #define PROTO(R, N, P) \ ptype<void R>::type N (PARAM_ITER P (,e)) PROTO((int), f, (int)(a)(float)(b)); It will iteratively process the next (name) or (type) by NAME or PARAMS respectively, with the ... having an empty macro argument

This is C99 code: typedef struct expr_t { int n_children; foo data; // Maybe whatever type with unknown alignment struct expr_t *children[]; } expr_t; Now, how do I allocate memory ? expr_t *e = malloc (sizeof (expr_t) + n * sizeof (expr_t *)); or expr_t *e = malloc (offsetof (expr_t, children) + n * sizeof (expr_t *)); ? Is sizeof even guaranteed to work on an type with flexible array member (GCC accepts it) ? CrazyCasta expr_t *e = malloc (sizeof (expr_t) + n * sizeof (expr_t *)); is well defined in C99. From the C99 specification 6.7.2.1.16: As a special case, the last element of a

In C99, the term arithmetic operation appears 16 times, but I don't see a definition for it. The term arithmetic operator only appears twice in the text (again without definition) but it does appear in the Index: arithmetic operators additive, 6.5.6, G.5.2 bitwise, 6.5.10, 6.5.11, 6.5.12 increment and decrement, 6.5.2.4, 6.5.3.1 multiplicative 6.5.5, G.5.1 shift, 6.5.7 unary, 6.5.3.3 Then we have + - | & (binary) ++ -- * (binary) / % << >> ~ as arithmetic operators, if the Index is considered normative! Perhaps we should identify arithmetic operation as being the use of an arithmetic operator.

This question is almost a duplicate of some others I've found, but this specifically concerns POSIX, and a very common example in pthreads that I've encountered several times. I'm mostly concerned with the current state of affairs (i.e., C99 and POSIX.1-2008 or later), but any interesting historical information is of course interesting as well. The question basically boils down to whether b will always take the same value as a in the following code: long int a = /* some valid value */ void *ptr = (void *)a; long int b = (long int)ptr; I am aware that this usually works, but the question is

From the C99 standard, 6.7(5): A declaration specifies the interpretation and attributes of a set of identifiers. A definition of an identifier is a declaration for that identifier that: for an object, causes storage to be reserved for that object; for a function, includes the function body; for an enumeration constant or typedef name, is the (only) declaration of the identifier. If identifiers with typedef are in fact definitions, then why are they allowed to be declared more than once? Example: int main() { typedef int x; typedef int x; } Above program compiles with no errors. How is this

The C standard specifies two forms of definition for main for a hosted implementation: int main(void) { /* ... */ } and int main(int argc, char *argv[]) { /* ... */ } It may be defined in ways that are "equivalent" to the above (for example, you can change the parameter names, replace int by a typedef name defined as int , or write char *argv[] as char **argv ). It may also be defined "in some other implementation-defined manner" -- which means that things like int main(int argc, char *argv[], char *envp) are valid if the implementation documents them. The "in some other implementation-defined