The following code works with GCC's C compiler, but not with the C++ compiler. Is there a "shortcut" to achieve the same result in C++?
int array[10] = {
[1] = 1,
[2] = 2,
[9] = 9
};
EDIT: Humm, I found this, clarifies everything. http://eli.thegreenplace.net/2011/02/15/array-initialization-with-enum-indices-in-c-but-not-c/
This form of initialization is only defined in the C99 standard. It does not apply to C++. So, you'll have to assign your elements one-by-one:
int array[10] = { 0 };
array[1] = 1;
array[2] = 2;
array[9] = 9;
While gcc may support some sort of extension to C++, it is generally advisable to avoid compiler- and platform-specific extensions wherever possible.
Use the standard C++ syntax for array initialization:
int array[10] = { 0, 1, 2, 0, 0, 0, 0, 0, 0, 9 };
Or write a function to do the initialization of specific elements:
std::array<int, 10> create_initialized_array()
{
std::array<int, 10> values = { 0 };
values[1] = 1;
values[2] = 2;
values[9] = 9;
return values;
}
std::array<int, 10> array = create_initialized_array();
Or use a lambda expression:
std::array<int, 10> array = ([]() -> std::array<int, 10>
{
std::array<int, 10> values = { 0 };
values[1] = 1;
values[2] = 2;
values[9] = 9;
return values;
})();
std::array. std::array is specified as being an aggregate, which means that it cannot have any user-declared constructors. The rationale for this was to allow aggregate initialization (the T x[N] = { /* initializers */ }; syntax). It might be possible to remove the aggregate requirement and add support for initializer_list, but that would break some currently-valid C++11 (and TR1) code (e.g. code that relies on brace elision, which I do not believe is valid for initializer lists).int [100]={[55]=7};, with my array: CArray<int,100> a { E[55]=7 };. Of course simple initialization still is valid: CArray<int,100> a { 0,0,...,7 };std::array cannot have any user-declared constructors because it is an aggregate. Adding support for designated initializers would be interesting to consider, though. Generalizing designated initializers to work for arbitrary types could prove tricky, but not impossible. I am entirely unfamiliar with the new C++11 initializer lists feature, so I'm probably not the best person to ask about this.
int array[10] = { 0, 1, 2, 0, 0, 0, 0, 0, 0, 9 };