How to initialize all members of an array to the same value

Question

I have a large array in C  not C   if that makes a difference   I want to initialize all members of the same value   I could swear I once knew a simple way to do this  I could use memset   in my case  but isn t there a way to do this that is built right into the C syntax

User · Answer

I see no requirements in the question  so the solution must be generic  initialization of an unspecified possibly multidimensional array built from unspecified possibly structure elements with an initial member value    include  lt string h    void array init  void  start  size t element size  size t elements  void  initval      memcpy         start               initval  element size                   memcpy   char  start element size  start    element size  elements-1           testing  include  lt stdio h    struct s     int a    char b    array 2  3   init   int main      init    struct s   a   3   b    x      array init  array  sizeof array 0  0    2 3   init       for  int i 0  i lt 2  i         for  int j 0  j lt 3  j           printf  array  i   i  a    i  b     c  n  i j array i  j  a array i  j  b       Result   array 0  0  a   3  b    x  array 0  1  a   3  b    x  array 0  2  a   3  b    x  array 1  0  a   3  b    x  array 1  1  a   3  b    x  array 1  2  a   3  b    x    EDIT   start element size changed to  char  start element size

User · Answer

If you mean in parallel  I think the comma operator when used in conjunction with an expression can do that    a 1  1  a 2  2       a indexSize      or if you mean in a single construct  you could do that in a for loop    for int index   0  value   10  index  lt  sizeof array  sizeof array 0    index    value--    array index    index      Note the comma operator in an arguments list is not the parallel operator described above   You can initialize an array decleration   array      1  2  3  4  5     You can make a call to malloc calloc sbrk alloca etc to allocate a fixed region of storage to an object   int  array   malloc sizeof int  numberOfListElements Indexes     and access the members by     array   index    Etc

User · Answer

Unless that value is 0  in which case you can omit some part of the initializer and the corresponding elements will be initialized to 0   there s no easy way   Don t overlook the obvious solution  though   int myArray 10      5  5  5  5  5  5  5  5  5  5      Elements with missing values will be initialized to 0   int myArray 10      1  2       initialize to 1 2 0 0 0      So this will initialize all elements to 0   int myArray 10      0       all elements 0   In C    an empty initialization list will also initialize every element to 0  This is not allowed with C   int myArray 10           all elements 0 in C     Remember that objects with static storage duration will initialize to 0 if no initializer is specified   static int myArray 10      all elements 0   And that  0  doesn t necessarily mean  all-bits-zero   so using the above is better and more portable than memset     Floating point values will be initialized to  0  pointers to null value  etc

User · Answer

I know the original question explicitly mentions C and not C    but if you  like me  came here looking for a solution for C   arrays  here s a neat trick   If your compiler supports fold expressions  you can use template magic and std  index sequence to generate an initializer list with the value that you want  And you can even constexpr it and feel like a boss    include  lt array gt        3      This functions s only purpose is to ignore the index given as the second     template argument and to always produce the value passed in  template lt class T  size t   ignored   gt  constexpr T identity func const T amp  value        return value          2      At this point  we have a list of indices that we can unfold     into an initializer list using the  identity func  above  template lt class T  size t    Indices gt  constexpr std  array lt T  sizeof    Indices  gt  make array of impl const T amp  value  std  index sequence lt Indices    gt         return  identity func lt T  Indices gt  value               1      This is the user-facing function      The template arguments are swapped compared to the order used     for std  array  this way we can let the compiler infer the type     from the given value but still define it explicitly if we want to  template lt size t Size  class T gt  constexpr std  array lt T  Size gt   make array of const T amp  value        using Indices   std  make index sequence lt Size gt       return make array of impl value  Indices           std  array lt int  4 gt  42  42  42  42  constexpr auto test array   make array of lt 4    int   gt  42   static assert test array 0     42   static assert test array 1     42   static assert test array 2     42   static assert test array 3     42      static assert test array 4     42   out of bounds   You can take a look at the code at work  at Wandbox

User · Answer

For statically initializing a large array with the same value  without multiple copy-paste  you can use macros    define VAL 1X     42  define VAL 2X     VAL 1X   VAL 1X  define VAL 4X     VAL 2X   VAL 2X  define VAL 8X     VAL 4X   VAL 4X  define VAL 16X    VAL 8X   VAL 8X  define VAL 32X    VAL 16X  VAL 16X  define VAL 64X    VAL 32X  VAL 32X  int myArray 53      VAL 32X  VAL 16X  VAL 4X  VAL 1X      If you need to change the value  you have to do the replacement at only one place   Edit  possible useful extensions   courtesy of Jonathan Leffler   You can easily generalize this with    define VAL 1 X  X  define VAL 2 X  VAL 1 X   VAL 1 X     etc       A variant can be created using    define STRUCTVAL 1          VA ARGS      define STRUCTVAL 2      STRUCTVAL 1   VA ARGS     STRUCTVAL 1   VA ARGS      etc       that works with structures or compound arrays    define STRUCTVAL 48      STRUCTVAL 32   VA ARGS     STRUCTVAL 16   VA ARGS     struct Pair   char key 16   char val 32      struct Pair p data       STRUCTVAL 48  Key    Value      int a data   4      STRUCTVAL 48 12  19  23  37       macro names are negotiable

User · Answer

If the array happens to be int or anything with the size of int or your mem-pattern s size fits exact times into an int  i e  all zeroes or 0xA5A5A5A5   the best way is to use memset     Otherwise call memcpy   in a loop moving the index

User · Answer

For initializing  normal  data types  like int arrays   you can use the bracket notation  but it will zero the values after the last if there is still space in the array      put values 1-8  then two zeroes int list 10     1 2 3 4 5 6 7 8

User · Answer

If your compiler is GCC you can use following syntax   int array 1024      0     1023    5     Check out detailed description  http   gcc gnu org onlinedocs gcc-4 1 2 gcc Designated-Inits html

User · Answer

If you want to ensure that every member of the array is explicitly initialized  just omit the dimension from the declaration   int myArray       1  2  3  4  5  6  7  8  9      The compiler will deduce the dimension from the initializer list  Unfortunately  for multidimensional arrays only the outermost dimension may be omitted   int myPoints   3        1  2  3      4  5  6      7  8  9       is OK  but  int myPoints           1  2  3      4  5  6      7  8  9       is not

User · Answer

For delayed initialization  i e  class member constructor initialization  consider   int a 4    unsigned int size   sizeof a    sizeof a 0    for  unsigned int i   0  i  lt  size  i      a i    0

User · Answer

I saw some code that used this syntax   char  array             0     Hello        1     World          Where it becomes particularly useful is if you re making an array that uses enums as the index   enum       ERR OK      ERR FAIL      ERR MEMORY      define  ITEM x   x     x  char  array             ITEM ERR OK        ITEM ERR FAIL        ITEM ERR MEMORY          This keeps things in order  even if you happen to write some of the enum-values out of order   More about this technique can be found here and here

User · Answer

Nobody has mentioned the index order to access the elements of the initialized array  My example code will give an illustrative example to it    include  lt iostream gt   void PrintArray int a 3  3         std  cout  lt  lt   a11      lt  lt  a 0  0   lt  lt    t t   lt  lt   a12      lt  lt  a 0  1   lt  lt    t t   lt  lt   a13      lt  lt  a 0  2   lt  lt  std  endl      std  cout  lt  lt   a21      lt  lt  a 1  0   lt  lt    t t   lt  lt   a22      lt  lt  a 1  1   lt  lt    t t   lt  lt   a23      lt  lt  a 1  2   lt  lt  std  endl      std  cout  lt  lt   a31      lt  lt  a 2  0   lt  lt    t t   lt  lt   a32      lt  lt  a 2  1   lt  lt    t t   lt  lt   a33      lt  lt  a 2  2   lt  lt  std  endl      std  cout  lt  lt  std  endl     int wmain int argc  wchar t   argv          int a1 3  3         11      12      13         The most                         21      22      23         basic                         31      32      33         format       int a2   3          11      12      13         The first  outer  dimension                         21      22      23         may be omitted  The compiler                         31      32      33         will automatically deduce it       int a3 3  3          11     12      13         The elements of each                          21     22      23         second  inner  dimension                          31     32      33         can be grouped together       int a4   3           11     12      13         Again  the first dimension                          21     22      23         can be omitted when the                           31     32      33         inner elements are grouped       PrintArray a1       PrintArray a2       PrintArray a3       PrintArray a4           This part shows in which order the elements are stored in the memory      int   b    int    a1       The output is the same for the all four arrays      for  int i 0  i lt 9  i                  std  cout  lt  lt  b i   lt  lt    t              return 0      The output is   a11   11                a12   12                a13   13 a21   21                a22   22                a23   23 a31   31                a32   32                a33   33  a11   11                a12   12                a13   13 a21   21                a22   22                a23   23 a31   31                a32   32                a33   33  a11   11                a12   12                a13   13 a21   21                a22   22                a23   23 a31   31                a32   32                a33   33  a11   11                a12   12                a13   13 a21   21                a22   22                a23   23 a31   31                a32   32                a33   33  11      12      13      21      22      23      31      32      33

User · Answer

If you mean in parallel  I think the comma operator when used in conjunction with an expression can do that    a 1  1  a 2  2       a indexSize      or if you mean in a single construct  you could do that in a for loop    for int index   0  value   10  index  lt  sizeof array  sizeof array 0    index    value--    array index    index      Note the comma operator in an arguments list is not the parallel operator described above   You can initialize an array decleration   array      1  2  3  4  5     You can make a call to malloc calloc sbrk alloca etc to allocate a fixed region of storage to an object   int  array   malloc sizeof int  numberOfListElements Indexes     and access the members by     array   index    Etc

User · Answer

If the array happens to be int or anything with the size of int or your mem-pattern s size fits exact times into an int  i e  all zeroes or 0xA5A5A5A5   the best way is to use memset     Otherwise call memcpy   in a loop moving the index

User · Answer

If the array happens to be int or anything with the size of int or your mem-pattern s size fits exact times into an int  i e  all zeroes or 0xA5A5A5A5   the best way is to use memset     Otherwise call memcpy   in a loop moving the index

User · Answer

If your compiler is GCC you can use following syntax   int array 1024      0     1023    5     Check out detailed description  http   gcc gnu org onlinedocs gcc-4 1 2 gcc Designated-Inits html

User · Answer

Cutting through all the chatter  the short answer is that if you turn on optimization at compile time you won t do better than this    int i value 5 array 1000    for i 0 i lt 1000 i    array i  value     Added bonus  the code is actually legible

User · Answer

include lt stdio h gt  int main    int i a 50   for  i 0 i lt 50 i         a i  5    set value 5 to all the array index   for  i 0 i lt 50 i    printf   d n  a i       return 0      It will give the o p 5 5 5 5 5 5        till the size of whole array

User · Answer

int i  for  i   0  i  lt  ARRAY SIZE    i      myArray i    VALUE      I think this is better than  int myArray 10      5  5  5  5  5  5  5  5  5  5      incase the size of the array changes

User · Answer

I know that user Tarski answered this question in a similar manner  but I added a few more details  Forgive some of my C for I m a bit rusty at it since I m more inclined to want to use C    but here it goes     If you know the size of the array ahead of time      include  lt stdio h gt   typedef const unsigned int cUINT  typedef unsigned int UINT   cUINT size   10  cUINT initVal   5   void arrayInitializer  UINT  myArray  cUINT size  cUINT initVal    void printArray  UINT  myArray      int main                 UINT myArray size           Not initialized during declaration but can be     initialized using a function for the appropriate TYPE       arrayInitializer  myArray  size  initVal         printArray  myArray         return 0     void arrayInitializer  UINT  myArray  cUINT size  cUINT initVal         for   UINT n   0  n  lt  size  n               myArray n    initVal           void printArray  UINT  myArray         printf   myArray              for   UINT n   0  n  lt  size  n               printf    u   myArray n              if   n  lt  size-1               printf                    printf      n         There are a few caveats above  one is that UINT myArray size   is not directly initialized upon declaration  however the very next code block or function call does initialize each element of the array to the same value you want  The other caveat is  you would have to write an initializing function for each type you will support and you would also have to modify the printArray   function to support those types     You can try this code with an online complier found here

User · Answer

If your compiler is GCC you can use following syntax   int array 1024      0     1023    5     Check out detailed description  http   gcc gnu org onlinedocs gcc-4 1 2 gcc Designated-Inits html

User · Answer

Back in the day  and I m not saying it s a good idea   we d set the first element and then   memcpy   amp element  1    amp element  0   sizeof  element -sizeof  element  0      Not even sure it would work any more  that would depend on the implementation of memcpy  but it works by repeatedly copying the initial element to the next - even works for arrays of structures

User · Answer

For delayed initialization  i e  class member constructor initialization  consider   int a 4    unsigned int size   sizeof a    sizeof a 0    for  unsigned int i   0  i  lt  size  i      a i    0

User · Answer

Unless that value is 0  in which case you can omit some part of the initializer and the corresponding elements will be initialized to 0   there s no easy way   Don t overlook the obvious solution  though   int myArray 10      5  5  5  5  5  5  5  5  5  5      Elements with missing values will be initialized to 0   int myArray 10      1  2       initialize to 1 2 0 0 0      So this will initialize all elements to 0   int myArray 10      0       all elements 0   In C    an empty initialization list will also initialize every element to 0  This is not allowed with C   int myArray 10           all elements 0 in C     Remember that objects with static storage duration will initialize to 0 if no initializer is specified   static int myArray 10      all elements 0   And that  0  doesn t necessarily mean  all-bits-zero   so using the above is better and more portable than memset     Floating point values will be initialized to  0  pointers to null value  etc

User · Answer

Here is another way   static void unhandled interrupt struct trap frame  frame  int irq  void  arg          this code intentionally left blank    static struct irqtbl s vector tbl XCHAL NUM INTERRUPTS           0     XCHAL NUM INTERRUPTS-1   unhandled interrupt  NULL        See   C-Extensions  Designated inits  Then ask the question  When can one use C extensions   The code sample above is in an embedded system and will never see the light from another compiler

User · Answer

If the size of the array is known in advance  one could use a Boost preprocessor C ARRAY INITIALIZE macro to do the dirty job for you   include  lt boost preprocessor repetition enum hpp gt   define C ARRAY ELEMENT z  index  name  name index   define C ARRAY EXPAND name size  BOOST PP ENUM size C ARRAY ELEMENT name   define C ARRAY VALUE z  index  value  value  define C ARRAY INITIALIZE value size  BOOST PP ENUM size C ARRAY VALUE value

User · Answer

If you want to ensure that every member of the array is explicitly initialized  just omit the dimension from the declaration   int myArray       1  2  3  4  5  6  7  8  9      The compiler will deduce the dimension from the initializer list  Unfortunately  for multidimensional arrays only the outermost dimension may be omitted   int myPoints   3        1  2  3      4  5  6      7  8  9       is OK  but  int myPoints           1  2  3      4  5  6      7  8  9       is not

User · Answer

If you want to ensure that every member of the array is explicitly initialized  just omit the dimension from the declaration   int myArray       1  2  3  4  5  6  7  8  9      The compiler will deduce the dimension from the initializer list  Unfortunately  for multidimensional arrays only the outermost dimension may be omitted   int myPoints   3        1  2  3      4  5  6      7  8  9       is OK  but  int myPoints           1  2  3      4  5  6      7  8  9       is not

User · Answer

For statically initializing a large array with the same value  without multiple copy-paste  you can use macros    define VAL 1X     42  define VAL 2X     VAL 1X   VAL 1X  define VAL 4X     VAL 2X   VAL 2X  define VAL 8X     VAL 4X   VAL 4X  define VAL 16X    VAL 8X   VAL 8X  define VAL 32X    VAL 16X  VAL 16X  define VAL 64X    VAL 32X  VAL 32X  int myArray 53      VAL 32X  VAL 16X  VAL 4X  VAL 1X      If you need to change the value  you have to do the replacement at only one place   Edit  possible useful extensions   courtesy of Jonathan Leffler   You can easily generalize this with    define VAL 1 X  X  define VAL 2 X  VAL 1 X   VAL 1 X     etc       A variant can be created using    define STRUCTVAL 1          VA ARGS      define STRUCTVAL 2      STRUCTVAL 1   VA ARGS     STRUCTVAL 1   VA ARGS      etc       that works with structures or compound arrays    define STRUCTVAL 48      STRUCTVAL 32   VA ARGS     STRUCTVAL 16   VA ARGS     struct Pair   char key 16   char val 32      struct Pair p data       STRUCTVAL 48  Key    Value      int a data   4      STRUCTVAL 48 12  19  23  37       macro names are negotiable

User · Answer

If your compiler is GCC you can use following syntax   int array 1024      0     1023    5     Check out detailed description  http   gcc gnu org onlinedocs gcc-4 1 2 gcc Designated-Inits html

User · Answer

int i  for  i   0  i  lt  ARRAY SIZE    i      myArray i    VALUE      I think this is better than  int myArray 10      5  5  5  5  5  5  5  5  5  5      incase the size of the array changes

User · Answer

include lt stdio h gt  int main    int i a 50   for  i 0 i lt 50 i         a i  5    set value 5 to all the array index   for  i 0 i lt 50 i    printf   d n  a i       return 0      It will give the o p 5 5 5 5 5 5        till the size of whole array

User · Answer

For initializing  normal  data types  like int arrays   you can use the bracket notation  but it will zero the values after the last if there is still space in the array      put values 1-8  then two zeroes int list 10     1 2 3 4 5 6 7 8

User · Answer

int array 1024      0     1023    5   As the above works fine  but make sure no spaces between the     dots

User · Answer

You can do the whole static initializer thing as detailed above  but it can be a real bummer when your array size changes  when your array embiggens  if you don t add the appropriate extra initializers you get garbage    memset gives you a runtime hit for doing the work  but no code size hit done right is immune to array size changes   I would use this solution in nearly all cases when the array was larger than  say  a few dozen elements   If it was really important that the array was statically declared  I d write a program to write the program for me and make it part of the build process

User · Answer

For initializing  normal  data types  like int arrays   you can use the bracket notation  but it will zero the values after the last if there is still space in the array      put values 1-8  then two zeroes int list 10     1 2 3 4 5 6 7 8

User · Answer

There is a fast way to initialize array of any type with given value  It works very well with large arrays  Algorithm is as follows    initialize first element of the array  usual way  copy part which has been set into part which has not been set  doubling the size with each next copy operation     For 1 000 000 elements int array it is 4 times faster than regular loop initialization  i5  2 cores  2 3 GHz  4GiB memory  64 bits    loop runtime 0 004248  seconds   memfill   runtime 0 001085  seconds        include  lt stdio h gt   include  lt time h gt   include  lt string h gt   define ARR SIZE 1000000  void memfill void  dest  size t destsize  size t elemsize       char    nextdest    char    dest   elemsize     size t movesize  donesize   elemsize      destsize -  elemsize     while  destsize          movesize    donesize  lt  destsize    donesize   destsize        memcpy nextdest  dest  movesize         nextdest    movesize  destsize -  movesize  donesize    movesize             int main         clock t timeStart      double  runTime      int     i  a ARR SIZE        timeStart   clock        for  i   0  i  lt  ARR SIZE  i            a i    9          runTime    double  clock   - timeStart     double CLOCKS PER SEC      printf  loop runtime  f  seconds  n  runTime        timeStart   clock        a 0    10      memfill a  sizeof a   sizeof a 0         runTime    double  clock   - timeStart     double CLOCKS PER SEC      printf  memfill   runtime  f  seconds  n  runTime       return 0

User · Answer

If your array is declared as static or is global  all the elements in the array already have default default value 0  Some compilers set array s the default to 0 in debug mode    It is easy to set default to 0    int array 10     0    However  for other values  you have use memset   or loop    example      int array 10       memset array -1  10  sizeof int

User · Answer

Nobody has mentioned the index order to access the elements of the initialized array  My example code will give an illustrative example to it    include  lt iostream gt   void PrintArray int a 3  3         std  cout  lt  lt   a11      lt  lt  a 0  0   lt  lt    t t   lt  lt   a12      lt  lt  a 0  1   lt  lt    t t   lt  lt   a13      lt  lt  a 0  2   lt  lt  std  endl      std  cout  lt  lt   a21      lt  lt  a 1  0   lt  lt    t t   lt  lt   a22      lt  lt  a 1  1   lt  lt    t t   lt  lt   a23      lt  lt  a 1  2   lt  lt  std  endl      std  cout  lt  lt   a31      lt  lt  a 2  0   lt  lt    t t   lt  lt   a32      lt  lt  a 2  1   lt  lt    t t   lt  lt   a33      lt  lt  a 2  2   lt  lt  std  endl      std  cout  lt  lt  std  endl     int wmain int argc  wchar t   argv          int a1 3  3         11      12      13         The most                         21      22      23         basic                         31      32      33         format       int a2   3          11      12      13         The first  outer  dimension                         21      22      23         may be omitted  The compiler                         31      32      33         will automatically deduce it       int a3 3  3          11     12      13         The elements of each                          21     22      23         second  inner  dimension                          31     32      33         can be grouped together       int a4   3           11     12      13         Again  the first dimension                          21     22      23         can be omitted when the                           31     32      33         inner elements are grouped       PrintArray a1       PrintArray a2       PrintArray a3       PrintArray a4           This part shows in which order the elements are stored in the memory      int   b    int    a1       The output is the same for the all four arrays      for  int i 0  i lt 9  i                  std  cout  lt  lt  b i   lt  lt    t              return 0      The output is   a11   11                a12   12                a13   13 a21   21                a22   22                a23   23 a31   31                a32   32                a33   33  a11   11                a12   12                a13   13 a21   21                a22   22                a23   23 a31   31                a32   32                a33   33  a11   11                a12   12                a13   13 a21   21                a22   22                a23   23 a31   31                a32   32                a33   33  a11   11                a12   12                a13   13 a21   21                a22   22                a23   23 a31   31                a32   32                a33   33  11      12      13      21      22      23      31      32      33

User · Answer

You can do the whole static initializer thing as detailed above  but it can be a real bummer when your array size changes  when your array embiggens  if you don t add the appropriate extra initializers you get garbage    memset gives you a runtime hit for doing the work  but no code size hit done right is immune to array size changes   I would use this solution in nearly all cases when the array was larger than  say  a few dozen elements   If it was really important that the array was statically declared  I d write a program to write the program for me and make it part of the build process

User · Answer

A slightly tongue-in-cheek answer  write the statement  array   initial value   in your favourite array-capable language  mine is Fortran  but there are many others   and link it to your C code   You d probably want to wrap it up to be an external function

User · Answer

A slightly tongue-in-cheek answer  write the statement  array   initial value   in your favourite array-capable language  mine is Fortran  but there are many others   and link it to your C code   You d probably want to wrap it up to be an external function

User · Answer

For initializing  normal  data types  like int arrays   you can use the bracket notation  but it will zero the values after the last if there is still space in the array      put values 1-8  then two zeroes int list 10     1 2 3 4 5 6 7 8

User · Answer

If the size of the array is known in advance  one could use a Boost preprocessor C ARRAY INITIALIZE macro to do the dirty job for you   include  lt boost preprocessor repetition enum hpp gt   define C ARRAY ELEMENT z  index  name  name index   define C ARRAY EXPAND name size  BOOST PP ENUM size C ARRAY ELEMENT name   define C ARRAY VALUE z  index  value  value  define C ARRAY INITIALIZE value size  BOOST PP ENUM size C ARRAY VALUE value

User · Answer

int i  for  i   0  i  lt  ARRAY SIZE    i      myArray i    VALUE      I think this is better than  int myArray 10      5  5  5  5  5  5  5  5  5  5      incase the size of the array changes

User · Answer

I saw some code that used this syntax   char  array             0     Hello        1     World          Where it becomes particularly useful is if you re making an array that uses enums as the index   enum       ERR OK      ERR FAIL      ERR MEMORY      define  ITEM x   x     x  char  array             ITEM ERR OK        ITEM ERR FAIL        ITEM ERR MEMORY          This keeps things in order  even if you happen to write some of the enum-values out of order   More about this technique can be found here and here

User · Answer

Here is another way   static void unhandled interrupt struct trap frame  frame  int irq  void  arg          this code intentionally left blank    static struct irqtbl s vector tbl XCHAL NUM INTERRUPTS           0     XCHAL NUM INTERRUPTS-1   unhandled interrupt  NULL        See   C-Extensions  Designated inits  Then ask the question  When can one use C extensions   The code sample above is in an embedded system and will never see the light from another compiler

User · Answer

Here is another way   static void unhandled interrupt struct trap frame  frame  int irq  void  arg          this code intentionally left blank    static struct irqtbl s vector tbl XCHAL NUM INTERRUPTS           0     XCHAL NUM INTERRUPTS-1   unhandled interrupt  NULL        See   C-Extensions  Designated inits  Then ask the question  When can one use C extensions   The code sample above is in an embedded system and will never see the light from another compiler

User · Answer

I know that user Tarski answered this question in a similar manner  but I added a few more details  Forgive some of my C for I m a bit rusty at it since I m more inclined to want to use C    but here it goes     If you know the size of the array ahead of time      include  lt stdio h gt   typedef const unsigned int cUINT  typedef unsigned int UINT   cUINT size   10  cUINT initVal   5   void arrayInitializer  UINT  myArray  cUINT size  cUINT initVal    void printArray  UINT  myArray      int main                 UINT myArray size           Not initialized during declaration but can be     initialized using a function for the appropriate TYPE       arrayInitializer  myArray  size  initVal         printArray  myArray         return 0     void arrayInitializer  UINT  myArray  cUINT size  cUINT initVal         for   UINT n   0  n  lt  size  n               myArray n    initVal           void printArray  UINT  myArray         printf   myArray              for   UINT n   0  n  lt  size  n               printf    u   myArray n              if   n  lt  size-1               printf                    printf      n         There are a few caveats above  one is that UINT myArray size   is not directly initialized upon declaration  however the very next code block or function call does initialize each element of the array to the same value you want  The other caveat is  you would have to write an initializing function for each type you will support and you would also have to modify the printArray   function to support those types     You can try this code with an online complier found here

User · Answer

Cutting through all the chatter  the short answer is that if you turn on optimization at compile time you won t do better than this    int i value 5 array 1000    for i 0 i lt 1000 i    array i  value     Added bonus  the code is actually legible

User · Answer

Unless that value is 0  in which case you can omit some part of the initializer and the corresponding elements will be initialized to 0   there s no easy way   Don t overlook the obvious solution  though   int myArray 10      5  5  5  5  5  5  5  5  5  5      Elements with missing values will be initialized to 0   int myArray 10      1  2       initialize to 1 2 0 0 0      So this will initialize all elements to 0   int myArray 10      0       all elements 0   In C    an empty initialization list will also initialize every element to 0  This is not allowed with C   int myArray 10           all elements 0 in C     Remember that objects with static storage duration will initialize to 0 if no initializer is specified   static int myArray 10      all elements 0   And that  0  doesn t necessarily mean  all-bits-zero   so using the above is better and more portable than memset     Floating point values will be initialized to  0  pointers to null value  etc

User · Answer

int array 1024      0     1023    5   As the above works fine  but make sure no spaces between the     dots

User · Answer

I see no requirements in the question  so the solution must be generic  initialization of an unspecified possibly multidimensional array built from unspecified possibly structure elements with an initial member value    include  lt string h    void array init  void  start  size t element size  size t elements  void  initval      memcpy         start               initval  element size                   memcpy   char  start element size  start    element size  elements-1           testing  include  lt stdio h    struct s     int a    char b    array 2  3   init   int main      init    struct s   a   3   b    x      array init  array  sizeof array 0  0    2 3   init       for  int i 0  i lt 2  i         for  int j 0  j lt 3  j           printf  array  i   i  a    i  b     c  n  i j array i  j  a array i  j  b       Result   array 0  0  a   3  b    x  array 0  1  a   3  b    x  array 0  2  a   3  b    x  array 1  0  a   3  b    x  array 1  1  a   3  b    x  array 1  2  a   3  b    x    EDIT   start element size changed to  char  start element size

User · Answer

If your array is declared as static or is global  all the elements in the array already have default default value 0  Some compilers set array s the default to 0 in debug mode    It is easy to set default to 0    int array 10     0    However  for other values  you have use memset   or loop    example      int array 10       memset array -1  10  sizeof int

User · Answer

You can do the whole static initializer thing as detailed above  but it can be a real bummer when your array size changes  when your array embiggens  if you don t add the appropriate extra initializers you get garbage    memset gives you a runtime hit for doing the work  but no code size hit done right is immune to array size changes   I would use this solution in nearly all cases when the array was larger than  say  a few dozen elements   If it was really important that the array was statically declared  I d write a program to write the program for me and make it part of the build process

User · Answer

Back in the day  and I m not saying it s a good idea   we d set the first element and then   memcpy   amp element  1    amp element  0   sizeof  element -sizeof  element  0      Not even sure it would work any more  that would depend on the implementation of memcpy  but it works by repeatedly copying the initial element to the next - even works for arrays of structures

User · Answer

Here is another way   static void unhandled interrupt struct trap frame  frame  int irq  void  arg          this code intentionally left blank    static struct irqtbl s vector tbl XCHAL NUM INTERRUPTS           0     XCHAL NUM INTERRUPTS-1   unhandled interrupt  NULL        See   C-Extensions  Designated inits  Then ask the question  When can one use C extensions   The code sample above is in an embedded system and will never see the light from another compiler

User · Answer

Unless that value is 0  in which case you can omit some part of the initializer and the corresponding elements will be initialized to 0   there s no easy way   Don t overlook the obvious solution  though   int myArray 10      5  5  5  5  5  5  5  5  5  5      Elements with missing values will be initialized to 0   int myArray 10      1  2       initialize to 1 2 0 0 0      So this will initialize all elements to 0   int myArray 10      0       all elements 0   In C    an empty initialization list will also initialize every element to 0  This is not allowed with C   int myArray 10           all elements 0 in C     Remember that objects with static storage duration will initialize to 0 if no initializer is specified   static int myArray 10      all elements 0   And that  0  doesn t necessarily mean  all-bits-zero   so using the above is better and more portable than memset     Floating point values will be initialized to  0  pointers to null value  etc

User · Answer

int i  for  i   0  i  lt  ARRAY SIZE    i      myArray i    VALUE      I think this is better than  int myArray 10      5  5  5  5  5  5  5  5  5  5      incase the size of the array changes

User · Answer

If you want to ensure that every member of the array is explicitly initialized  just omit the dimension from the declaration   int myArray       1  2  3  4  5  6  7  8  9      The compiler will deduce the dimension from the initializer list  Unfortunately  for multidimensional arrays only the outermost dimension may be omitted   int myPoints   3        1  2  3      4  5  6      7  8  9       is OK  but  int myPoints           1  2  3      4  5  6      7  8  9       is not

User · Answer

There is a fast way to initialize array of any type with given value  It works very well with large arrays  Algorithm is as follows    initialize first element of the array  usual way  copy part which has been set into part which has not been set  doubling the size with each next copy operation     For 1 000 000 elements int array it is 4 times faster than regular loop initialization  i5  2 cores  2 3 GHz  4GiB memory  64 bits    loop runtime 0 004248  seconds   memfill   runtime 0 001085  seconds        include  lt stdio h gt   include  lt time h gt   include  lt string h gt   define ARR SIZE 1000000  void memfill void  dest  size t destsize  size t elemsize       char    nextdest    char    dest   elemsize     size t movesize  donesize   elemsize      destsize -  elemsize     while  destsize          movesize    donesize  lt  destsize    donesize   destsize        memcpy nextdest  dest  movesize         nextdest    movesize  destsize -  movesize  donesize    movesize             int main         clock t timeStart      double  runTime      int     i  a ARR SIZE        timeStart   clock        for  i   0  i  lt  ARR SIZE  i            a i    9          runTime    double  clock   - timeStart     double CLOCKS PER SEC      printf  loop runtime  f  seconds  n  runTime        timeStart   clock        a 0    10      memfill a  sizeof a   sizeof a 0         runTime    double  clock   - timeStart     double CLOCKS PER SEC      printf  memfill   runtime  f  seconds  n  runTime       return 0

User · Answer

I know the original question explicitly mentions C and not C    but if you  like me  came here looking for a solution for C   arrays  here s a neat trick   If your compiler supports fold expressions  you can use template magic and std  index sequence to generate an initializer list with the value that you want  And you can even constexpr it and feel like a boss    include  lt array gt        3      This functions s only purpose is to ignore the index given as the second     template argument and to always produce the value passed in  template lt class T  size t   ignored   gt  constexpr T identity func const T amp  value        return value          2      At this point  we have a list of indices that we can unfold     into an initializer list using the  identity func  above  template lt class T  size t    Indices gt  constexpr std  array lt T  sizeof    Indices  gt  make array of impl const T amp  value  std  index sequence lt Indices    gt         return  identity func lt T  Indices gt  value               1      This is the user-facing function      The template arguments are swapped compared to the order used     for std  array  this way we can let the compiler infer the type     from the given value but still define it explicitly if we want to  template lt size t Size  class T gt  constexpr std  array lt T  Size gt   make array of const T amp  value        using Indices   std  make index sequence lt Size gt       return make array of impl value  Indices           std  array lt int  4 gt  42  42  42  42  constexpr auto test array   make array of lt 4    int   gt  42   static assert test array 0     42   static assert test array 1     42   static assert test array 2     42   static assert test array 3     42      static assert test array 4     42   out of bounds   You can take a look at the code at work  at Wandbox

User · Answer

If the array happens to be int or anything with the size of int or your mem-pattern s size fits exact times into an int  i e  all zeroes or 0xA5A5A5A5   the best way is to use memset     Otherwise call memcpy   in a loop moving the index

User · Answer

You can do the whole static initializer thing as detailed above  but it can be a real bummer when your array size changes  when your array embiggens  if you don t add the appropriate extra initializers you get garbage    memset gives you a runtime hit for doing the work  but no code size hit done right is immune to array size changes   I would use this solution in nearly all cases when the array was larger than  say  a few dozen elements   If it was really important that the array was statically declared  I d write a program to write the program for me and make it part of the build process

[c] How to initialize all members of an array to the same value?

Examples related to c

Examples related to arrays

Examples related to initialization

Examples related to array-initialize