stdint

I'm developing a module for using c inline in Python code based on swig . For that I would like to make numpy arrays accessible in C . Until now I used C types like unsigned short but I would like to use types like uint16_t from stdint.h to be save whatever compiler my module encounters. Unfortunately the c++ -functions do not get wrapped correctly when using stdint.h types. The Error given is: _setc() takes exactly 2 arguments (1 given) . That means, the function is not wrapped to accept numpy arrays. The error does not occur, when I use e.g. unsigned short . Do you have any ideas, how I can

I have ever read that int32_t is exact 32 bits long and int_least32_t only at least 32 bits, but they have both the same typedefs in my stdint.h: typedef int int_least32_t; and typedef int int32_t; So where is the difference? They exactly the same... int32_t is signed integer type with width of exactly 32 bits with no padding bits and using 2's complement for negative values. int_least32_t is smallest signed integer type with width of at least 32 bits. These are provided only if the implementation directly supports the type. The typedefs that you are seeing simply means that in your

Where is ptrdiff_t defined in C? If non-trivial, how can I make this type visible from GCC on Linux? It's defined in stddef.h . That header defines the integral types size_t , ptrdiff_t , and wchar_t , the functional macro offsetof , and the constant macro NULL . It is defined by the POSIX standard: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stddef.h.html Where the type is exactly may be implemetation-specific, but interface is stddef.h Since @Good Person said this wasn't specific to Linux, in Microsoft Visual Studio, ptrdiff_t is defined in: C:\Program Files (x86)\Microsoft

I saw different types of definition of an integer in stdint.h . I'll take unsigned 32-bit integer as an example. uint32_t means clearly an unsigned integer of 32 bits. That's the one I always use. uint_fast32_t and uint_least32_t : What's the difference with uint32_t and when should I use them instead of uint32_t ? And now, I saw uintX_t where X is 24, 40, 48 and 56. It happens in my code that I have to work with 48 and 56-bit integers. As an example, I suppose uint24_t is define as something like this : struct uint24_t { unsigned int the_integer : 24; }; Am I right ? And, Will you suggest me

The stdint.h header lacks an int_fastest_t and uint_fastest_t to correspond with the {,u}int_fastX_t types. For instances where the width of the integer type does not matter, how does one pick the integer type that allows processing the greatest quantity of bits with the least penalty to performance? For example, if one was searching for the first set bit in a buffer using a naive approach, a loop such as this might be considered: // return the bit offset of the first 1 bit size_t find_first_bit_set(void const *const buf) { uint_fastest_t const *p = buf; // use the fastest type for comparison

Possible Duplicate: Visual Studio support for new C / C++ standards? See the text below from wiki : The C99 standard includes definitions of several new integer types to enhance the portability of programs[2]. The already available basic integer types were deemed insufficient, because their actual sizes are implementation defined and may vary across different systems. The new types are especially useful in embedded environments where hardware supports usually only several types and that support varies from system to system. All new types are defined in inttypes.h header (cinttypes header in C+