Kann man bei einer Template-Funktion durch irgendwelche Tricks erkennen, was für Typen übergeben wurden? Also ob POT, Non-POT, Zeiger, oder sonstwas?
Ich meine sowas schonmal gesehen zu haben, zumindest für (Funktions-?)Zeiger. Ich find im großen weiten Internet aber nichts

Dankbar für jede Antwort,
ergebendst,
Badestrand

Für PODs fällt mir nix ein.

template<class T>
struct IsInt {

    enum { result = false };
};

template<class T>
struct IsDouble {

    enum { result = false };
};

template<>
struct IsInt<int> {

    enum { result = true };
};

template<>
struct IsDouble<double> {

    enum { result = true };
};

Inspiriert von Michael's Code ist mir das eingefallen.

template<class T>
inline bool is_pointer_type(T value)
{
   return false;
}

template<class T>
inline bool is_pointer_type(T *value)
{
   return true;
}

template<class T>
inline bool IsPod(T&)
{
   return type_traits<T>::is_pod;
}

template<class T>
struct type_traits
{
   static const bool is_pod     = false;
   static const bool is_integer = false;
   static const bool is_real    = false;
   static const bool is_signed  = false;
};

template<>
struct type_traits<char>
{
   static const bool is_pod     = true;
   static const bool is_integer = true;
   static const bool is_real    = false;
   static const bool is_signed  = true;
   typedef signed char signed_t;
   typedef unsigned char unsigned_t;
};

template<>
struct type_traits<unsigned char>
{
   static const bool is_pod     = true;
   static const bool is_integer = true;
   static const bool is_real    = false;
   static const bool is_signed  = false;
   typedef signed char signed_t;
   typedef unsigned char unsigned_t;
};

template<>
struct type_traits<short>
{
   static const bool is_pod     = true;
   static const bool is_integer = true;
   static const bool is_real    = false;
   static const bool is_signed  = true;
   typedef short signed_t;
   typedef unsigned short unsigned_t;
};

template<>
struct type_traits<unsigned short>
{
   static const bool is_pod     = true;
   static const bool is_integer = true;
   static const bool is_real    = false;
   static const bool is_signed  = false;
   typedef unsigned short signed_t;
   typedef unsigned short unsigned_t;
};

template<>
struct type_traits<int>
{
   static const bool is_pod     = true;
   static const bool is_integer = true;
   static const bool is_real    = false;
   static const bool is_signed  = true;
   typedef int signed_t;
   typedef unsigned int unsigned_t;
};

template<>
struct type_traits<unsigned int>
{
   static const bool is_pod     = true;
   static const bool is_integer = true;
   static const bool is_real    = false;
   static const bool is_signed  = false;
   typedef int signed_t;
   typedef unsigned int unsigned_t;
};

template<>
struct type_traits<long long int>
{
   static const bool is_pod     = true;
   static const bool is_integer = true;
   static const bool is_real    = false;
   static const bool is_signed  = true;
   typedef long long int signed_t;
   typedef unsigned long long int unsigned_t;
};

template<>
struct type_traits<unsigned long long int>
{
   static const bool is_pod     = true;
   static const bool is_integer = true;
   static const bool is_real    = false;
   static const bool is_signed  = false;
   typedef long long int signed_t;
   typedef unsigned long long int unsigned_t;
};

template<>
struct type_traits<float>
{
   static const bool is_pod = true;
   static const bool is_integer = false;
   static const bool is_real = true;
   static const bool is_signed = true;
};

template<>
struct type_traits<double>
{
   static const bool is_pod = true;
   static const bool is_integer = false;
   static const bool is_real = true;
   static const bool is_signed = true;
};

template<>
struct type_traits<bool>
{
   static const bool is_pod = true;
   static const bool is_integer = true;
   static const bool is_real = false;
   static const bool is_signed = false;
};

hab ich mir mal zusammengeschrieben, fuer ne BinaryStream klasse.

Meep Meep

http://www.boost.org/libs/type_traits/index.html

Wir bauen uns selber eine Sandburg :p

Eine sehr gut Type-Traits-Library, die alle deine gestellten Fragen beantworten kann, findest du in den boost-Libs (http://www.boost.org/doc/html/boost_typetraits.html).

template< typename T >
struct is_pointer< T* const >
{
	enum { value = true };
};

template< typename T >
struct is_pointer< T* volatile >
{
	enum { value = true };
};

template< typename T >
struct is_pointer< T* const volatile >
{
	enum { value = true };
};

Microsoft bietet übrigens einige Typetrait funktionen an, z.B. __is_pod(): http://msdn2.microsoft.com/en-us/library/ms177194(VS.80).aspx

Achja, wo wir grad beim sammeln sind!

template< typename T1, typename T2 >
struct is_same
{
	enum { value = false };
};

template< typename T >
struct is_same< T, T >
{
	enum { value = true };
};

template <typename T>
struct is_… {
    static bool const value = false;
};

Garnichts, aber was spricht gegen den enum-hack?

• Er sieht "hässlich" aus
• Er versteckt die wahre Semantik des Codes
• Er verwendet einen falschen Typ (enum/int) statt bool
• Er braucht zusätzliche geschweifte Klammern, die man auf einer deutschen PC-Tastatur schlecht erreicht (interessiert mich nicht, ich verwende nen Mac)

Keine schwerwiegenden Gründe (bis auf den zweiten Punkt), aber doch alles in allem Gründe genug für mich.

Hallo,
die Variante mit der expliziten Aufzälung ist für PODs etwas schlecht, da es beliebig viele POD-Typen gibt. Dummerweise lässt sich ein is_pod<T> in Standard-C++ nicht vollständig implementieren.

werden dann klassen und strukturen die aus reinen pods bestehen auch als pod gewerted ? oder wie ist das zu verstehen ?

Meep Meep

Meep Meep schrieb:

HumeSikkins schrieb:

Hallo,
die Variante mit der expliziten Aufzälung ist für PODs etwas schlecht, da es beliebig viele POD-Typen gibt. Dummerweise lässt sich ein is_pod<T> in Standard-C++ nicht vollständig implementieren.

werden dann klassen und strukturen die aus reinen pods bestehen auch als pod gewerted ? oder wie ist das zu verstehen ?

Meep Meep

Ja. Siehe: http://www.parashift.com/c++-faq-lite/intrinsic-types.html#faq-26.7