Hoffe habt eine Idee zu folgendem Problem:

Ich habe folgende Klasse Counter

template <class V>
class Counter
{
   public:
    Counter(){}
    virtual void Counter(){}

    virtual void Print()
    {
      // hier stream operationen, die nur fuer bestimmte V zulaessig sind
    }
};

Ich wuerde nun gerne obige Print Methode nur fuer bestimmte (!) Auspraegungen von Counter erlauben, z.B. nur fuer

Counter<int> 
// oder 
Counter<float>

wie sieht nun solch eine kindklasse aus ? weiss nicht wie das syntax-maessig aussehen muesste ..

danke.

mein problem laesst sich vielleichth aus so formulieren:

ich moechte nur bestimmte Typen fuer V bei der instanzierung erlauben,
z.B. alle standard-zahlen-datentypen

Counter<int>
Counter<float>
Counter<short>
..
usw.

aber nichts(!) anderes.

template <typename T, typename std::enable_if<std::is_fundamental<T>::value>::type* = nullptr>
class A { };

Alternativ, wenn du schöne Compiler-Fehlermeldungen willst, lässt du das enable_if weg und fügst dafür in jeden Konstruktor von A das ein:

static_assert(std::is_fundamental<T>::value, "Not allowed");

Naja du fragst hier schon nach zwei ziemlich unterschiedliche Sachen. Wenn du nur fundamentale Typen zulassen willst, kannst du das machen:

template <typename T, typename std::enable_if<std::is_fundamental<T>::value>::type* = nullptr>
class A { };

Alternativ, wenn du schöne Compiler-Fehlermeldungen willst, lässt du das enable_if weg und fügst dafür in jeden Konstruktor von A das ein:

static_assert(std::is_fundamental<T>::value, "Not allowed");

ok, vielen dank. allerdings gibt es vielleicht noch eine einschraenkung:
es muss auf linux (gcc/g++) compilierbar sein.

fuer std::is_arithmetic oder std::is_fundamental etc.
muss man <type_traits> includieren.

mein compiler g++(2.4.1) auf FreeBSD kennt diesen header nicht !?

laesst sich obiges vielleich mit partial template specialization machen (beispiel-code) !?

vielen dank.

Edit: http://www.gnu.org/software/gcc/releases.html GCC 2.4.1 ist aus dem Jahre 1993. Dein Ernst?

Du kannst es so probieren wie afdslol. Aber ehrlich gesagt solltest du stattdessen lieber deinen GCC aktualisieren und C++11 programmieren.

Edit: http://www.gnu.org/software/gcc/releases.html GCC 2.4.1 ist aus dem Jahre 1993. Dein Ernst?

ich programmiere das leider nicht fuer private zwecke sondern fuer eine firma. die entwicklungsumgebungsgegebenheiten lassen sich leider nicht so einfach upgraden.

template<typename T>
struct IsArithmetic
{
	static const bool Value = false;
};
template<>
struct IsArithmetic<bool>
{
	static const bool Value = true;
};
template<>
struct IsArithmetic<char>
{
	static const bool Value = true;
};
template<>
struct IsArithmetic<unsigned char>
{
	static const bool Value = true;
};
template<>
struct IsArithmetic<signed char>
{
	static const bool Value = true;
};
// ...

pepe75 schrieb:

..
zusaetzlich faellt mir auf, dass obiges erst zur laufzeit gecheckt wird (!?)

Falsch.

pepe75 schrieb:

ich programmiere das leider nicht fuer private zwecke sondern fuer eine firma. die entwicklungsumgebungsgegebenheiten lassen sich leider nicht so einfach upgraden.

Dazu fällt mir nun wirklich gar nichts ein...

Edit:

pepe75 schrieb:

laesst sich obiges vielleich mit partial template specialization machen (beispiel-code) !?

Hast du meinen Beitrag also ignoriert?

std::is_arithmetic etc. lässt sich auch ganz einfach mit einer älteren C++-Standardisierung implementieren:

Wenn es denn 1993 schon standardisiert gewesen wäre...

Das entschuldigt meiner Ansicht nach nicht, einen 21 Jahre alten Compiler zu benutzen (ist das BSD genauso alt?), aber sei's drum.
Zur Laufzeit wird hier garnichts geprüft. Das ist alles Compile-Time. C++ wurde zum ersten mal 1998 standardisiert, keine Ahnung also, was 5 Jahre davor schon im GCC implementiert war (insbesondere Template-Spezialisierung). Probiere es doch einfach aus, wie asdflol gesagt hat! Und denke mal scharf nach, ob ein Update nach 21 Jahren die Arbeit nicht wert sein könnte.

mein compiler g++(2.4.1)

glaube ich nicht.
Was gibt gcc --version aus?

template <typename T> struct is_arithmetic
{
    static bool const value = std::numeric_limits<T>::is_specialized;
};

?

pepe75 schrieb:

Ich wuerde nun gerne obige Print Methode nur fuer bestimmte (!) Auspraegungen von Counter erlauben, z.B. nur fuer ...

template <class V>
struct CounterPrinter;

template <class V>
struct CounterPrinterImpl
{
    static void Print(std::ostream& os, V const& v)
    {
        os << v;
    }
}

template <> struct CounterPrinter<char> : CounterPrinterImpl<char>;
template <> struct CounterPrinter<short> : CounterPrinterImpl<short>;
template <> struct CounterPrinter<int> : CounterPrinterImpl<int>;
// ...

template <class V>
class Counter
{
public:
    Counter(){}
    virtual ~Counter(){}

    virtual void Print() // virtual?
    {
        CounterPrinter<V>::Print(std::cout, m_v);
    }

private:
    V m_v;
};

Counter lässt sich jetzt mit allen Typen verwenden, aber nur mit den Typen char, short und int hat Counter eine Print() Funktion.

Die Funktionsdefinition existiert zwar uneingeschränkt im Counter Template, aber das ist erlaubt. Fehler gibt's erst wenn die Funktion irgendwo referenziert wird, weil das Funktionstemplate eben für z.B. Counter<std::string> nicht instanzierbar ist.
enable_if oder ähnliche SFINAE Tricks braucht man nur, wenn man z.B. mehrere Überladungen einer Funktion hat, von denen einige (oder alle) nur für bestimmte Typen funktionieren sollen.
In so einem Fall würde der Code oben nicht mehr funktionieren, da der Fehler in meinem Beispiel erst im Funktionsrumpf auftritt, und das ist für SFINAE zu spät.
(Bei SFINAE muss der Fehler bereits beim "Instanzieren" des Prototyps auftreten. Nur in dem Fall wird der Fehler dann nicht als Fehler gewertet, und das Template statt dessen einfach aus der Overload-Liste entfernt.)

(Ich bitte um Korrektur falls das nicht stimmt bzw. nicht ausreichend genau formuliert ist, aber ich meine es sollte inetwa hinkommen :))