Ошибка «элемент инициализатора не является константой» при попытке инициализировать переменную с помощью const

Я получаю сообщение об ошибке в строке 6 (инициализация my_foo для foo_init) следующей программы, и я не уверен, что понимаю почему.

typedef struct foo_t {
    int a, b, c;
} foo_t;

const foo_t foo_init = { 1, 2, 3 };
foo_t my_foo = foo_init;

int main()
{
    return 0;
}

Имейте в виду, что это упрощенная версия большого многофайлового проекта, над которым я работаю. Цель состояла в том, чтобы в объектном файле была одна константа, которую несколько файлов могли бы использовать для инициализации структуры состояний. Так как это встроенная цель с ограниченными ресурсами и структура не такая маленькая, я не хочу иметь несколько копий исходного кода. Я бы предпочел не использовать:

#define foo_init { 1, 2, 3 }

Я также пытаюсь написать переносимый код, поэтому мне нужно решение, которое действительно C89 или C99.

Связано ли это с ORG в объектном файле? Что инициализированные переменные входят в одну ORG и инициализируются путем копирования содержимого второй ORG?

Может быть, мне просто нужно изменить свою тактику и сделать так, чтобы функция инициализации делала все копии при запуске. Разве есть другие идеи?

В языке C объекты со статической продолжительностью хранения должны быть инициализированы с помощью константных выражений или с помощью агрегатных инициализаторов, содержащих константные выражения.

«Большой» объект никогда не является константным выражением в C, даже если объект объявлен как const.

Кроме того, в языке C, термин «константа» относится к буквенным константам (как 1, 'a', 0xFFи так далее), членам перечислений, и результатам таких операторов , как sizeof. Константные объекты (любого типа) не являются константами в терминологии языка Си. Их нельзя использовать в инициализаторах объектов со статической продолжительностью хранения независимо от их типа.

Например, это НЕ константа

const int N = 5; /* `N` is not a constant in C */

Выше Nбыло бы константой в C ++, но это не константа в C. Так что, если вы попытаетесь сделать

static int j = N; /* ERROR */

вы получите ту же ошибку: попытка инициализировать статический объект с непостоянной.

По этой причине в языке C мы преимущественно используем #defineдля объявления именованных констант, а также #defineдля создания именованных агрегатных инициализаторов.

Это ограничение языка. В разделе 6.7.8 / 4:

Все выражения в инициализаторе для объекта со статической продолжительностью хранения должны быть константными выражениями или строковыми литералами.

В разделе 6.6 спецификация определяет, что должно считаться константным выражением. Нет, где говорится, что переменная const должна считаться константным выражением. Это допустимо для компилятора расширять this ( 6.6/10 - An implementation may accept other forms of constant expressions), но это ограничит переносимость.

Если вы можете изменить my_fooего, чтобы у него не было статического хранилища, все было бы в порядке:

int main()
{
    foo_t my_foo = foo_init;
    return 0;
}

Просто для иллюстрации путем сравнения и контрастирования Код взят с http://www.geeksforgeeks.org/g-fact-80/ / Код не работает в gcc и передается в g ++ /

#include<stdio.h>
int initializer(void)
{
    return 50;
}

int main()
{
    int j;
    for (j=0;j<10;j++)
    {
        static int i = initializer();
        /*The variable i is only initialized to one*/
        printf(" value of i = %d ", i);
        i++;
    }
    return 0;
}

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

#include <stdio.h>
typedef struct foo_t  {
    int a; int b; int c;
} foo_t;
static const foo_t s_FooInit = { .a=1, .b=2, .c=3 };
// or a pointer
static const foo_t *const s_pFooInit = (&(const foo_t){ .a=2, .b=4, .c=6 });
int main (int argc, char **argv) {
    const foo_t *const f1 = &s_FooInit;
    const foo_t *const f2 = s_pFooInit;
    printf("Foo1 = %d, %d, %d\n", f1->a, f1->b, f1->c);
    printf("Foo2 = %d, %d, %d\n", f2->a, f2->b, f2->c);
    return 0;
}

GCC 7.4.0 не может скомпилировать коды, как показано ниже:

#include <stdio.h>
const char * const str1 = "str1";
const char * str2 = str1;
int main() {
    printf("%s - %s\n", str1, str2);
    return 0;
}

constchar.c: 3: 21: ошибка: элемент инициализатора не является константным const char * str2 = str1;

Фактически, строка "const char *" не является константой времени компиляции, поэтому она не может быть инициализатором. Но строка "const char * const" является константой времени компиляции, она должна быть в состоянии быть инициализатором. Я думаю, что это небольшой недостаток CLang.

Имя функции, конечно, является константой времени компиляции. Так что этот код работает:

void func(void)
{
    printf("func\n");
}
typedef void (*func_type)(void);
func_type f = func;
int main() {
    f();
    return 0;
}