Templates oder virtuelle Schnittstellen??

[chetigol]

Hi,

überlege gerade, was ich im folgenden Beispiel eher verwenden sollte! Irgendwie hab ich gerade schwierigkeiten mich zu entscheiden.

Ich baue eine Klasse, welche gewisse Daten aus einer Datenbank bereitstellen soll, welche der beiden Implementierungsarten wäre "sauberer" ?

1. virtuelles Interface


class DbInterface {}; // abstractes db interface

class KonkretesDbInterface : public DbInterface {};

class DatenBereitsteller
{
private:
bool check()
{
if ( database.ok() == false ) ....
}


public:
DatenBereitsteller( DbInterface& db ) : database(db)
{
db.connect();
.....
}

Daten1 getDaten1() { db.exec("SELECT...."); .... }
Daten2 getDaten2() { db.exec("SELECT...."); .... }
Daten3 getDaten3() { db.exec("SELECT...."); .... }
};

int main()
{
DbInterface* db = new KonkretesDbInterface( DbParameter );

DatenBereitsteller daten(*db);
}



2. Templates:



template<typename Database>
class DatenBereitsteller
{
private:
bool check()
{
if ( database.ok() == false ) ....
}


public:
DatenBereitsteller( Database& db ) : database(db)
{
db.connect();
.....
}

Daten1 getDaten1() { db.exec("SELECT...."); .... }
Daten2 getDaten2() { db.exec("SELECT...."); .... }
Daten3 getDaten3() { db.exec("SELECT...."); .... }


};

int main()
{
KonkretesDbInterface db( DbParameter );

DatenBereitsteller<KonkretesDbInterface> daten(db);
}



Ich tendiere eher zu der Methode mit Templates! Da der Datentyp der Datenbank Immer zur Laufzeit bekannt ist und sich auch zur Laufzeit nicht ändert.

Aber irgendwie bin ich mir nicht sicher! Wenn ich mir viele Template-Implementierungen anschaue, so werden diese meistens für Container-Klassen oder irgendwelche statischen Berechnungen verwendet. sehe aber selten Programme, wo Templates als "Ersatz" für dynamischen Polymorphismus verwendet werden.

[Gast]

Bist du dir auch bewusst, was der Unterschied ist? Templates werden für jede Parameter-Kombination (hier nur der Database-Typ) instanziiert, d.h., benutzt du 10 DB-Typen, gibts auch 10 Datenbereitsteller-Klassen im finalen code. Exzessive Nutzung führt also zu code-bloating. Der Vorteil liegt aber u.a. darin, dass man so auf virtuelle Methoden in Database-Typen (die halt ein nicht-explizites interface implementieren müssen) verzichten könnte, deren Aufruf sonst immer etwas performance kostet.
Aber die Anbindung zur DB dürfte sowieso nicht blitzschnell sein, so würde ich hier ein klassisches interface mit virtuellen Methoden vorziehen.

[chetigol]

Bist du dir auch bewusst, was der Unterschied ist? Templates werden für jede Parameter-Kombination (hier nur der Database-Typ) instanziiert, d.h., benutzt du 10 DB-Typen, gibts auch 10 Datenbereitsteller-Klassen im finalen code. Exzessive Nutzung führt also zu code-bloating. Der Vorteil liegt aber u.a. darin, dass man so auf virtuelle Methoden in Database-Typen (die halt ein nicht-explizites interface implementieren müssen) verzichten könnte, deren Aufruf sonst immer etwas performance kostet.
Aber die Anbindung zur DB dürfte sowieso nicht blitzschnell sein, so würde ich hier ein klassisches interface mit virtuellen Methoden vorziehen.

jup, der unterschied ist mir bewusst. geht mir eher um "was ist schöner" ... falls es so etwas überhaupt gibt in diesem zusammenhang. Bzw, wie andere dies lösen würden.

Edit: Aber dein Einwand mir der "langsamen" Datenbankverbindung hat was! Auch wenn es mir von der Implementierung eher die Templatebasierte Methode eher zusagt.

[Gnafoo]

Imho klar das Interface, weil:


Der Overhead vom virtual-Call dürfte hier vollkommen irrelevant sein.

Etwas weniger Code-Bloat im Vergleich zum Template.

Templates haben den hässlichen Effekt, das am Ende meist alles im Header landet (→ höhere Compile-Zeiten).

Interfaces ermöglichen das Auswechseln der Implementierung zur Laufzeit (abhängig vom Config-File, mit Plugins, …).

Das Interface listet die erforderlichen Methoden für die Implementierung an einer Stelle zentral auf (→ Übersichtlicher).

C++ kann leider noch keine Concepts (http://en.wikipedia.org/wiki/Concepts_(C%2B%2B)). Daher muss man beim Template mit miesen Fehlermeldungen leben, wenn etwas in der Klasse fehlt.

„Viraler“ Effekt: Beim Template braucht alles was die Datenbank nutzen möchte plötzlich selbst einen Template-Parameter.


5+6 gehören eigentlich zusammen. Bei Templates gibt es einfach keinen richtigen „Contract“, der festlegt, was der Typ unterstützen soll. Das muss man dann meist selbst dokumentieren und imho ist das unschön, wenn es umfangreicher wird.