C++ explizite Instanziierung von Nicht-Template-Typ

Question

Ich lese ein Buch über C++. Ich bin immer noch ziemlich dazu, aber ich versuche immer noch, die wesentlichen Dinge erledigt zu bekommen. Dieser Abschnitt beinhaltet die Vererbung, und das Ziel besteht darin, eine Formklasse zu erstellen und dann darauf mit ersten zweidimensionalen Formen und dann dreidimensionalen Formen, die aus zweidimensionalen Formen aufbauen, aufzubauen.

Bisher war ich in der Lage, die zweidimensionalen Formen vollständig zu vervollständigen. Die Funktionen dort funktionieren gut. Ich bin jetzt auf dreidimensionale Formen umgestiegen, und da stoße ich auf ein kleines Problem.

Das Buch sagt, ein System zu implementieren, das für Länge, Höhe und für dreidimensionale Breite entweder Ints oder Floats zulässt, also habe ich eine Vorlage in sie, um das zu tun. Hier denke ich, dass ich auf Probleme stoße.

Ich habe kopiert und die zweidimensionale Klasse in die dreidimensionale Klasse und versuchen, es von dort zu vervollständigen. Dann habe ich es zu einem kleinen Problem gemacht.

Wenn ich versuche zu kompilieren, bekomme ich zwei Hauptfehler.

Fehler: ‚Threed‘ ist keine Klassenvorlage Fehler: explizite Instanziierung Nicht-Template-Typs ‚ThreeD‘

Ich denke, das kleinste Stück, das mit dem entsprechenden Informationen vorgelegt werden muss. Denken Sie daran, main.cpp, shape.h, shape.cpp, twod.h und twod.cpp funktionieren zwar so, aber ich habe die vollständigen Header und nicht die anderen cpps eingefügt.

Jede Hilfe, die Sie zur Verfügung stellen könnten, wäre großartig.

Ich habe die ThreeD.cpp an die Spitze gesetzt, da der Fehler von dort kommt.

Ich glaube nicht, dass es ein Duplikat von "Warum können Vorlagen nur in der Header-Datei implementiert werden?" weil der Code gut mit der TwoD-Klasse funktioniert, nur nicht mit der ThreeD-Klasse.

ThreeD.cpp

#include <iostream> 
#include <string> 
#include "shape.h" 
#include "TwoD.h" 

using namespace std; 

template class ThreeD<int>; 
template class ThreeD<float>; 


    template <class T> 
    ThreeD<T>::ThreeD (string oobj, int osides, T olength, T oheight, T owidth) 
     : TwoD<T>(oobj, osides, olength, oheight) 
    { 
     setObject(obj); 
     setSides(sides); 
     setLength(length); 
     setHeight(height); 
     setWidth(owidth); 
    } //End of TwoD constructor 

template <class T> 
int ThreeD<T>::getSides() { 
    return sides; 
} //End of function getSides 

main.cpp

#include <iostream> 
#include "shape.h" 
#include "TwoD.h" 
#include "ThreeD.h" 

using namespace std; 

int main() { 


TwoD<float> triangle("Triangle", 3, 3, 3); 

ThreeD<float> cube("Cube", 6, 3, 3, 3); 
} 

Shape.h

#ifndef SHAPE_H 
#define SHAPE_H 

#include <string> 

using namespace std; 

//Implimenting template <class T> as a means to have the sides 
//variable become either a float or an int. 
template <class T> 
class Shape { 

public: 
    Shape(string, int, T); 
// void setObject(string); //Used to ensure constructor works 
    virtual void setObject(string) = 0; 
//Used setObject as virtual function since constructor uses it to 
//Make the object using the setObject function. 
    string getObject(); 
    int getSides(); 
    bool setSides(int); 
    float getLength(); 
    void setLength (T); 

    float getPerimeter(string, T); 
    float getArea (string, T); 

    void display(); 
private: 
    string object; 
    int sides; 
    T length; 
}; 

#endif 

Shape.cpp

#include <iostream> 
#include <string> 
#include "shape.h" 

using namespace std; 

//Telling the compiler template class of Shape which versions for T to 
//expect either int or float. 
template class Shape<int>; 
template class Shape<float>; 

//Constructor of Shape. Inputs shape, sides, and length. 
    template <class T> 
    Shape<T>::Shape (string shapes, int sides, T length){ 
     setObject(shapes); 
     setSides(sides); 
     setLength(length); 
    } //End of Shape constructor 

TwoD.h

#ifndef TWOD_H 
#define TWOD_H 

#include <string> 
#include "shape.h" 

using namespace std; 

//Implimenting template <class T> as a means to have the sides 
//variable become either a float or an int. 
template <class T> 
class TwoD : public Shape<T> 
{ 

public: 
    TwoD(std::string, int, T, T); 
    void setObject(string); //Used to ensure constructor works 
// virtual void setObject(string) = 0; 
//Used setObject as virtual function since constructor uses it to 
//Make the object using the setObject function. 
    string getObject(); 
    int getSides(); 
    bool setSides(int); 
    T getLength(); 
    void setLength (T); 
    T getHeight(); 
    void setHeight (T); 

    float getPerimeter(string, T, T); 
    float getArea (string, T, T); 

    void display(); 
private: 
    string object; 
    int sides; 
    T length; 
    T height; 
}; 

#endif 

TwoD.cpp

#include <iostream> 
#include <string> 
#include "shape.h" 
#include "TwoD.h" 

using namespace std; 

//Telling the compiler template class of TwoD which versions for T to 
//expect either int or float. 
template class TwoD<int>; 
template class TwoD<float>; 

//Constructor of TwoD. Inputs TwoD, sides, and length. 
    template <class T> 
    TwoD<T>::TwoD (string obj, int sides, T length, T height) 
     : Shape<T>(obj, sides, length) 
    { 
     setObject(obj); 
     setSides(sides); 
     setLength(length); 
     setHeight(height); 
    } //End of TwoD constructor 

ThreeD.h

#ifndef THREED_H 
#define THREED_H 

#include <string> 
#include "shape.h" 
#include "TwoD.h" 

using namespace std; 

//Implimenting template <class T> as a means to have the sides 
//variable become either a float or an int. 
template <class T> 
class ThreeD : public TwoD<T> 
{ 

public: 
    ThreeD(std::string, int, T, T, T); 
    void setObject(std::string); //Used to ensure constructor works 
// virtual void setObject(string) = 0; 
//Used setObject as virtual function since constructor uses it to 
//Make the object using the setObject function. 
    string getObject(); 
    int getSides(); 
    bool setSides(int); 
    T getLength(); 
    void setLength (T); 
    T getHeight(); 
    void setHeight (T); 

    T getWidth(); 
    void setWidth (T); 

    float getPerimeter(string, T, T, T); 
    float getArea (string, T, T, T); 

    void display(); 
private: 
    std::string object; 
    int sides; 
    T length; 
    T height; 
    T width; 
}; 

#endif 

Answer 1

In ThreeD.cpp Sie brauchen:

#include "ThreeD.h" 

Ohne dass die Linie template class ThreeD<int>; Marken Nein Sinn für den Compiler, weil ThreeD nicht deklariert wurde.