Konstanten in C++ [static const]

Tobias Gerg

Hallo zusammen,

ich sitze gerade über einem Problem mit statischen Konstanten. Bisher bin ich immer dem (Irr-)glauben aufgesessen, dass statische Konstanten, die mit static const angelegt werden, keinen Speicher verbrauchen, bzw. wenn sie Speicher brauchen, nur einmal angelegt werden.

Folgendes Szenario hat mich gerade eines besseren belehrt:

// test.h
static const int u = 32;

// test1.h
void Func();

// test1.cpp
#include "test.h"
#include <iostream>

void Func()
{
   using namespace std;
   cout << &u << endl;  // 0x443000
}

#include "test.h"
#include "test1.h"

int main()
{
   using namespace std;
   cout << &u << endl;  // 0x443004
}

Wie lege ich dann typsichere Konstanten in Headerdateien an, wenn das, da static ja für jede Übersetzungseinheit eine eigene Variable anlegt, so wie gezeigt nicht funktioniert?

Compiler ist MinGW g++ Version: 3.4.5 (mingw-vista special r3)

Gruß
Tobi

gibts da klassenvererbung?
ohne objekt?

static sagt ja das die variable zur gesamten laufzeit existiert und const das sie nicht verändert wird, also bei deinem Beispiel der Wert 32.

Wie das jetzt bei der Adresse ausschaut, kann ich dir aber leider auch nicht sagen.

volkard

wollten wir nicht von static const int innerhalb einer klasse schreiben? außerhalb schreibt doch keiner static davor.

Tobias Gerg

volkard schrieb:

wollten wir nicht von static const int innerhalb einer klasse schreiben? außerhalb schreibt doch keiner static davor.

Ok... Ich geb dir recht, dass static muss da weg...
Aber auch wenn ich nur

// test.h
const int u = 32;

schreibe. Bekomm ich dass selbe Ergebnis. u wird für jede übersetzungseinheit angelegt.

Wenn ich dass nicht will, muss ich dann wirklich wieder auf

#define u 32

zurückgreifen?

Gruß
Tobi

theta

static im globalen namespace hat auch eine wirkung.
die variable ist dann nur in der jeweiligen kompilier einheit gültig (zugreifbar).

Simon

volkard

der speicher wurde nur angelegt, WEIL du die adresse gezogen hast.
willste es genau einmal haben, also nicht wegoptimiert, aber auch nicht mehrfach, deklariere extern const int in dem header und definiere einmal const in in der cpp-datei.

Tobias Gerg

theta schrieb:

static im globalen namespace hat auch eine wirkung.
die variable ist dann nur in der jeweiligen kompilier einheit gültig (zugreifbar).

Simon

Dass ist mir klar. Darum hab ich dass static einmal entfernt.
Trotzdem hab ich in den Übersetzungseinheiten test.cpp und test1.cpp zwei Variablen die jeweils an unterschiedlichen Adressen liegen...

Gruß
Tobi

volkard

theta schrieb:

static im globalen namespace hat auch eine wirkung.
die variable ist dann nur in der jeweiligen kompilier einheit gültig (zugreifbar).
Simon

aber vor "const" schreibt global keiner "static", denn das steht schon unsichtbar da. allenfalls schreibt man "extern", was das unsichtbare static löscht.

Tobias Gerg

volkard schrieb:

der speicher wurde nur angelegt, WEIL du die adresse gezogen hast.
willste es genau einmal haben, also nicht wegoptimiert, aber auch nicht mehrfach, deklariere extern const int in dem header und definiere einmal const in in der cpp-datei.

Danke,

genau das wars....

Gruß
Tobi

pumuckl

theta schrieb:

static im globalen namespace hat auch eine wirkung.
die variable ist dann nur in der jeweiligen kompilier einheit gültig (zugreifbar).

Simon

Das ist der große unterschied zwischen static auf globaler bzw. namespace Ebene und static innerhalb von Klassen. Folgendes gibt jeweils zweimal die gleiche Adresse aus:

//test.h
extern const int u;

struct X
{
  static const int u;
};

void* func();
void* Xfunc();

//test.cpp
#include "constants.h"

const int u = 32;

const int X::u = 35;

void* func()
{ return (void*)&u; }

void* Xfunc()
{ return (void*)&X::u; }

//main.cpp
#include <iostream>
#include "constants.h"

void* foo() {return (void*)&u;}
void* Xfoo() {return (void*)&X::u;}

using namespace std;

int main()
{
   cout << "func()" << func() << endl;
   cout << "foo()" << foo() << endl << endl;
   cout << "Xfunc()" << Xfunc() << endl << "Xfoo()" << Xfoo() << endl;
}

theta

Genau. Und dasselbe gilt für den anonymen namespace.