How to set value of unsigned char array on C

Another solution would be the use of almighty memcpy() and C99 compound literals:

memcpy(array, (int []){ 0x00, 0x01, 0x02 }, sizeof array);

Believe it or not, this works.

    for (int i = 0; i < 64; ++i) buffer[i] = 0x00;

or in C++ (11 or later), you can use std::fill_n or std::generate_n

     std::fill_n(buffer, 64, 0x00);

or

      for (auto &b : buffer) b = 0x00;

From your comment I see you do not want to access elements of the array. If not, then here is another solution to your problem.

You could declare the buffer on the memory pool. Hence,

unsigned char *buffer = malloc( sizeof( unsigned char ) * 64 );

... and then if you ever wanted to replace all of the elements of the array (as you have attempted to do using the array initialization syntax), it would be done as follows:

memset( buffer, 0x00, sizeof( unsigned char ) * 64 ); // To replace buffer = { 0x00, ..., 0x00 };.
memset( buffer, 0, sizeof( unsigned char ) * 64 ); // To replace buffer = '0...0';.

Legacy:

If you wanted to use an array declared on the stack then you would need to mutate it one element at a time using the square brackets [ ]. It would be done as follows:

for ( int i = 0; i < 64; i++ ) {
  buffer[ i ] = val; // where "val" is some value.
}

Use std::memset:

memset(buffer, 0, sizeof(buffer));

There's also bzero, but it's a legacy function, so it shouldn't be used in new development.

You can change the values of the element in two ways :

unsigned char buffer[64]={0xef,0xaa,0x03,0x05,0x05,0x06,0x07,0x08,......};

buffer[0] = 0;
buffer[1] = 15;
// etc ...

// C++11 for-loop range works fine to :
for ( auto &c : buffer )
    c = 0;

Or after that, you can use function like : memset, std::fill_n :

memset( buffer, 0, sizeof(buffer) );
std::fill_n( buffer, 64, 0x00 );

You could use snprintf:

#include <stdio.h>

int main() {
  unsigned char buffer[64]={0};
  snprintf(buffer, 64, "Hello World!\x0D\x0A");
  printf(buffer);
}

Output:

$ ./a.out | hexdump -C
00000000  48 65 6c 6c 6f 20 57 6f  72 6c 64 21 0d 0a        |Hello World!..|
0000000e

Initialization and assignment are two different operations, despite similarity in the syntax.

int x[4] = { 1, 2, 3, 4}; // initialization
x = { 1, 2, 3, 4}; // assignment

Additionally, raw arrays in C and C++ behave strangely and in particular there's a special rule that says that they are not assignable:

int x[4];
int y[4];

y = x; // error, arrays are not assignable

So even if you create an array temporary object you cannot simply copy that into another array object using the assignment operator.

Instead, if you are set on using raw arrays, you have to set each array element individually, using memcpy, fill, etc.

A better solution is to use C++ and a type other than raw arrays which does allow assignment, such as std::array<unsigned char, 64>:

std::array<unsigned char, 64> buffer = {0xef,0xaa,0x03,0x05,0x05,0x06,0x07,0x08};
buffer = {}; // zeros out the array

The std::array template just generally behaves consistently like a normal object whereas raw arrays in C and C++ have all these very strange behaviors and special cases in the language specs. You should avoid using raw arrays.

Unfortunately C does not have any alternative to raw arrays.

Since that are some compiler issues, try a simple usage of memcpy().

#include <string.h>
int main() {
  unsigned char bufferTo[  64]={0xef,0xaa,0x03,0x05,0x05,0x06,0x07,0x08,......};
  unsigned char bufferFrom[64]={0x01,0x04,0xa0,0xb0,0xde,0x00,.....};
  memcpy(bufferTo, bufferFrom, 64);
  return 0;
}