Konstante für mehrere Dateien deklarieren & sofort benutzen

[Stefan S. (stefanst)]

Hallöchen!
Ich will eine Art Konstante definieren, die ich dann auch sofort zur 
Deklaration eines public-Array benötige. Dafür habe ich bisher #define 
benutzt. Da ich die Konstante aber in mehreren Dateien, die ich mit 
Header-Dateien verknüpfe, brauche, stellt sich mir die Frage, wie dies 
am einfachsten zu realisieren ist.
Muss ich in jeder Datei

#define konstante

einfügen, oder geht das auch noch anders? Ich habe auch schon über das 
Schlüsselwort const nachgedacht, aber da mein Code in zwei Dateien im 
Prinzip so aussieht wie folgt, habe ich das noch nicht hingekriegt...

const char konstante = 5;
char array[konstante];

Wie muss das aussehen, damit es auch im Zusammenspiel mit mehreren 
Dateien funktioniert (zB. mit extern ?)?

Viele Grüße,
Stefan

[Helmut L. (helmi1)]

In deiner Hauptdatei schreibst du

const char konstante = 5;


In den anderen Datei kannst du dann mit

extern const char konstante;

darauf zu greifen.

Gruss Helmi

[Karl H. (kbuchegg)]

Stefan S. schrieb:

> Muss ich in jeder Datei
>

#define konstante

> einfügen, oder geht das auch noch anders?

Du nimmst das #define in eine eigene Datei, die du überall inkludierst.

>

> const char konstante = 5;
> char array[konstante];
>

Nein, das geht nicht.
In C sind das keine echten Konstanten

[Stefan S. (stefanst)]

Das heißt, es gibt keine andere Möglichkeit, als das ganze mit #define 
zu realisieren?
Und warum ist const keine echte Konstante?

@Helmi:
Das habe ich versucht, aber der Compiler meldet dann immer den Fehler
error C221: non-constant case/dim expression

Ich könnte mir vorstellen, dass dies daran liegt, dass die Konstante und 
das Array als Public deklariert werden... stimmt das?

[Klaus W. (mfgkw)]

Karl heinz Buchegger schrieb:
> Stefan S. schrieb:
>
>> Muss ich in jeder Datei
>>

#define konstante

>> einfügen, oder geht das auch noch anders?
>
> Du nimmst das #define in eine eigene Datei, die du überall inkludierst.
>
>>

>> const char konstante = 5;
>> char array[konstante];
>>

>
> Nein, das geht nicht.
> In C sind das keine echten Konstanten

kommt drauf an...

Nach Standard C89 geht es nicht, nach C99 meines Wissens doch und
der gcc kann es auf jeden Fall.

[Klaus W. (mfgkw)]

Stefan S. schrieb:
> Das heißt, es gibt keine andere Möglichkeit, als das ganze mit #define
> zu realisieren?
> Und warum ist const keine echte Konstante?

const heisst nicht, daß es eine Konstante wäre, sondern nur
daß du den Wert nicht mehr ändern willst.
Älteren C-Compilern reicht das nicht; für eine Feldlänge
ist es nicht const genug...

Z.B. sagt const volatile... explizit, daß der Programmierer
die Variable (keine Konstante!) nicht ändern will, daß aber
jemand anders zur Laufzeit evtl. den Wert manipuliert.

> ...

[Helmut L. (helmi1)]

Eine richtige Konstante ist das nicht wie die anderen schon sagten.

>Das habe ich versucht, aber der Compiler meldet dann immer den Fehler
>error C221: non-constant case/dim expression

Welcher Compiler ist das denn ?

Kann das sien das du diese Konstante in einem switch / case konstrukt 
verwenden willst ?
Das geht so nicht.

Diese const brauch ich meistens um feste Texte u. Tabelle abzuspeichern.

[Stefan S. (stefanst)]

Also ich will eigentlich nur ein public Array der Größe x deklarieren. 
Da ich dieses Array im gesamten Programm benötige und das Programm in 
einzelne Module aufgeteilt ist, habe ich Probleme, den einzelnen Modulen 
klar zu machen, dass ein Array[x] existiert... um Änderungen einfach zu 
machen, wollte ich halt nicht

char array[16];

sondern

const char x = 16;
char array[x];

schreiben...
Hat jemand eine Idee, wie man das realisieren kann (ohne in jedes Modul 
ein "#define" zu beutzen oder immer ein extra-Modul einzubinden)?

Viele Grüße,
Stefan

PS: Ich nutze den Compiler von Keil (µVision3)

[Klaus W. (mfgkw)]

Wenn du deinem Compiler beibringen kannst (z.B. weil es der gcc ist?),
den Standard C99 zu verwenden (beim gcc mit der Option --stdd=c99),
dann sollte es so gehen wir du es ursprünglich vorhattest.

Wenn nicht, musst du es mit #define machen.
Evtl. ist es für dich angenehmer, das #define nicht direkt in den
Quelltext zu schreiben, sondern als Compileroption zu übergeben.
Beim gcc (und vermutlich bei anderen auch, von VC++ weiß ich es)
geht das mit der Option -D, also z.B. beim Compilieren mit angeben:
... -DANZAHL=150 ...
Das wirkt dann wie ein #define ANZAHL 150 am Anfang des Quelltextes.

[Klaus W. (mfgkw)]

achso, noch eine Möglichkeit ist natürlich, als globale Variable
nicht das Feld zu vereinbaren, sondern nur einen Zeiger darauf.
Außerdem eine weitere globale Variable für die Anzahl der
Elemente. Dann denkt man sich im Programm irgendwie zu
Programmstart die Anzahl aus und allokiert mit malloc() dann
das Feld.
Ich behaupte nicht, daß das eleganter wäre, aber zumindest eine
Möglichkeit.

[Karl H. (kbuchegg)]

Wo liegt eigentlich das Problem mit #define ?


module.h
********

#ifndef MODULE_H_INCLUDED
#define MODULE_H_INCLUDED

#define NR_ENTRIES  16
extern int Values[ NR_ENTRIES ];

void init( void );

#endif

module.c
********

#include "module.h"

int Values[NR_ENTRIES];

void init( void )
{
  unsigned char i;

  for( i = 0; i < NR_ENTRIES; ++i )
    Values[i] = 0;
}

main.c
******

#include "module.h"

int main()
{
  unsigned char i;

  init();

  for( i = 0; i < NR_ENTRIES; ++i )
    printf( "%d\n", Values[i] );
}

Wenn du irgendwo sonst nach NR_ENTRIES benötigst, dann inkludierst du 
dort einfach ebenfalls module.h und hast die 'Konstante' auch dort 
verfügbar.

[Stefan S. (stefanst)]

Hmm... also ich habe mal gegoogelt, aber noch nichts brauchbares dafür 
gefunden, ob man unter µVision3 auch mit c99-Standard kompilieren 
kann... weiß das jemand?

Grüße

EDIT: Okay, danke an Karl, ich probiers mal so ;-) (falls jemand zu 
obigem doch noch eine Idee hat, gerne schreiben!)