// BEGIN File: Constant.h
#ifndef _CONSTANT_INCUDED_
#define _CONSTANT_INCUDED_

class Constant
{
public:
    Constant() {};
    ~Constant() {};

public:
    void foo(void);

public:
    static const int _SIZE;
};

#endif //_CONSTANT_INCUDED_

// END File: Constant.h

// BEGIN File: Constant.cpp
#include "Constant.h"
#include <stdio.h>

const int Constant::_SIZE = 10;

void Constant::foo(void)
{
    printf("Size = %i", Constant::_SIZE);
}

// END File: Constant.cpp

...und

// BEGIN File main.cpp
#include <stdio.h>
#include <stdlib.h>
#include "Constant.h"

void main(void)
{
unsigned char array1[Constant::_SIZE];                      // ERROR: keine Konstante
unsigned char *array2 = new unsigned char[Constant::_SIZE]; // OK

int test = 10;

    switch(test)
    {
        case Constant::_SIZE: // ERROR: keine Konstante
            break;

        case 3:
        default:
            break;
    }

    delete [] array2;
}

// END File: main.cpp

Habe ich da ein grundliegendes Verständnis problem, oder liegt hier ein Compilerbug vor?

Warum kann ich auf die public static const Konstante in main() nicht als Konstante zugreifen?

Schlimmer wird es, wenn ich Klassen von Constant.cpp ableiten will, die ebenfalls mit der Konstante der Vaterklasse arbeiten müssen.

Der Grund, warum es mit gcc funktioniert, könnte die VLA-Erweiterung für C++ sein.

2. <stdio.h> ist veraltet, heißt in C++ <cstdio>, selbes mit stdlib.h.

Das ist zwar korrekt, aber wenn er diese Änderungen in VS6 macht, gibt es wahrscheinlich noch mehr Fehler. VS6 wohnt im gleichen Altersheim wie <stdio.h> für C++

Grüssli

Compilezeit-Konstanten müssen direkt in der Klasse initialisiert werden. Woher soll der Compiler auch in A.cpp den Wert wissen, wenn er in B.cpp steht?

Der Grund, warum es mit gcc funktioniert, könnte die VLA-Erweiterung für C++ sein.

1. Klasse Constant.cpp hat einen Standardkonstruktor, somit gibt es zumindest die Konstante.

2. char *array2 = new char[Constant::_SIZE] funktioniert doch auch!

3. Zu den anderen Beiträgen: Hab das bis einschl VS 2005 ausprobiert

Grüsse

class Constant {
  static const int SIZE = 42;
};

Das geht bei älteren Compilern (ich vermute auch beim VC6) aber nicht, deshalb sieht man manchmal auch den enum-Trick:

class Constant {
  enum { SIZE = 42 };
}; // hoffe die Syntax ist richtig ...

_DEBUG schrieb:

2. char *array2 = new char[Constant::_SIZE] funktioniert doch auch!

Was hat das mit irgendwas zu tun? new[] benötigt weder eine Compilezeitkonstante noch überhaupt eine Konstante.

enum { _SIZE = 10 };

anstatt

static const int _SIZE = 10;

s.a. http://books.google.de/books?id=8E5P-Sa0SCcC&pg=PA31&lpg=PA31&dq=Myers+enum+workaround&source=bl&ots=Dh5G7uHgwo&sig=2aOaoHg-VScWJU5MAmpt3NQTSII&hl=de&ei=AXJqTL-JC4WBlAeI2eHCAg&sa=X&oi=book_result&ct=result&resnum=1&ved=0CBkQ6AEwAA#v=onepage&q&f=false

LordJaxom schrieb:

Compilezeit-Konstanten müssen direkt in der Klasse initialisiert werden. Woher soll der Compiler auch in A.cpp den Wert wissen, wenn er in B.cpp steht?

Der Grund, warum es mit gcc funktioniert, könnte die VLA-Erweiterung für C++ sein.

1. Klasse Constant.cpp hat einen Standardkonstruktor, somit gibt es zumindest die Konstante.

2. char *array2 = new char[Constant::_SIZE] funktioniert doch auch!

3. Zu den anderen Beiträgen: Hab das bis einschl VS 2005 ausprobiert

Grüsse

Gesagt, warum Du den alten Compiler überhaupt nutzt, hast Du noch nicht.
Und VS2005 ist zwar wesentlich besser als VC6, aber trotzdem 5 Jahre alt.

Das geht bei älteren Compilern (ich vermute auch beim VC6) aber nicht, deshalb sieht man manchmal auch den enum-Trick:

class Constant {
  enum { SIZE = 42 };
}; // hoffe die Syntax ist richtig ...

Yep, die zweite Variante scheint zu funktionieren.
Danke für den Tipp

3. Führende Unterstriche sind AFAIK dem Compiler vorbehalten, die haben in deinem Code nix zu suchen: _SIZE -> SIZE

Der relevante Teil des Standards liest sich wie folgt:

ISO/IEC 14882:2003 17.4.3.1.2 (1) schrieb:

— Each name that contains a double underscore (_ _) or begins with an underscore followed by an upper-case letter (2.11) is reserved to the implementation for any use.
— Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.165)

(...)

165. Such names are also reserved in namespace ::std (17.4.3.1).

Also:

class Constant {
  enum {
    _SIZE = 42, // BÖSE!
    _size = 42  // erlaubt
  };
};

int const _size = 42; // BÖSE!

Wobei man sich natürlich auch darüber streiten kann, wie guter Stil Constant::_size ist.