size-t

I'd like to know the maximum value of size_t on the system my program is running. My first instinct was to use negative 1, like so: size_t max_size = (size_t)-1; But I'm guessing there's a better way, or a constant defined somewhere. A manifest constant (a macro) exists in C99 and it is called SIZE_MAX . There's no such constant in C89/90 though. However, what you have in your original post is a perfectly portable method of finding the maximum value of size_t . It is guaranteed to work with any unsigned type. #define MAZ_SZ (~(size_t)0) or SIZE_MAX As an alternative to bit-operations suggested

I am using the mingw-w64 (x64) fork of minGW as prepared on nuwen.net. This is from the 7.1 version of gcc : gcc --version gcc (GCC) 7.1.0 I am compiling this program: #include <stdio.h> int main(void) { size_t a = 100; printf("a=%lu\n",a); printf("a=%llu\n",a); printf("a=%zu\n",a); printf("a=%I64u\n",a); } with warnings and c11 standard: gcc -Wall -Wextra -Wpedantic -std=c11 test_size_t.c and I get these warnings: test_size_t.c: In function 'main': test_size_t.c:6:14: warning: format '%lu' expects argument of type 'long unsigned int', but argument 2 has type 'size_t {aka long long unsigned

On a cross platform c/c++ project (Win32, Linux, OSX), I need to use the *printf functions to print some variables of type size_t. In some environments size_t's are 8 bytes and on others they are 4. On glibc I have %zd, and on Win32 I can use %Id . Is there an elegant way to handle this? finnw The PRIuPTR macro (from <inttypes.h>) defines a decimal format for uintptr_t , which should always be large enough that you can cast a size_t to it without truncating, e.g. fprintf(stream, "Your size_t var has value %" PRIuPTR ".", (uintptr_t) your_var); There are really two questions here. The first

On a 64-bit system, sizeof(unsigned long) depends on the data model implemented by the system, for example, it is 4 bytes on LLP64 (Windows), 8 bytes on LP64 (Linux, etc.). What's sizeof(size_t) supposed to be? Does it vary with data model like sizeof(long) does? If so, how? References: 64-bit data models on Wikipedia size_t is defined by the C standard to be the unsigned integer return type of the sizeof operator (C99 6.3.5.4.4), and the argument of malloc and friends (C99 7.20.3.3 etc). The actual range is set such that the maximum (SIZE_MAX) is at least 65535 (C99 7.18.3.2). However, this

I'm under the same impression as this answer , that size_t is always guaranteed by the standard to be large enough to hold the largest possible type of a given system. However, this code fails to compile on gcc/Mingw: #include <stdint.h> #include <stddef.h> typedef uint8_t array_t [SIZE_MAX]; error: size of array 'array_t' is too large Am I misunderstanding something in the standard here? Is size_t allowed to be too large for a given implementation? Or is this another bug in Mingw? EDIT: further research shows that typedef uint8_t array_t [SIZE_MAX/2]; // does compile typedef uint8_t array_t

In some code I've inherited, I see frequent use of size_t with the std namespace qualifier. For example: std::size_t n = sizeof( long ); It compiles and runs fine, of course. But it seems like bad practice to me (perhaps carried over from C?). Isn't it true that size_t is built into C++ and therefore in the global namespace? Is a header file include needed to use size_t in C++? Another way to ask this question is, would the following program (with no includes) be expected to compile on all C++ compilers? size_t foo() { return sizeof( long ); } There seems to be confusion among the