je reçois « pas de fonction de membre déclaré en classe » erreur sur mon constructeur de copie quand je compile une classe

Question

Je templated suis en utilisant C++ et je suis en train de créer une classe basé sur un modèle (une pile). Je voudrais définir le constructeur de copie et l'opérateur d'affectation.

sont clairement définis dans l'en-tête, puis je les mettre en œuvre dans le fichier cpp.

Voici les problèmes que je reçois: - Pour le constructeur de copie: prototype pour 'Stack :: Stack (const Stack &)' ne correspond pas à la classe 'Stack' - Pour l'opérateur assignement: pile .cpp: 28: erreur: non 'Stack & Stack :: operator = (const Stack &)' fonction membre déclarée dans la classe 'Stack' - Pour le constructeur: stack.cpp: 4: erreur: le candidat est: Stack: : Stack()

Voici le fichier d'en-tête:

// stack.hpp 

#ifndef STACK_HPP 
#define STACK_HPP 


#include <stdio.h> 
#include <assert.h> 


template <class T> 
class Stack 
{ 

public: 
    Stack(); 
    ~Stack(); 

    Stack(const Stack&); 
    Stack& operator=(const Stack&); 


private: 
    T* v_; 
    size_t vsize_; 
    size_t vused_; 

}; 

Voici le fichier cpp:

// stack.cpp 

#include "stack.hpp" 

template <class T> 
Stack<T>::Stack() : 
    v_(0), 
    vsize_(10), 
    vused_(0) 
{ 
    v_ = new T[vsize_]; 
} 

template <class T> 
Stack<T>::~Stack() 
{ 
    delete[] v_; 
} 


// Stack(const Stack&); 
template <class T> Stack<T>::Stack(const Stack<T>& other) : 
    v_(NewCopy(other.v, other.vsize_, other.vsize_)), 
    vsize_(other.vsize_), 
    vuser_(other.vused) 
{ 
} 

// Stack& operator=(const Stack&); 
template<class T> Stack<T>& Stack<T>::operator=(const Stack<T>& other) 
{ 
    if (this != &other) 
    { 
    T* v_new = NewCopy(other.v_, other.vsize_, other.vsize__; 
    delvete v_; 
    v_ = v_new 
    vsize_ = other.vsize_; 
    vused_ = other.vused_; 
    } 
    return *this 

} 

Une dernière chose, voici le journal de la compilation:

g++ -c stack.cpp -o stack.o 
stack.cpp:20: error: prototype for ‘Stack<T>::Stack(const Stack<T>&)’ does not match any in class ‘Stack<T>’ 
stack.cpp:4: error: candidate is: Stack<T>::Stack() 
stack.cpp:28: error: no ‘Stack<T>& Stack<T>::operator=(const Stack<T>&)’ member function declared in class ‘Stack<T>’ 

Je suis sûr que ce soit seulement une petite erreur de faute de frappe, mais je ne peux pas semble le trouver. Merci pour votre aide

Answer 1

Vous ne pouvez pas compiler des modèles en unités de compilation séparée. En bref, tout le code du template doit être dans un en-tête. C'est probablement ce qui cause votre problème.

La raison en est que les modèles ne définissent pas de véritables classes. Les modèles spécifient comment le code peut être généré. Alors, quand vous faites une

Stack<int> myStack; 

Le compilateur utilise le modèle pour générer un constructeur de copie:

Stack<int>::Stack<int>(const Stack<int>& src); 

Ceci est un type complètement différent d'un

Stack<float> 

qui définira un tout constructeur de copie indépendant, et ensemble de méthodes complètement indépendant.

Une option beaucoup utilisent est d'inclure le cpp dans l'en-tête, dans un revers genre de passage.

-à-dire dans Stack.hpp, au fond

#include "Stack.cpp" 

mais ce genre de cache le fait que vraiment son tout juste balancé dans un en-tête.