Fehler "Initialisierungselement ist nicht konstant" beim Versuch, eine Variable mit const zu initialisieren

Ich erhalte eine Fehlermeldung in Zeile 6 (initialisiere my_foo auf foo_init) des folgenden Programms und bin mir nicht sicher, warum.

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;
}

Beachten Sie, dass dies eine vereinfachte Version eines größeren Projekts mit mehreren Dateien ist, an dem ich arbeite. Das Ziel war es, eine einzige Konstante in der Objektdatei zu haben, mit der mehrere Dateien eine Statusstruktur initialisieren können. Da es sich um ein eingebettetes Ziel mit begrenzten Ressourcen handelt und die Struktur nicht so klein ist, möchte ich nicht mehrere Kopien der Quelle. Ich würde es vorziehen, nicht zu verwenden:

#define foo_init { 1, 2, 3 }

Ich versuche auch, portablen Code zu schreiben, daher benötige ich eine Lösung, die C89 oder C99 gültig ist.

Hat dies mit den ORGs in einer Objektdatei zu tun? Dass initialisierte Variablen in eine ORG gehen und durch Kopieren des Inhalts einer zweiten ORG initialisiert werden?

Vielleicht muss ich nur meine Taktik ändern und alle Kopien beim Start von einer Initialisierungsfunktion ausführen lassen. Es sei denn, es gibt andere Ideen da draußen?

In der Sprache C müssen Objekte mit statischer Speicherdauer mit konstanten Ausdrücken oder mit aggregierten Initialisierern mit konstanten Ausdrücken initialisiert werden.

Ein "großes" Objekt ist in C niemals ein konstanter Ausdruck, selbst wenn das Objekt als deklariert ist const.

Darüber hinaus ist in der Sprache C, bezieht sich der Begriff „konstant“ , um Literalkonstanten (wie 1, 'a', 0xFFund so weiter), ENUM - Mitglieder, und die Ergebnisse derartiger Operatoren als sizeof. Konstantenqualifizierte Objekte (jeglicher Art) sind keine Konstanten in der C-Sprachterminologie. Sie können unabhängig von ihrem Typ nicht in Initialisierern von Objekten mit statischer Speicherdauer verwendet werden.

Dies ist beispielsweise KEINE Konstante

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

Das Obige Nwäre eine Konstante in C ++, aber es ist keine Konstante in C. Wenn Sie es also versuchen

static int j = N; /* ERROR */

Sie erhalten den gleichen Fehler: einen Versuch, ein statisches Objekt mit einer Nichtkonstante zu initialisieren.

Dies ist der Grund, warum wir in der C-Sprache vorwiegend #definebenannte Konstanten deklarieren und #definebenannte aggregierte Initialisierer erstellen.

Es ist eine Einschränkung der Sprache. In Abschnitt 6.7.8 / 4:

Alle Ausdrücke in einem Initialisierer für ein Objekt mit statischer Speicherdauer müssen konstante Ausdrücke oder Zeichenfolgenliterale sein.

In Abschnitt 6.6 definiert die Spezifikation, was als konstanter Ausdruck betrachtet werden muss. Nein, wo steht, dass eine const-Variable als konstanter Ausdruck betrachtet werden muss. Es ist für einen Compiler legal, this ( 6.6/10 - An implementation may accept other forms of constant expressions) zu erweitern, dies würde jedoch die Portabilität einschränken.

Wenn Sie Änderungen vornehmen können, my_foodamit kein statischer Speicher vorhanden ist, sind Sie in Ordnung:

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

Nur zur Veranschaulichung durch Vergleich und Kontrast Der Code stammt von http://www.geeksforgeeks.org/g-fact-80/ / Der Code schlägt in gcc fehl und wird in g ++ / übergeben

#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;
}

Das ist ein bisschen alt, aber ich bin auf ein ähnliches Problem gestoßen. Sie können dies tun, wenn Sie einen Zeiger verwenden:

#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 kann keine Codes wie folgt kompilieren:

#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: Fehler: Initialisiererelement ist nicht konstant const char * str2 = str1;

Tatsächlich ist eine Zeichenfolge "const char *" keine Konstante zur Kompilierungszeit, daher kann sie kein Initialisierer sein. Ein "const char * const" -String ist jedoch eine Konstante zur Kompilierungszeit. Er sollte ein Initialisierer sein können. Ich denke, das ist ein kleiner Nachteil von CLang.

Ein Funktionsname ist natürlich eine Konstante zur Kompilierungszeit. Dieser Code funktioniert also:

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