Verständnisproblem Grammatikrelgel member-declaration

hicks

Hallo,

ich verstehe die folgende C++ Regel nicht (Ausschnitt aus der Grammatik):

member-declaration:
...
::opt nested-name-specifier templateopt unqualified-id ;
...

Was wird hier deklariert? Kennt jemand ein Beispiel für das o.a. Konstrukt?

Vielen Dank,

J.B.

pumuckl

währe evtl. günstig wenn du den kontext dazu mitlieferst.

hicks

Hier die vollständige Grammatikregel (C++ Grammatik, iso/ansi):

member-declaration:
decl-specifier-seqopt member-declarator-listopt ;
function-definition ;opt
::opt nested-name-specifier templateopt unqualified-id ;
using-declaration
template-declaration

Diese Regel definiert, wie Klassenmember einer Klasse aussehen dürfen. Im einfachsten Fall sind es Membervariablen, -Funktionen oder Funktionsdefinitionen (die ersten beiden Regeln decken das ab).
Die letzen beiden Regeln ermöglichen using und template-Deklarationen in einer Klassendefinition:

class A {
int variableDecl; // first rule
void functionDecl(); // first rule
void functionDef() { }; // second rue
??? //
using ::std::string; // introdues type string into this namespace, fourth rule
template <class T> void f(T); // templated function, fifth one
}

Meine Frage ist, was die mittlere Regel darstellen soll. Ich habe die ISO/ANSI-Beschreibung nach der Regel durchforstet, werde jedoch nicht schlau.

Th

Forward-Deklaration auf eine verschachtelte (nested) Subklasse oder Struktur, z.B.

class X
{
  class Y; // <- dieser Konstrukt

  Y *m_y;

  // now the declaration:
  class Y
  {
     // ...
  }
};

hicks

Danke für die Antwort, aber das ist es nicht (ist eine Kombination aus decl-specifier und member-declarator). Das fehlende Konstrukt scheint irgendetwas mit templates zu tun zu haben. Schlau werde ich daraus allerdings nicht.

Th

Sorry, hab noch mal im Stroustrup nachgeschaut, es geht schon um nested-Members, z.B.

class X
{
   struct S
   {

   };
};

class Y
{
    X::S m_x; <- nested member
};

Das template-Schlüsselwort ist ja als optional deklariert, kann also entfallen, ebenso "::" am Anfang (also z.B. ::X::S m_x).

Zum template Schlüsselwort bei Methoden-Aufrufen habe ich folgendes Beispiel gefunden:

The Keyword template as Qualifier

Use the keyword template as a qualifier to distinguish member templates from other names. The following example illustrates when you must use template as a qualifier:

class A
{
public:
template<class T> T function_m() { };
};

template<class U> void function_n(U argument)
{
char object_x = argument.function_m<char>();
}
The declaration char object_x = argument.function_m<char>(); is ill-formed. The compiler assumes that the < is a less-than operator. In order for the compiler to recognize the function template call, you must add the template quantifier:
char object_x = argument.template function_m<char>();

wobei ich jetzt auch keine Fall weiß, wo man explizit "template" in einer Member-Deklaration schreibt, evtl. ist es ein Hint für den Compiler bei Namensgleichheit?

Ich hoffe, dies hilft dir weiter...

hicks

Danke, danke, das ist es.

otze

wobei ich jetzt auch keine Fall weiß, wo man explizit "template" in einer Member-Deklaration schreibt, evtl. ist es ein Hint für den Compiler bei Namensgleichheit?

//edit ich glaub, damit ist sowas gemeint

template<class Klasse,class T>
class X
{
    typename Klasse:: template S<T> m_x; <- das hier
};

struct Klasse
{
   template<class U>
   struct S
   {
        U inhalt;
   };
};

int main(){
	X<Klasse,int> objekt;
}