C++Talk.NET

Boris Glawe · Guest

Hallo,

unten habe ich ich eine Klassentemplate Master.

In diesem Template ist eine Klasse Nested definiert. Damit diese Klasse
etwas zu tun hat, speichert sie eine Integer Instanzvariable mit dem
Wert 42.

Master speichert eine Instanzvariable vom Typ Nested und vom Typ T.
Letztere ist nur dazu da, um den Datentyp T überhaupt zu benutzen.

Ärger macht die Methode getNested() in Master. Ich weiß nicht, wie der
Datentyp der Nested Klasse aussieht. Mein Vorschlag unten wird vom
Compiler nicht akzeptiert. Ich möchte also eine Referenz auf die
Instanzvariable nested zurückliefern. Wie sieht deren Typ aus? Mein
Compiler beschwert sich bei folgendem Code mit folgender Meldung:

g++ -o test test.cpp -Wall -O3
test.cpp:53: Fehler: expected constructor, destructor, or type
conversion before »&« token
test.cpp: In constructor »Master<T>::Master(T&) [with T = char]«:
test.cpp:78: instantiated from here
test.cpp:41: Fehler: Abhängigenname »Master<T>::Nested« wird als
Nicht-Typ erkannt, aber die Instanziierung liefert einen Typ
test.cpp:41: Anmerkung: »typename Master<T>::Nested« sagen, wenn ein Typ
gemeint ist

Zusätzlich gefällt ihm irgend etwas am Konstruktor von Master<T>::Master
nicht. Kann aber diese Geheimsprache nicht deuten :-)

Grüße Boris

Hier der Code:

----------------------------------------------------------
#include <iostream>
#include <map>

using namespace std;

template <typename T>
class Master
{

public:
class Nested
{
public:
Nested();
int getValue() const;
private:
int value;
};

Master(T&);

Nested& getNested() const;

private:

Nested nested;
T dummyValue;
};

/*
Das Aufrufen des Konstruktors "Master<T>::Nested()"
schlaegt fehl. Wie lautet der korrekt Name des Konstruktors?
*/

template <typename T>
Master<T>::Master(T& dv) :
nested( Master<T>::Nested() ),
dummyValue(dv)
{}

/*
Hier mault der Kompiler, weil er mit dem Typ
"Master<T>::Nested &" nichts anfangen kann.
Wenn ich mich nicht taeuschen, dann ist das aber
der Typ der Instanzvariablen "nested"!?
*/
template <typename T>
Master<T>::Nested & getNested const
{
return nested;
}

template <typename T>
Master<T>::Nested::Nested() :
value(42)
{}

template <typename T>
int Master<T>::Nested::getValue() const
{
return value;
}

int main(){

char c = 'g';

Master<char> m(c);

}

Thomas Maeder · Guest

Boris Glawe <boris@boris-glawe.de> writes:

Falk Tannhäuser · Guest

Boris Glawe schrieb: