Wie haben eine Struktur mit der Vorlage mit einer Klasse

Mit diesem code (nur eine Klasse von test):

typedef unsigned short UInt16;

template<class T>
class CClass
{
public:
    SValue* getNewSValue(void);
private:
    typedef struct {
        T *mValue;
        T *next;
        T *previous;
        UInt16 index;
    } SValue;
};

template<typename T>
SValue* CClass<T>::getNewSValue(void)
{
    return new SValue;
}

Habe ich die folgenden Fehler:

Fehler B. c2143: Syntaxfehler : fehlendes
';' vor '*'

error C4430: fehlender type-specifier -
int angenommen. Hinweis: C++ nicht
Unterstützung von default-int

Ist es möglich, eine Struktur in einer Klasse? Wenn ich erkläre das struct aus der Klasse der Vorlage nicht sieht, dass die Vorlage T.

+1: gut formatierte Frage

InformationsquelleAutor okami | 2010-09-06

c++struct templates

3

$9.2/2 - Der Schlüssel ist die unten Zitat aus der C++ Standard03

`Eine Klasse ist als eine komplett-definiert den Objekt-Typ (3.9) (oder die komplette Art) beim schließen } die class-specifier. Innerhalb der Schüler-Spezifikation, die Klasse wird als abgeschlossen betrachtet, innerhalb der Funktion Körper, default-Argumente und-Konstruktor ctor-Initialisierungen (wie unter anderem in geschachtelten Klassen). Sonst gilt es als unvollständig-innerhalb der eigenen Klasse Mitglied-Spezifikation.

Weiß nicht, was ist UINT16, aber das folgende sollte funktionieren
```
template<class T> 
class CClass 
{ 
private: 
    typedef struct { 
        T *mValue; 
        T *next; 
        T *previous; 
        short int index;                      //Replacing with int for illustration only
    } SValue; 
public:
    SValue* getNewSValue(void); 
private: 
}; 
```
EDIT 3: Die *** kam es zu versuchen, um die änderung FETT (das hätte ich sowieso gelöscht)
```
template<class T> typename CClass<T>::SValue* CClass<T>::getNewSValue(void) 
{ 
    return new SValue; 
}

int main(){
    CClass<int> s;
    s.getNewSValue();
}
```
- Was ist der Zweck der typename klappenmechanismus in der definition von getNewSValue ? Das ist, weil SValue ist Unbenannt und wir haben zu finden, um es mit den typedef Namen ?
- wenn wir weglassen typename es würde analysiert werden, wie die definition von einem Mitglied namens SValue Klasse CClass<T>, für die kein Typ angegeben war: tempate<class T> Class<T>::SValue;. Die folgenden Token werden würde, junk-und abgelehnt durch den compiler als Fehler in der syntax. All dies ist, da der compiler standardmäßig annimmt, nicht-Typen, wenn es nicht lookup-ein name, der auf der parse-Zeit (ich.e er weiß nicht, was T noch, also kann es nicht lookup SValue). Wenn Sie typename, SValue ist richtig, gilt als Typname für das Mitglied getNewSValue.
- Der code, den Sie setzen es generiert die folgende Fehlermeldung: "Fehler C2244: 'CClass<T>::getNewSValue' : unable to match-Funktion die definition einer vorhandenen Erklärung"
- Danke !
- für eine Weile Ihr verwirrt mich mit dem dreifach-Zeiger (*'s). Ich denke, es sollte SValue* und nicht SValue***
- Ja, es ist meine Schuld. Ich war versucht, um es FETT und dann beschlossen, es nicht zu tun. Also habe ich manuell entfernt, das führende ** aber vergessen hat, die nachfolgende sind 🙁 editiert meinen post entsprechend
InformationsquelleAutor Chubsdad
1

Da die member-Funktion definition ist im globalen Bereich, die Sie benötigen, um sich zu qualifizieren, deren Rückgabetyp mit CClass:: zu verweisen, um den Namen innerhalb der Klasse scope. Auch die typename - Schlüsselwort ist erforderlich, wenn auf typenames verschachtelten Vorlagen.
```
template<typename T>
typename CClass<T>::SValue* CClass<T>::getNewSValue(void)
```
Auch, die geschachtelte Struktur struct ist Unbenannt. Beachten Sie, dass in C++, Klassen und Strukturen die korrekten Namen, und ein typedef-name ist nicht der name einer Klasse. Sie werden viel besser dran, die Vermeidung der Typdefinition.
```
struct SValue {
    T *mValue;
    T *next;
    T *previous;
    UInt16 index;
};
```
- Diese ist sehr ausführlich :-), Aber die Kartoffel Ihren code erzeugt, der folgenden Fehler auf der Zeile: typename CClass<T>::SValue* CClass<T>::getNewSValue(void) FEHLER ---> "Fehler C2899: typename kann nicht verwendet werden, die außerhalb einer template-Deklaration"
- halten Sie die template< typename T > Teil. Für weniger verbose syntax definieren Sie die Funktion in der class {} Umfang. Dann typename und Qualifikation (auf Klasse-lokalen Typen) sind nicht erforderlich.
InformationsquelleAutor Potatoswatter

Es sieht aus wie Ihre struct ist nicht definiert, wenn Sie deklarieren des Rückgabetyps von getNewSValue.

Mit, dass Sie keinen Fehler:

template<class T>
class CClass
{
public:
    SValue* getNewSValue(void);
private:
    typedef struct {
        T *mValue;
        T *next;
        T *previous;
        UInt16 index;
    } SValue;
};

template<typename T>
SValue* CClass<T>::getNewSValue(void)
{
  return new SValue;
}

Und Sie auch zu qualifizieren, die SValue zurück geben, denn es ist eingebettet in CClass wenn Sie es verwenden, um zu definieren getNewSValue.

InformationsquelleAutor Cedric H.

Erklären SValue vor getNewSValue():

template<class T> 
class CClass 
{ 
private: 
    typedef struct { 
        T *mValue; 
        T *next; 
        T *previous; 
        UInt16 index; 
    } SValue; 
public: 
    SValue* getNewSValue(void); 
};

Stellen Sie außerdem sicher, dass UInt16 definiert ist.

InformationsquelleAutor In silico

wie zu versuchen, diese ? er arbeitete auf VS2008

template<class T>
class CClass
{
private:
    typedef struct {
        T *mValue;
        T *next;
        T *previous;
        __int16 index;
    } SValue;

public:
    SValue* getNewSValue(void)
    {
        return new SValue;
    }
};

InformationsquelleAutor YeenFei

0

Den SValue-Typ ist innerhalb des CClass-namespace. Sie brauchen, um vollständig zu qualifizieren, die typename-außerhalb der Klasse.
```
template<typename T>
CClass<T>::SValue* CClass<T>::getNewSValue(void)
```
Außerdem sollten Sie SValue der öffentlichkeit, wenn es zurückgegeben wird, von einer öffentlichen Methode.

InformationsquelleAutor Markus Kull
0

Für die Aufzeichnung, keiner von diesen wird kompilieren (auf GCC 4.2 mindestens) sobald ein Anruf zu getNewSValue() genannt wird. Da es sich um eine öffentliche Methode gibt einen Zeiger auf einen privaten Typ, erhalten Sie eine compile-Fehlermeldung, die besagt, dass SValue is private.

Um für diese zu arbeiten, müssen Sie, um SValue öffentlichkeit, oder ändern Sie den Typ der return-Wert getNewSValue() etwas wie void*, da es scheint, dass Sie versuchen zu machen SValue ein undurchsichtiger Typ.

InformationsquelleAutor rossipedia

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.