How to initialize a static array within a c-style struct by an existing static array?

Try either of these syntaxes:

struct conf_t {
    const unsigned int a;
    const unsigned int b;
    const unsigned char id[ID_SIZE];
};

conf_t syntax_1 = { 10, 1, { 'a', 'b', 'c' }};  // an array needs its own {}
conf_t syntax_2 = { 10, 1, "hello" };           // an array of char can be a string.
                                                // make sure you have room for the
                                                // null termination!

The error on the initialization is that you cannot initialize an array element of type const unsigned char with an lvalue of type unsigned char[16].

What you need to initialize your member, is to use the correct initialization syntax with curly braces { vals... }, and use the correct types on the initialization values. But, this isn't so easy in standard C++, because you are triying to initialize a const value from a non-const one.

One workaround without losing const in your id member is to simply change it to const unsigned char*. Here the pointer type is the key.

Then, you can use some obscure monsters that exists in C++, like reinterpret_cast<T>, and initialize your const member from a non const one.

#include <cstring>
#include <string>
#define ID_SIZE 16

struct conf_t {
    const unsigned int a;
    const unsigned int b;
    const unsigned char* id[ID_SIZE];
};

int main() {
    const std::string raw_id("0123456789ABCDEF");
    unsigned char id[ID_SIZE];
    memcpy(id, raw_id.c_str(), ID_SIZE);
    struct conf_t conf = {10, 2048, reinterpret_cast<const unsigned char*>(id)};
    std::cout << *(conf.id);
}

And everything compiles fine now. You can see a live example here

Something is odd in your declaration. I suspect most of you issues come from an abusive usage of const.

Your conf_t definition reads:

struct conf_t { 
    const unsigned int a;
    const unsigned int b;
    const unsigned char id[ID_SIZE];
};

Why are you declaring constant members? And why are they uninitialized? The fact that they are all declared const and none of them are initialized makes me suspect a big code smell. If you require a constant conf_t, then declare it the usual way, as in:

struct conf_t { 
    unsigned int a;            // note that the const keyword has disappeared.
    unsigned int b;
    unsigned char id[ID_SIZE];
};

// the conf_t variable is declared const..

const conf_t my_conf { 10, 2048, "0123456789ABCDE" };

// et voilà !

If you need more flexibility, (ie: initialize id from an lvalue), you can either define a constructor as suggested by @Frodyne, or create an initializer function, this solution has the advantage of keeping the POD property of you simple conf_t struct.

Example:

struct conf_t { 
    unsigned int a;
    unsigned int b;
    unsigned char id[ID_SIZE];  // is there a VERY good reason why this is unsigned char?
};

// initializes a conf_t, I guess you cpould call that a 
// pseudo-constructor of sorts.

conf_t make_conf(int a, int b, const char* id)
{
     // our contract:
     assert(id != NULL && strlen(id) < ID_SIZE);  // or strlen(id) == ID_SIZE - 1, if you wish

     conf_t result = { a, b };
     strncpy((char*)result.id, id, sizeof(result.id));
     result.id[sizeof(result.id) - 1] = 0;

     // all c++ compilers less than 20 years old will return in-place
     return result;
}


//  declaration from literals then becomes:

const conf_t cfg1 = make_conf(1, 2, "0123456789ABCDE");

//  declaration from l-values becomes:

int x = 123; 
int y = 42;
std::string s = "EDCBA9876543210";

const conf_t cfg2 = make_conf(x, y, s.c_str());

Which shouldn't be too taxing on the fingers, nor on the eyes.