assert in Array-Initialisierung

[Ben (Gast)]

Hallo,

folgendes kompilierbare Minimalbeispiel:

#define CHECK_VALUE(val)      (val)

int myArray[] =
{
    CHECK_VALUE(8),
    CHECK_VALUE(9),
    CHECK_VALUE(10)
};


int main(void)
{

}

Wie man sieht macht CHECK_VALUE momentan noch garnichts, außer den Wert 
wieder "zurückzugeben".

Ich wollte nun das Makro dementsprechend erweitern dass
a) weiterhin der Wert zurückgegeben wird
b) mittels assert ein Compile-Zeit Check durchgeführt wird, ob der Wert 
im Range ist (Bsp: <= 9)


Das krieg ich nicht hin, also hab ich erstmal geschaut ob ein 
_Static_assert in einer Arrayinitialisierung überhaupt klappt:

#define CHECK_VALUE(val)      (val)

#define MY_ASSERT(val)  _Static_assert (val <= 9, "assert1");

int myArray[] =
{
    CHECK_VALUE(8),
    CHECK_VALUE(9),
    CHECK_VALUE(10)
    MY_ASSERT(10)

};


int main(void)
{

}

Hier meckert der Compiler:

../main.c:46:3: error: expected '}' before '_Static_assert'

Der Aufruf erfolgt mittels -std=c11.
Ist das was ich vorhabe überhaupt möglich?
Kann man _Static_assert wirklich nur in Funktionen und "freestanding" 
verwenden?
Gibt es andere Lösungen?

Viele Grüße

[Oliver (Gast)]

Ein define macht immer grundsätzlich nur eine Textersetzung. Der 
Compiler bekommt das also gar nicht zusehen, der sieht immer nur den 
schon aufgelösten Code.

Das sollte deine beiden Fragen beantworten. (die  nach dem 
static_define, und die die, warum es jetzt nicht geht).

Oliver

[Ben (Gast)]

Oliver schrieb:
> Ein define macht immer grundsätzlich nur eine Textersetzung....

Das ist mir schon klar.

Ich kann auch schreiben:

int myArray[] =
{
    CHECK_VALUE(8),
    CHECK_VALUE(9),
    CHECK_VALUE(10)
    _Static_assert (10 <= 9, "assert1");
};

was natürlich das selbe ist.

Das klappt aber, natürlich mit der gleichen Fehlermeldung, ebenfalls 
nicht.

Weswegen ich auch hier nachfrage ob mein Unterfangen nicht durchführbar 
ist, d.h. ich _Static_assert einfach falsch verwende.

[Karl H. (kbuchegg)]

Ben schrieb:

> Weswegen ich auch hier nachfrage ob mein Unterfangen nicht durchführbar
> ist, d.h. ich _Static_assert einfach falsch verwende.

Ich denke das kann hier nicht wirklich funktionieren, weil an dieser 
Stelle ja nur Initialisierungs-Ausdrücke möglich sind. Ein 
_Static_assert ist aber kein Ausdruck, der einen Wert liefern würde. 
Daher wäre das logisch gesehen an dieser Stelle schon mal nicht möglich.

Hmm. Ich denke, da musst du zurück zur alten Technik der Präprozessor 
#if Anweisungen, so die aufgrund der Datentypen einsetzbar sind.

[Ben (Gast)]

Karl Heinz schrieb:
> _Static_assert ist aber kein Ausdruck, der einen Wert liefern würde.
> Daher wäre das logisch gesehen an dieser Stelle schon mal nicht möglich.

Danke KH.

Ich war irgendwie der Meinung, ein _Static_assert würde im OK-Fall zu 
"garnix" expandieren, so dass es überall stehen kann.

Die Lösung mit #if ... #error hatte ich schonmal, die funktioniert 
grundsätzlich.

Allerdings stelle ich gerade auf ein Array um, so dass ich eine Variable 
Anzahl an Einträgen verwalten kann. Dementsprechend wüsste ich nicht, 
wie eine Lösung mit #if... hier aussehen würde. Ein #if ist ja erstmal 
ein statisches Konstrukt. Ändert sich die Anzahl an Einträgen im Array 
müsste der #if Block jedesmal angepasst werden.
Diesen Aufwand wollte ich durch mein CHECK_VALUE Makro direkt bei der 
Initialisierung erschlagen.

Gibt es da vielleicht noch einen anderen Weg?

[B. S. (bestucki)]

Solche Dinge erledige ich normalerweise mit Funktionen, diese wird 
einmalig bei Programmstart aufgerufen:

assert(CheckMyArray());

Wird nun NDEBUG definiert, fällt der Funktionsaufruf automatisch weg. In 
der finalen Version hinterlässt diese Variante also keine Spuren.

[Karl H. (kbuchegg)]

Ich orientiere mich jetzt hierran

http://books.google.at/books?id=MAAuAgAAQBAJ&pg=PA762&lpg=PA762&dq=_Static_assert&source=bl&ots=Y-ma7f-uC3&sig=lLe2lPQ6c9OZPHGHWIRc8sfbvGA&hl=de&sa=X&ei=W9M7VInsEYqS7AbP6YCoCQ&ved=0CCkQ6AEwAjgK#v=onepage&q=_Static_assert&f=false

In Terms of syntax, _Static_assert is treated as a declaration statement.

Daher kann das an dieser Stelle nicht funktionieren. Du kannst ja auch 
nicht

int ij[5] = { 1, 2, 3, extern int k };

schreiben.

> Ich war irgendwie der Meinung, ein _Static_assert würde
> im OK-Fall zu "garnix" expandieren, so dass es überall stehen kann.

Das spielt in dem Fall keine Rolle mehr. Die Frage ist, wie 
_Static_assert in die Syntax eingebaut wurde.

[Ben (Gast)]

Soweit OK.

Leider bringt mich das nicht wirklich weiter. Was ich bisher weiß ist, 
dass es mit _Static_assert wohl nicht klappen wird. Wenn es eine andere 
Lösung gibt wär ich aber auch zufrieden.

Im Prinzip will ich ja sowas hier haben:

#define CHECK_VALUE(val)    #if (val >= ERROR_VAL)   \
                                #error Out of Range! \
                            #else                    \
                                (val)                \
                            #endif

int myArray[] =
{
    CHECK_VALUE(8),
    CHECK_VALUE(9),
    CHECK_VALUE(10)
};

Das der Code nicht kompiliert ist mir klar.
Aber er sollte deutlich machen was ich will. Mit asserts kann ich diese 
Funktionalität also nicht erreichen.
Das Beispiel oben klappt auch nicht.

Hat jemand vielleicht noch einen Vorschlag?

Viele Grüße!

[PittyJ (Gast)]

Ich verstehe den Sinn nicht so ganz.
Im Normalfall weiß doch der Programmierer am besten, welche Konstanten 
er in den Code hinein kompiliert. Warum sollte der Kompiler die 
Konstanten noch einmal abprüfen?

Benutzereingaben werden geprüft. Aber das macht ein Programm ja erst zur 
Laufzeit und nicht schon zur Kompilierzeit.

[Ben (Gast)]

Auch wenn der Sinn nicht Thema dieses Threades werden soll:

Es handelt sich um Konfigurationseinträge, die auf Plausibilität geprüft 
werden sollen. Ist kein Muss, denn wie du schon sagst sollte der 
Programmierer wissen was erlaubt ist und was nicht. Schöner fände ichs 
aber wenns nochmal überprüft wird. Allerdings nur, wenn dies zur 
Compilezeit möglich ist, denn Ressourcen (ROM oder RAM) will ich dafür 
nicht aufwenden.

Beispiel: in sämtlichen UART-Beispielen die man hier findet prüft der 
Präprozessor die Baudrate auch nochmal (z.B. ob der Fehler größer 2% 
ist).
Dadurch wird verhindert, dass Code kompiliert wird der anschließend 
wahrscheinlich nicht zufriedenstellend läuft. Findest du das auch 
unsinnig? Ist im Prinzip das gleiche wie ich vorhabe.

[Daniel A. (daniel-a)]

Ich kenne _Static_assert nicht, aber man kann ja ausprobieren ;)
Funktioniert fileicht sowas, den komma operator nutzen?

#define CHECK_VALUE(val)  (_Static_assert (val <= 9, "assert1"), val)

int myArray[] =
{
    CHECK_VALUE(8),
    CHECK_VALUE(9),
    CHECK_VALUE(10)
};

Oder eine Makroliste (getestet)?

// header file
#ifndef STR
#define STR(x) #x
#endif
#ifndef EVAL
#define EVAL(x,y) x(y)
#endif
#define SEMIKOLON ;
#define KOMMA ,
#define BUILD_ARRAY(x) x
#define CHECK_ARRAY(x) _Static_assert(CHECK(x), "Assert failed in " __FILE__ ":" EVAL(STR,__LINE__) " for value " #x ": expression " EVAL(STR,CHECK(x)) " is false!")

// c file

#define CHECK(x) x <= 9
#define LISTE(E,D) \
  E(8) D\
  E(9) D\
  E(10)

LISTE(CHECK_ARRAY, SEMIKOLON);

int myArray[] = {
  LISTE(BUILD_ARRAY, KOMMA)
};

#undef LISTE
#undef CHECK

[B. S. (bestucki)]

Daniel A. schrieb:
> #define CHECK_VALUE(val)  (_Static_assert (val <= 9, "assert1"), val)

Das funktioniert nicht. Der Compiler meckert schon, wenn man das 
static_assert nur umklammert:

(static_assert(1, "test")); // [Error] expected expression before '_Static_assert'

Scheinbar funktioniert folgendes:

static const char Help__ = ' ';
#define CHECK(val) (((val) < 10) ? Help__ : val)

Ist val kleiner 10, wirft der Compiler folgende Fehlermeldung:

[Error] initializer element is not constant

Etwas unschön, da die Fehlermeldung nicht direkt etwas mit der Prüfung 
des Wertes zu tun hat, aber immerhin eine Fehlermeldung.