Wie erstellt man abgeleitete Klassen aus einer Basisklasse mit Template-Programmierung in C++?

Question

Ich muss eine Anzahl von Klassen (mehr als 50) aus einer Basisklasse erstellen, wobei der einzige Unterschied in den Namen der abgeleiteten Klassen besteht.

Zum Beispiel ist meine Basisklasse definiert als:

class BaseError : public std::exception 
{ 
private: 
    int osErrorCode; 
    const std::string errorMsg; 

public: 
    int ec; 
    BaseError() : std::exception(), errorMsg() {} 

    BaseError (int errorCode, int osErrCode, const std::string& msg) 
     : std::exception(), errorMsg(msg) 
    { 
     ec = errorCode; 
     osErrorCode = osErrCode; 
    } 

    BaseError (const BaseError& other) 
     : std::exception(other), errorMsg(other.errorMsg) 
    { 
     ec = other.errorCode; 
     osErrorCode = other.osErrorCode; 
    } 

    const std::string& errorMessage() const { return errorMsg; } 

    virtual ~BaseError() throw(){} 

} 

ich viel abgeleiteten Klassen von dieser Basisklasse zu schaffen, haben jeweils ihre eigene Konstrukteure haben, Copy-Konstruktor und die virtuelle Destruktorfunktion, ich derzeit am Kopieren/Einfügen der Code die Namen zu ändern, wenn nötig:

class FileError : public BaseError{ 
private: 
    const std::string error_msg; 

public: 
    FileError() :BaseError(), error_msg() {} 

    FileError (int errorCode, int osErrorCode, const std::string& errorMessage) 
     :BaseError(errorCode, osErrorCode, errorMessage){} 

    virtual ~FileError() throw(){} 
}; 

Frage: gibt es eine Möglichkeit, diese Klassen haben Vorlagen verwendet, so dass die im Plementation wird nicht wiederholt?

Answer 1

Ich nehme an, Sie möchten eine Klassenhierarchie erstellen, so dass Sie dynamischen Versand in Ihren catch-Klauseln verwenden können (basierend auf dem Compiler, um den richtigen Typ herauszufinden), um benutzerdefinierte Fehlerbehandlung zu implementieren. Sie können dies tun, indem Sie die BaseError-Klasse beibehalten und eine Vorlagenklasse hinzufügen, für die Sie dann mehrere Instanziierungen bereitstellen. Bedenken Sie:

class BaseError : public std::exception 
{ 
private: 
    int osErrorCode; 
    const std::string errorMsg; 

public: 
    int ec; 
    BaseError() : std::exception(), errorMsg() {} 

    BaseError (int errorCode, int osErrCode, const std::string& msg) 
     : std::exception(), errorMsg(msg) 
    { 
     ec = errorCode; 
     osErrorCode = osErrCode; 
    } 

    // ... 
}; 

template <int T> 
class ConcreteError : public BaseError { 
public: 
    ConcreteError() :BaseError(), error_msg() {} 

    ConcreteError (int errorCode, int osErrorCode, const std::string& errorMessage) 
     :BaseError(errorCode, osErrorCode, errorMessage){} 
}; 

können Sie nun eingerichtet einige Typdefinitionen:

typedef ConcreteError<0> FileError; 
typedef ConcreteError<1> NetworkError; 
typedef ConcreteError<2> DatabaseError; 
// ... 

Sie jetzt eine Hierarchie mit drei verschiedenen Fehlerklassen haben.

Answer 2

Wenn die Implementierung genau gleich ist und Sie nur einen anderen Namen für jede Klasse haben möchten, dann würde simple typedef Ihre Aufgabe erfüllen.

Und wenn es einen kleinen Unterschied in der Implementierung gibt, aber nicht in der Schnittstelle, dann brauchen Sie wahrscheinlich Vorlagen. Dann bedenken Sie auch policy based design.

Answer 3

Wenn die Implementierungen identisch sind, erstellen Sie eine Enumeration und eine Vorlage.

enum error { 
    file_error, 
}; 
template<error e> class my_exception : public BaseError { 
    .... 
}; 
typedef my_exception<file_error> file_exception;