When to use std size t

Question

I m just wondering should I use std  size t for loops and stuff instead of int  For instance    include  lt cstdint   int main         for  std  size t i   0  i  lt  10    i               std  size t OK here  Or should I use  say  unsigned int instead           In general  what is the best practice regarding when to use std  size t

User · Accepted Answer

A good rule of thumb is for anything that you need to compare in the loop condition against something that is naturally a std::size_t itself.

std::size_t is the type of any sizeof expression and as is guaranteed to be able to express the maximum size of any object (including any array) in C++. By extension it is also guaranteed to be big enough for any array index so it is a natural type for a loop by index over an array.

If you are just counting up to a number then it may be more natural to use either the type of the variable that holds that number or an int or unsigned int (if large enough) as these should be a natural size for the machine.

User · Answer

By definition  size t is the result of the sizeof operator  size t was created to refer to sizes   The number of times you do something  10  in your example  is not about sizes  so why use size t  int  or unsigned int  should be ok   Of course it is also relevant what you do with i inside the loop  If you pass it to a function which takes an unsigned int  for example  pick unsigned int   In any case  I recommend to avoid implicit type conversions  Make all type conversions explicit

User · Answer

Soon most computers will be 64-bit architectures with 64-bit OS es running programs operating on containers of billions of elements  Then you must use size t instead of int as loop index  otherwise your index will wrap around at the 2 32 th element  on both 32- and 64-bit systems   Prepare for the future

User · Answer

short answer   almost never  long answer   Whenever you need to have a vector of char bigger that 2gb on a 32 bit system  In every other use case  using a signed type is much safer than using an unsigned type    example   std  vector lt A gt  data           calculate the index that should be used  size t i   calc index param1  param2      doing calculations close to the underflow of an integer is already dangerous     do some bounds checking if  i - 1  lt  0            always false  because 0-1 on unsigned creates an underflow     return LEFT BORDER    else if  i  gt   data size   - 1            if i already had an underflow  this becomes true     return RIGHT BORDER        now you have a bug that is very hard to track  because you never     get an exception or anything anymore  to detect that you actually     return the false border case   return calc something data i-1   data i   data i 1      The signed equivalent of size t is ptrdiff t  not int  But using int is still much better in most cases than size t  ptrdiff t is long on 32 and 64 bit systems   This means that you always have to convert to and from size t whenever you interact with a std  containers  which not very beautiful  But on a going native conference the authors of c   mentioned that designing std  vector with an unsigned size t was a mistake   If your compiler gives you warnings on implicit conversions from ptrdiff t to size t  you can make it explicit with constructor syntax   calc something data size t i-1    data size t i    data size t i 1       if just want to iterate a collection  without bounds cheking  use range based for   for const auto amp  d   data                  here some words from Bjarne Stroustrup  C   author  at going native  For some people this signed unsigned design error in the STL is reason enough  to not use the std  vector  but instead an own implementation

User · Answer

size t is a very readable way to specify the size dimension of an item - length of a string  amount of bytes a pointer takes  etc  It s also portable across platforms - you ll find that 64bit and 32bit both behave nicely with system functions and size t - something that unsigned int might not do  e g  when should you use unsigned long

User · Answer

size t is returned by various libraries to indicate that the size of that container is non-zero  You use it when you get once back  0  However  in the your example above looping on a size t is a potential bug  Consider the following   for  size t i   thing size    i  gt   0  --i         this will never terminate because size t is a typedef for      unsigned int which can not be negative by definition      therefore i will always be  gt   0   printf  the never ending story  la la la la        the use of unsigned integers has the potential to create these types of subtle issues  Therefore imho I prefer to use size t only when I interact with containers types that require it

User · Answer

Use std  size t for indexing counting C-style arrays   For STL containers  you ll have  for example  vector lt int gt   size type  which should be used for indexing and counting vector elements   In practice  they are usually both unsigned ints  but it isn t guaranteed  especially when using custom allocators

User · Answer

size t is an unsigned integral type  that can represent the largest integer on you system  Only use it if you need very large arrays matrices etc   Some functions return an size t and your compiler will warn you if you try to do comparisons   Avoid that by using a the appropriate signed unsigned datatype or simply typecast for a fast hack

User · Answer

size t is an unsigned type that can hold maximum integer value for your architecture  so it is protected from integer overflows due to sign  signed int 0x7FFFFFFF incremented by 1 will give you -1   or short size  unsigned short int 0xFFFF incremented by 1 will give you 0    It is mainly used in array indexing loops address arithmetic and so on  Functions like memset   and alike accept size t only  because theoretically you may have a block of memory of size 2 32-1  on 32bit platform    For such simple loops don t bother and use just int

User · Answer

When using size t be careful with the following expression  size t i   containner find  mytoken    size t x   99  if  i-x gt -1  amp  amp  i x  lt  containner size          cout  lt  lt  containner i-x   lt  lt       lt  lt  containner i x   lt  lt  endl      You will get false in the if expression regardless of what value you have for x  It took me several days to realize this  the code is so simple that I did not do unit test   although it only take a few minutes to figure the source of the problem  Not sure it is better to do a cast or use zero   if   int  i-x   gt  -1 or  i-x   gt   0    Both ways should work  Here is my test run  size t i   5  cerr  lt  lt   i-7    lt  lt  i-7  lt  lt     int  i-7     lt  lt   int  i-7   lt  lt  endl    The output  i-7 18446744073709551614  int  i-7  -2  I would like other s comments

User · Answer

size t is unsigned int  so whenever you want unsigned int you can use it   I use it when i want to specify size of the array   counter ect     void   operator new  size t size   is a good use of it

User · Answer

size t is the result type of the sizeof operator   Use size t for variables that model size or index in an array  size t conveys semantics  you immediately know it represents a size in bytes or an index  rather than just another integer   Also  using size t to represent a size in bytes helps making the code portable

User · Answer

The size t type is meant to specify the size of something so it s natural to use it  for example  getting the length of a string and then processing each character   for  size t i   0  max   strlen  str   i  lt  max  i        doSomethingWith  str i      You do have to watch out for boundary conditions of course  since it s an unsigned type  The boundary at the top end is not usually that important since the maximum is usually large  though it is possible to get there   Most people just use an int for that sort of thing because they rarely have structures or arrays that get big enough to exceed the capacity of that int   But watch out for things like   for  size t i   strlen  str  - 1  i  gt   0  i--    which will cause an infinite loop due to the wrapping behaviour of unsigned values  although I ve seen compilers warn against this   This can also be alleviated by the  slightly harder to understand but at least immune to wrapping problems    for  size t i   strlen  str   i--  gt  0      By shifting the decrement into a post-check side-effect of the continuation condition  this does the check for continuation on the value before decrement  but still uses the decremented value inside the loop  which is why the loop runs from len    1 rather than len-1    0

[c++] When to use std::size_t?

Examples related to c++

Examples related to types

Examples related to idioms

Examples related to size-t

Examples related to loop-counter