size-t

Which type in C should be used to represent the difference between two objects' sizes? As size_t is unsigned, something like size_t diff = sizeof (small_struct) - sizeof (big_struct); obviously wouldn't be correct and it seems to me there's no real signed equivalent. ptrdiff_t sounds kind of tempting, but like its name says it's for subtracting pointers. I've read that e.g. segmented platforms like DOS have a maximal object size of 64k which is representable by 16-bit. Far pointers, however, are composed of a 16-bit segment value and a 16-bit offset value. Wouldn't that make ptrdiff_t on such

sizeof is a C keyword . It returns the size in a type named size_t . However, size_t is not a keyword, but is defined primarily in stddef.h and probably other C standard header files too. Consider a scenario where you want to create a C program which does not include any C standard headers or libraries. (Like for example, if you are creating an OS kernel.) Now, in such code, sizeof can be used (it is a C keyword, so it is a part of the language ), but the type that it returns ( size_t ) is not available! Does not this signify some kind of a problem in the C standard specification? Can you

In this question I see following: for (vector<int>::size_type ix = 0; ix ! = ivec.size(); ++ix) { ivec[ix] = 0; } I understand that why int is not used here, but why not just use size_t ? Under what circumstances I should use vector<int>::size_type instead of size_t ? The primary time to use size_type is in a template. Although std::vector<T>::size_type is usually size_t , some_other_container<T>::size_type might be some other type instead 1 . One of the few things a user is allowed to add to the std namespace is a specialization of an existing template for some user defined type. Therefore,

What are the differences between size_t and std::size_t in terms of where they are declared, when they should be used and any other differentiating features? Nawaz C's size_t and C++'s std::size_t are both same. In C, it's defined in <stddef.h> and in C++, its defined in <cstddef> whose contents are the same as C header (see the quotation below). Its defined as unsigned integer type of the result of the sizeof operator. C Standard says in §17.7/2, size_t which is the unsigned integer type of the result of the sizeof operator And C++ Standard says (about cstddef header) in §18.1/3, The contents

I have some C++ code that prints a size_t : size_t a; printf("%lu", a); I'd like this to compile without warnings on both 32- and 64-bit architectures. If this were C99, I could use printf("%z", a); . But AFAICT %z doesn't exist in any standard C++ dialect. So instead, I have to do printf("%lu", (unsigned long) a); which is really ugly. If there's no facility for printing size_t s built into the language, I wonder if it's possible to write a printf wrapper or somesuch such that will insert the appropriate casts on size_t s so as to eliminate spurious compiler warnings while still maintaining

I'm dealing with some code at work that includes an expression of the form -(sizeof(struct foo)) i.e. the negation of a size_t , and I'm unclear on what the C and C++ standards require of compilers when they see this. Specifically, from looking around here and elsewhere, sizeof returns an unsigned integral value of type size_t . I can't find any clear reference for specified behavior when negating an unsigned integer. Is there any, and if so, what is it? Edit: Ok, so there are some good answers regarding arithmetic on unsigned types, but it's not clear that this is in fact such. When this