Template-Funktion: Typ-Parameter T soll Ableitung von X sein

[Glocke]

Hi,

ich suche eine Möglichkeit zu erzwingen, dass einen Template-Parameter von einem Typ X abgeleitet ist. Beispiel (über den Sinn lässt sich streiten ^^):

Code: Alles auswählen

#include <iostream>

struct Base {
    void foo(int val) {}
};

struct Special: public Base {
	void foo(int val) {
	    std::cout << "Special: " << val << std::endl;
	}
};

struct Foo: public Base {
	void foo(int val) {
	    std::cout << "Foo: " << val << std::endl;
	}
};

template <class T> T create(int val) {
	T tmp;
	tmp.foo(val);
	return tmp;
}

int main() {
	Special s = create<Special>(5);
	Foo f = create<Foo>(5);
	//int i = create<int>(5); <-- so etwas soll nicht gehen dürfen
}

Die Überlegung template <class T: Base> zu schreiben, mag g++ syntaktisch nicht.
Klar erzwinge ich zur Compilerzeit, dass die Aufrufe der Funktion mit einem Typ erfolgen, der die Funktion void foo(int) hat, allerdings ist mir das noch etwas wenig.

Die generische Programmierung habe ich in Java kennengelernt. Ist das was ich machen will in C++ sinnvoll bzw. möglich?
Ich hoffe ich habe verständlich genug geschrieben was ich meine

Schönen Sonntag
LG Glocke

[Xin]

Hi,

ich suche eine Möglichkeit zu erzwingen, dass einen Template-Parameter von einem Typ X abgeleitet ist. Beispiel (über den Sinn lässt sich streiten ^^):

Über den Sinn lässt sich eigentlich gar nicht streiten, aber eine kostenlose Lösung gibt es nicht.

Das einzige, was mir spontan einfällt ist im Konstruktor ein Cast auf die Klasse X zu setzen. Ist T von X abgeleitet, geht das (kostet aber ein wenig Rechenzeit, daher vielleicht nur im Debug-Modus machen). Ist T nicht von X abgeleitet führt das zu einem Kompilierfehler.

Die generische Programmierung habe ich in Java kennengelernt. Ist das was ich machen will in C++ sinnvoll bzw. möglich?

Es ist leider nicht möglich. Allerdings - Achtung - Du kannst in C++ keine Generics erzeugen! Templates erzeugen für alle Typen eigene Programmteile. Du kannst mit Templates alles machen, was Du mit Generics machen kannst, und auch mehr. Aber ein Template ist kein Generic!

[Glocke]

Naja ich hab einfach mal folgendes probiert:

Code: Alles auswählen

#include <iostream>

struct Base {
    std::string name;
    Base() {
        this->name = "Base";
    }
    void foo(int val) {
        std::cout << "Base: " << val << this->name << std::endl;
    }
};

struct Special: public Base {
    Special() {
        this->name = "Special";
    }
	void foo(int val) {
	    std::cout << "Special: " << val << this->name << std::endl;
	}
};

struct Foo: public Base {
    Foo() {
        this->name = "Foo";
    }
	void foo(int val) {
	    std::cout << "Foo: " << val << this->name << std::endl;
	}
};

template <class Base> Base create(int val) {
	Base tmp;
	tmp.foo(val);
	return tmp;
}

int main() {
        Base b = create<Base>(5);
	Special s = create<Special>(5);
	Foo f = create<Foo>(5);
	//int i = create<int>(5); <-- so etwas soll nicht gehen dürfen
}

Quasi als Typparameter den Basistyp angegeben ... offenbar klappt das - oder sieht das nur so aus? Er verwendet die richtigen Methoden usw.... jetzt bin ich verwirrt