static array initialisieren
Chris
Folgendes Szenario: Ich m�chte ein statisches array in einer Funktion
der Form
void myFunc(...)
{
static double myArray[n];
...
};
bei ihrem *ersten* Aufruf mit lauter Nullen initialisieren.
Wie funktioniert das, ohne da� bei jedem Aufruf das komplette array
wieder �berschrieben wird?
Danke,
Chris
Thomas Koller
So wie es da steht passiert das schon, du brauchst also nichts mehr tun.
:-)
Tom
Jan Seiffert
> Hallo Leute!
>
> Folgendes Szenario: Ich möchte ein statisches array in einer Funktion
> der Form
>
> void myFunc(...)
> {
> static double myArray[n];
>
> ...
> };
>
> bei ihrem *ersten* Aufruf mit lauter Nullen initialisieren.
> wieder überschrieben wird?
>
Eine statische Initialisierung sieht z.B. so aus:
static double my_array[3] = {0.0, 1.0, 2.0};
Man kann die Anzahl der Arrayelemente weglassen, wenn man nur soviele Elemente
Platz braucht wie man Initialisierungselemente hat (sonst wird der Rest mit 0
aufgefuellt).
Statische Arrays ohne expliziete Initialisierung sollten aber von der
Laufzeitumgebung beim start sowieso mit binaer 0 gefuellt worden sein.
Falls das nicht so ist, ist deine Laufzeitbibliothek entweder kaputt oder falls
das so gewollt ist sollte sie deutlich darauf hinweisen (oder du hast es so
gewollt, weil du z.B. den Compiler (unbewusst?) in den freestanding mode
umgestellt hast). Dann ist aber auch immer die Gefahr gegeben das expliziete
statische Initialisierer auch nicht funktionieren.
Plattformabhaengige Details:
- Ob ein "binaer 0" auch einer 0 in diesem Datentyp entspricht, ist zwar nicht
garantiert, aber meist gegeben (Ganzzahlen eigentlich unkritisch, NULL-Pointer
ist seltenst was anderes als 0, nicht-IEEE Fliesskommazahlen sind auch selten).
- Hier ergibt sich naemlich eine Optimierungsmoeglichkeit. Mit initialisierer
landen deine statischen Arrays in der .data section und belegen Platz im
Executable, ohne initialisierer (also mit 0 vorbelegt) landen deine statischen
Arrays typischerweise in der .bss section und belegen keinen Platz im Executable.
> Danke,
>
> Chris
Gruss
Jan
--
Nur selten nimmt der Handelsmann statt baren Geldes Stuhlgang an
John D.
Auch wenn mein Problem damit schon gelöst ist, bin ich doch neugierig
geworden:
> Eine statische Initialisierung sieht z.B. so aus:
> static double my_array[3] = {0.0, 1.0, 2.0};
Wie ist das in dem Fall, daß ich mit vielen (>>3) Werten initialisieren
möchte, die soetwas wie einem "Bildungsgesetz" unterliegen? Soetwas
würde man ja i.A. in Form einer Schleife umsetzen, aber an welcher
Stelle? Immer noch das nicht-überschreiben-wollen bei erneutem
Funktionsaufruf im Hinterkopf.
Grüße, Chris
Thomas Koller
> Auch wenn mein Problem damit schon gel�st ist, bin ich doch neugierig
>
>> Eine statische Initialisierung sieht z.B. so aus:
>> static double my_array[3] = {0.0, 1.0, 2.0};
>
> m�chte, die soetwas wie einem "Bildungsgesetz" unterliegen?
Geht nicht, beim initialisieren musst du alle Werte angeben, bzw. wenn du
weniger angibst wird der Rest einfach mit 0 initialisiert.
> Soetwas
> w�rde man ja i.A. in Form einer Schleife umsetzen, aber an welcher
> Stelle? Immer noch das nicht-�berschreiben-wollen bei erneutem
> Funktionsaufruf im Hinterkopf.
Sobald du das in einer Schleife machst, ist das kein initialisieren
mehr sondern ein normales zuweisen. Dann musst du selbst daf�r sorgen,
dass es nur beim ersten Durchlauf beschrieben wird.
(z.b. �ber eine statische boolsche Variable die du beim ersten Durchlauf
zur�cksetzt).
Tom
Jan Seiffert
die einfachste Loesung ist "straight forward":
int my_func(/* whatever */)
{
static double my_array[1 << 3];
static bool init_done;
if(!init_done)
{
int i = sizeof(my_array)/sizeof(my_array[0]);
while(i--)
{
/* tolle formel hier */
my_array[i] = ...;
}
init_done = true;
}
/* normaler code */
}
hat aber zwei Nachteile:
- Der code wird zur Laufzeit immernoch einen "kurzen" check auf init_done
enthalten, das kann, wenn jede instruktion zaehlt, unerwuenscht sein.
- Das ist nicht Thread safe (ja, C kennt keine Threads, aber denoch sollte es
erwaehnt werden)
Ist aber fuer einfache Faelle ausreichend.
Oder wenn Platz keine Rolle spielt (ist halt eine Sache wie Gross das Array nun
ist) zur kompilierzeit aus einem Programm die Daten + etwas C Fluff drumherum
erzeugen, so das man das in einen Compiler schmeissen kann und zum entgueltigen
Programm hinzu linken.
Man kann die dynamische initialisierung aber auch verschieben an den Anfang des
Programms (oder vor der ersten Benutzung, wenn man das Sauber einhalten kann):
double my_array[1 << 3];
int my_func(/* whatever */)
{
/* normaler code der was tolles mit my_array tut */
}
int main(int argc, char *argv[])
{
int i = sizeof(my_array)/sizeof(my_array[0]);
while(i--)
{
/* tolle formel hier */
my_array[i] = ...;
}
/* rufe my_func() ganz oft auf */
}
es ist sinnvoll das in Funktionen auszulagern, besonders wenn das Programm ueber
mehrere Module verteilt ist:
#include "my_func.h"
#include "my_otherfunc.h"
int main(int argc, char *argv[])
{
my_func_init();
my_otherfunc_init();
/* rufe my_func() und my_otherfunc() ganz oft auf */
}
<voellig OT>
Und noch ein Hinweis aus dem Naehkaestchen:
Weil das fehleranfaellig und unbequem ist, kannst du, falls du den GCC
verwendest, mal das ausprobieren:
double my_array[1 << 3];
static void __attribute__((__constructor__)) my_func_init(void)
{
/* init my_array */
}
int my_func(/* whatever */)
{
/* normaler code der was tolles mit my_array tut */
}
</voellig OT>
> Grüße, Chris
Gruss
Jan
--
Fachbegriffe der Informatik:
44: Verdeckter Fehler
Siemens hat mitentwickelt. (Jörg Pechau)
Claus Reibenstein
¯¯¯¯¯¯¯
John wer?
Anfangs hast Du Dich noch "Chris" genannt (und warst deshalb von meinem
Realnamenplausibilitätsfilter zuverlässig entsorgt worden). Auf solche
Pseudonymspielchen hat hier niemand Lust.
Poste mit Deinem realen Namen, wenn Du ernst genommen werden möchtest.
> Wie ist das in dem Fall, daß ich mit vielen (>>3) Werten initialisieren
> möchte, die soetwas wie einem "Bildungsgesetz" unterliegen? Soetwas
> würde man ja i.A. in Form einer Schleife umsetzen, aber an welcher
> Stelle? Immer noch das nicht-überschreiben-wollen bei erneutem
> Funktionsaufruf im Hinterkopf.
Poste mit Deinem realen Namen, und Du bekommst von mir eine Lösung (die
übrigens trivial ist).
Gruß. Claus
Georg Bauhaus
Konstante Werte für den Initialisierer eines statischen
arrays würden ja dem compiler bekannt gemacht werden. Die
Werte entstehen nicht erst im fertig übersetzten, laufenden
Programm. Ein Fall also für ein weiteres Programm, das eben
den Initialisierer des ersten Programms schreibt.
Nach dem "Bildungsgesetz" für die Werte des Initialisierers.
Ralf Damaschke
> Eine statische Initialisierung sieht z.B. so aus:
> static double my_array[3] = {0.0, 1.0, 2.0};
> Man kann die Anzahl der Arrayelemente weglassen, wenn man nur soviele
> Elemente Platz braucht wie man Initialisierungselemente hat (sonst
> wird der Rest mit 0 aufgefuellt).
>
> Statische Arrays ohne expliziete Initialisierung sollten aber von der
> Laufzeitumgebung beim start sowieso mit binaer 0 gefuellt worden sein.
Nein, siehe unten.
> Plattformabhaengige Details:
>
> - Ob ein "binaer 0" auch einer 0 in diesem Datentyp entspricht, ist
> zwar nicht garantiert, aber meist gegeben (Ganzzahlen eigentlich
> unkritisch, NULL-Pointer ist seltenst was anderes als 0, nicht-IEEE
> Fliesskommazahlen sind auch selten).
Das macht nichts. Bei einer impliziten Initialisierung wird mit
dem *Wert* 0 initialisiert.
-- Ralf
Claus Reibenstein
> Claus Reibenstein schrieb:
>
>> Anfangs hast Du Dich noch "Chris" genannt (und warst deshalb von meinem
>> Realnamenplausibilitätsfilter zuverlässig entsorgt worden). Auf solche
>> Pseudonymspielchen hat hier niemand Lust.
>
> Du legst deine Ansichten als dominierenden Maßstab aus.
> Die Realname-Dogmatiker sind längst in der Minderheit.
Woher nimmst Du diese Gewissheit? Nur weil viele nicht mehr auf solche
Spielchen reagieren? Das liegt vermutlich daran, dass die meisten
Regulars ihre Filter längst angepasst haben und diesen Quatsch deshalb
oft gar nicht erst mitbekommen.
Gruß. Claus