Назначение подмассива: инициализация с "{...}" ожидается для ошибки агрегированного объекта

когда вы не указываете размер массива (в строке 1). компилятор указывает это для вас. а для этого надо сделать так:

/* Line 0 */    int foo[10][10];
/* Line 1 */    int foo_alias_compile_error[] = {foo[0]};

но у него все еще есть проблема. при компиляции этого кода:

 $ g++ error.cpp
 $ error.cpp:4:28: error: invalid conversion from ‘int*’ to ‘int’ [-fpermissive]
 $    4 |     int fooError[] = {foo[0]};
 $      |                       ~~~~~^
 $      |                            |
 $      |                            int*

потому что foo[0] является указателем и указывает на первую строку вашей матрицы (в строке 1). ты можешь это сделать:

/* Line 0 */    int foo[10][10];
/* Line 1 */    int foo_alias_compile_error[] = {foo[0][0]};

Можно было бы думать о строке 1 как о создании ссылки на 0-ю запись foo. Однако C++ работает иначе. Скорее, оператор присваивания (=) вызывает операцию копирования. Таким образом, C++ интерпретирует строку 1 как директиву для копирования элементов foo[0] в новый массив с неподходящим именем foo_alias_compile_error.

Это не то, что имелось в виду — нужна была ссылка, а не копия. Итак, хорошо, что C++ вызвал ошибку по несвязанной с этим причине и спас ее от самого себя.

Жизнеспособное решение предложено @FrançoisAndrieux. Вот более полный пример, показывающий, что ссылка (не копия) может быть сделана с помощью int (&foo_reference)[10] = foo[0];.

int foo[10][10];
for (int i = 0; i < 10; ++i) {
    for (int j = 0; j < 10; ++j) {
        foo[i][j] = i + j * 10;
    }
}
int (&foo_reference)[10] = foo[0];

for (int j = 0; j < 10; ++j) {
    foo_reference[j] = 100 + j;
}

for (int i = 0; i < 10; ++i) {
    printf("foo   [0][%i] is %i\n", i, foo[0][i]);
    printf("foo_refer[%i] is %i\n", i, foo_reference[i]);
}

Выходной фрагмент

foo   [0][0] is 100
foo_alias[0] is 100
foo   [0][1] is 101
foo_alias[1] is 101
foo   [0][2] is 102
foo_alias[2] is 102
foo   [0][3] is 103
foo_alias[3] is 103

Примечание

Стоит отметить, что функции, принимающие массивы в качестве аргументов, неявно преобразуют свои аргументы-массивы в указатели (как показано в строке 3). Итак, это одна из причин, по которой кто-то может ошибочно подумать, что что-то вроде строки 1 должно работать.

Другими словами, следующий код

void barz(int arg[]) {
    arg[2] = 99999;
}

int another_array[] = {0, 1, 2, 3, 4};
barz(another_array);
printf("another_array[2] is %i\n", another_array[2]);

«Правильно» печатает 99999, а не 2.

Инициализатор в определении массива (то есть массив в стиле C) должен должен быть списком в фигурных скобках.

Это правило распространяется как на вашу строку 1, так и на строку 2, где вы предоставляете что-то, что не является списком в фигурных скобках, и поэтому код неверен.

Дополнительная информация: когда вы предоставляете список в фигурных скобках, каждый элемент списка берется в качестве инициализатора для элемента ан массива. Как следствие, невозможно указать один инициализатор, который приводит к установке им нескольких элементов массива.

Это правило почти применимо рекурсивно; если у вас есть массив массивов, то инициализатор должен быть списком фигурных скобок. Однако есть правило, что в некоторых случаях вложенные фигурные скобки могут быть опущены (и код будет вести себя так, как если бы были предоставлены полные скобки). Например, int x[2][2] = { 1, 2, 3, 4 }; разрешено и ведет себя как int x[2][2] = { {1, 2}, {3, 4} };.