proggen.org

Code: Alles auswählen

#include <stdio.h>

template<typename T>
class ref
{
  public:
  T * Reference;

  ref( T & reference );
};

template<typename T>
ref<T>::ref( T & reference )
    : Reference( &reference )
{
  printf( "Standard\n" );
}

template<>
ref<int>::ref( int & reference )
    : Reference( &reference )
{
  printf( "int-Spezialisierung\n" );
}


int main()
{
  double d;
  int i;
  ref<double> rdouble(d);
  ref<int>    rint(i);

  return 0;
}

Code: Alles auswählen

Standard
int-Spezialisierung

Code: Alles auswählen

#include <stdio.h>

template<typename T, typename U>
class ref
{                                                               // Zeile 5
  public:
  T * Reference;
  U * URef;

  ref( T & reference, U & uref );                  // Zeile 10
};

template< typename T, typename U >
ref<T,U>::ref( T & reference, U & uref )
    : Reference( &reference )
    , URef( &uref )
{
    printf( "Standard\n" );
}


template< typename U >
ref<int, U>::ref( int & reference, U & uref )                    // Zeile 23
    : Reference( &reference )
    , URef( &uref )
{
    printf( "int\n" );
}                                                                    // Zeile 28


int main()
{
  double d1, d2, di;
  int i;

  ref< double, double > dref( d1, d2 );
  ref< int   , double > iref(  i, di );

  return 0;
}

Code: Alles auswählen

uref2.cpp:23: error: invalid use of incomplete type 'class ref<int, U>'
uref2.cpp:5: error: declaration of 'class ref<int, U>'

Code: Alles auswählen

1> uref2.cpp(28): error C2244: 'ref<T,U>::ref': Keine Übereinstimmung für Funktionsdefinition mit vorhandener Deklaration gefunden
1>          uref2.cpp(10): Siehe Deklaration von 'ref<T,U>::ref'
1>          Definition
1>          'ref<int,U>::ref(int &,U &)'
1>          Vorhandene Deklarationen
1>          'ref<T,U>::ref(T &,U &)'

Code: Alles auswählen

#include <stdio.h>
#include <type_traits>

template<typename T, typename U>
class ref
{
  public:
  T * Reference;
  U * URef;

  template<typename Dummy = T>
  ref(typename std::enable_if<std::is_integral<Dummy>::value, T>::type& reference, U& uref)
  {
    printf( "int\n" );
  }
  
  template<typename Dummy = T>
  ref(typename std::enable_if<!std::is_integral<Dummy>::value, T>::type& reference, U& uref)
  {
    printf( "Standard\n" );
  }
};

int main()
{
  double d1, d2, di;
  int i;

  ref< double, double > dref( d1, d2 );
  ref< int   , double > iref(  i, di );

  return 0;
}

Code: Alles auswählen

template <typename T>
MeinStruct 
{
   T methode(const typename std::enable_if<std::is_integral<T, void>::type&);
};

int main()
{
  MeinStruct<int> s;
  s.(13); // geht, Funktionskopf wird zu "T methode(const int&)"
  
  MeinStruct<char*> t;
  t.("nein"); // geht nicht, da std::enable_if einen fehler produziert, und der overload vom compiler entfernt wird. Das nennt man SFINAE.
}