Initialization of all elements of an array to one default value in C

Question

C   Notes  Array Initialization has a nice list over initialization of arrays  I have a  int array 100     -1     expecting it to be full with -1 s but its not  only first value is and the rest are 0 s mixed with random values   The code  int array 100     0     works just fine and sets each element to 0   What am I missing here   Can t one initialize it if the value isn t zero    And 2  Is the default initialization  as above  faster than the usual loop through the whole array and assign a value or does it do the same thing

User · Answer

For the case of an array of single-byte elements  you can use memset to set all elements to the same value   There s an example here

User · Answer

1  When you use an initializer  for a struct or an array like that  the unspecified values are essentially default constructed   In the case of a primitive type like ints  that means they will be zeroed   Note that this applies recursively  you could have an array of structs containing arrays and if you specify just the first field of the first struct  then all the rest will be initialized with zeros and default constructors   2  The compiler will probably generate initializer code that is at least as good as you could do by hand   I tend to prefer to let the compiler do the initialization for me  when possible

User · Answer

Using std  array  we can do this in a fairly straightforward way in C  14  It is possible to do in C  11 only  but slightly more complicated   Our interface is a compile-time size and a default value   template lt typename T gt  constexpr auto make array n std  integral constant lt std  size t  0 gt   T  amp  amp         return std  array lt std  decay t lt T gt   0 gt        template lt std  size t size  typename T gt  constexpr auto make array n std  integral constant lt std  size t  size gt   T  amp  amp  value        return detail  make array n impl lt size gt  std  forward lt T gt  value   std  make index sequence lt size - 1 gt          template lt std  size t size  typename T gt  constexpr auto make array n T  amp  amp  value        return make array n std  integral constant lt std  size t  size gt     std  forward lt T gt  value        The third function is mainly for convenience  so the user does not have to construct a std  integral constant lt std  size t  size gt  themselves  as that is a pretty wordy construction  The real work is done by one of the first two functions   The first overload is pretty straightforward  It constructs a std  array of size 0  There is no copying necessary  we just construct it   The second overload is a little trickier  It forwards along the value it got as the source  and it also constructs an instance of make index sequence and just calls some other implementation function  What does that function look like   namespace detail    template lt std  size t size  typename T  std  size t    indexes gt  constexpr auto make array n impl T  amp  amp  value  std  index sequence lt indexes    gt            Use the comma operator to expand the variadic pack        Move the last element in if possible  Order of evaluation is well-defined        for aggregate initialization  so there is no risk of copy-after-move     return std  array lt std  decay t lt T gt   size gt    static cast lt void gt  indexes   value      std  forward lt T gt  value               namespace detail   This constructs the first size - 1 arguments by copying the value we passed in  Here  we use our variadic parameter pack indexes just as something to expand  There are size - 1 entries in that pack  as we specified in the construction of make index sequence   and they have values of 0  1  2  3       size - 2  However  we do not care about the values  so we cast it to void  to silence any compiler warnings   Parameter pack expansion expands out our code to something like this  assuming size    4    return std  array lt std  decay t lt T gt   4 gt    static cast lt void gt  0   value    static cast lt void gt  1   value    static cast lt void gt  2   value   std  forward lt T gt  value       We use those parentheses to ensure that the variadic pack expansion     expands what we want  and also to ensure we are using the comma operator  Without the parentheses  it would look like we are passing a bunch of arguments to our array initialization  but really  we are evaluating the index  casting it to void  ignoring that void result  and then returning value  which is copied into the array   The final argument  the one we call std  forward on  is a minor optimization  If someone passes in a temporary std  string and says  make an array of 5 of these   we would like to have 4 copies and 1 move  instead of 5 copies  The std  forward ensures that we do this   The full code  including headers and some unit tests    include  lt array gt   include  lt type traits gt   include  lt utility gt   namespace detail    template lt std  size t size  typename T  std  size t    indexes gt  constexpr auto make array n impl T  amp  amp  value  std  index sequence lt indexes    gt            Use the comma operator to expand the variadic pack        Move the last element in if possible  Order of evaluation is well-defined        for aggregate initialization  so there is no risk of copy-after-move     return std  array lt std  decay t lt T gt   size gt    static cast lt void gt  indexes   value      std  forward lt T gt  value               namespace detail  template lt typename T gt  constexpr auto make array n std  integral constant lt std  size t  0 gt   T  amp  amp         return std  array lt std  decay t lt T gt   0 gt        template lt std  size t size  typename T gt  constexpr auto make array n std  integral constant lt std  size t  size gt   T  amp  amp  value        return detail  make array n impl lt size gt  std  forward lt T gt  value   std  make index sequence lt size - 1 gt         template lt std  size t size  typename T gt  constexpr auto make array n T  amp  amp  value        return make array n std  integral constant lt std  size t  size gt     std  forward lt T gt  value         struct non copyable       constexpr non copyable     default      constexpr non copyable non copyable const  amp     delete      constexpr non copyable non copyable  amp  amp     default      int main         constexpr auto array n   make array n lt 6 gt  5       static assert std  is same lt std  decay t lt decltype array n  gt   value type  int gt   value   Incorrect type from make array n         static assert array n size      6   Incorrect size from make array n         static assert array n 3     5   Incorrect values from make array n          constexpr auto array non copyable   make array n lt 1 gt  non copyable         static assert array non copyable size      1   Incorrect array size of 1 for move-only types          constexpr auto array empty   make array n lt 0 gt  2       static assert array empty empty     Incorrect array size for empty array          constexpr auto array non copyable empty   make array n lt 0 gt  non copyable         static assert array non copyable empty empty     Incorrect array size for empty array of move-only

User · Answer

Using the syntax that you used   int array 100     -1     says  set the first element to -1 and the rest to 0  since all omitted elements are set to 0   In C    to set them all to -1  you can use something like std  fill n  from  lt algorithm gt     std  fill n array  100  -1     In portable C  you have to roll your own loop  There are compiler-extensions or you can depend on implementation-defined behavior as a shortcut if that s acceptable

User · Answer

There is an extension to the gcc compiler which allows the syntax   int array 100       0     99    -1      This would set all of the elements to -1   This is known as  Designated Initializers  see here for further information   Note this isn t implemented for the gcc c   compiler

User · Answer

Should be a standard feature but for some reason it s not included in standard C nor C         include  lt stdio h gt      asm            global  arr               section  data         arr   fill 100  1  2         extern char arr     int main          int i       for i   0  i  lt  100    i            printf  arr  u     u  n   i  arr i              In Fortran you could do   program main     implicit none      byte a 100      data a  100 2      integer i      do i   0  100         print    a i      end do end   but it does not have unsigned numbers     Why can t C C   just implement it  Is it really so hard  It s so silly to have to write this manually to achieve the same result      include  lt stdio h gt   include  lt stdint h gt      did I count it correctly  I m not quite sure     uint8 t arr         2  2  2  2  2  2  2  2  2  2      2  2  2  2  2  2  2  2  2  2      2  2  2  2  2  2  2  2  2  2      2  2  2  2  2  2  2  2  2  2      2  2  2  2  2  2  2  2  2  2      2  2  2  2  2  2  2  2  2  2      2  2  2  2  2  2  2  2  2  2      2  2  2  2  2  2  2  2  2  2      2  2  2  2  2  2  2  2  2  2      2  2  2  2  2  2  2  2  2  2          int main          int i       for i   0  i  lt  100    i            printf  arr  u     u  n   i  arr i              What if it was an array of 1 000 00 bytes  I d need to write a script to write it for me  or resort to hacks with assembly etc  This is nonsense   It s perfectly portable  there s no reason for it not to be in the language   Just hack it in like    include  lt stdio h gt   include  lt stdint h gt      a byte array of 100 twos declared at compile time     uint8 t twos      100 2    int main         uint fast32 t i      for  i   0  i  lt  100    i            printf  twos  u     u  n   i  twos i               return 0      One way to hack it in is via preprocessing     Code below does not cover edge cases  but is written to quickly demonstrate what could be done       usr bin perl use warnings  use strict   open my  inf    lt main c   open my  ouf    gt out c    my  lines    lt  inf gt    foreach my  line   lines        if   line    m     d     d                 printf    1   2   3                    my  lnew           3   x  2 - 1     3                 line    s    d   d     lnew           printf  ouf  line        else           printf  ouf  line           close  ouf   close  inf

User · Answer

In C    it is also possible to use meta programming and variadic templates  The following post shows how to do it  Programmatically create static arrays at compile time in C

User · Answer

With    you assign the elements as they are declared  the rest is initialized with 0   If there is no      to initalize  the content is undefined

User · Answer

C  11 has another  imperfect  option   std  array lt int  100 gt  a  a fill -1

User · Answer

The page you linked states     If an explicit array size is specified  but an shorter initiliazation list is specified  the unspecified elements are set to zero    Speed issue  Any differences would be negligible for arrays this small  If you work with large arrays and speed is much more important than size  you can have a const array of the default values  initialized at compile time  and then memcpy them to the modifiable array

User · Answer

In the C   programming language V4  Stroustrup recommends using vectors or valarrays over builtin arrays   With valarrary s  when you create them  you can init them to a specific value like   valarray  lt int gt seven7s  7777777 7     To initialize an array 7 members long with  7777777    This is a C   way of implementing the answer using a C   data structure instead of a  plain old C  array   I switched to using the valarray as an attempt in my code to try to use C   isms v  C isms

User · Answer

The page you linked to already gave the answer to the first part      If an explicit array size is   specified  but an shorter   initiliazation list is specified  the   unspecified elements are set to zero    There is no built-in way to initialize the entire array to some non-zero value   As for which is faster  the usual rule applies   The method that gives the compiler the most freedom is probably faster    int array 100     0     simply tells the compiler  set these 100 ints to zero   which the compiler can optimize freely   for  int i   0  i  lt  100    i     array i    0      is a lot more specific  It tells the compiler to create an iteration variable i  it tells it the order in which the elements should be initialized  and so on  Of course  the compiler is likely to optimize that away  but the point is that here you are overspecifying the problem  forcing the compiler to work harder to get to the same result   Finally  if you want to set the array to a non-zero value  you should  in C    at least  use std  fill   std  fill array  array 100  42      sets every value in the array to 42   Again  you could do the same with an array  but this is more concise  and gives the compiler more freedom  You re just saying that you want the entire array filled with the value 42  You don t say anything about in which order it should be done  or anything else

User · Answer

Another way of initializing the array to a common value  would be to actually generate the list of elements in a series of defines    define DUP1  X     X    define DUP2  X   DUP1  X      X    define DUP3  X   DUP2  X      X    define DUP4  X   DUP3  X      X    define DUP5  X   DUP4  X      X        define DUP100  X   DUP99  X      X     define DUPx  X  N   DUP  N  X    define DUP  X  N   DUPx  X  N     Initializing an array to a common value can easily be done    define LIST MAX 6 static unsigned char List  LIST MAX      DUP  123  LIST MAX        Note  DUPx introduced to enable macro substitution in parameters to DUP

[c++] Initialization of all elements of an array to one default value in C++?

Examples related to c++

Examples related to arrays

Examples related to initialization

Examples related to variable-assignment

Examples related to default-value