elegante Funktionsdefinition in C++

Question

I haben folgende Funktionen:

void func1(int8_t input); 
void func1(int16_t input); 
void func1(int32_t input); 
void func1(float input); 

Die Umsetzung der vier Funktionen ist die gleiche, mit Ausnahme einiger interner Wert, der in Übereinstimmung mit dem eingegebenen Typ sind (int8_t, int16_t, int32_t oder float).

Momentan erstelle ich die anderen drei Funktionen durch Kopieren-Einfügen, aber das ist ziemlich mühsam.

Gibt es eine Möglichkeit, so dass ich nur 1 Funktion schreibe (zum Beispiel func1(int8_t input);) und dass zum Zeitpunkt der Erstellung die anderen drei Funktionen automatisch erstellt werden?

Oder in denen dies ohne die anderen drei Funktionen funktionieren könnte? Jede andere Lösung wird sehr geschätzt.

Answer 1

Verwendung von Template-Funktion ist die Lösung für dieses Problem:

template <typename T> 
void func1(const T value) 
{ 
    // Do some stuff 
} 

Wenn Sie spezielle internen Wert verwenden müssen, die auf Eingabetyp abhängig ist, können Sie Hilfs Typen Eigenschaften wie diese verwenden:

template <typename T> 
struct SomeTrait 
{ 
    static const int value = 10; 
}; 

template <> 
struct SomeTrait<float> 
{ 
    static const int value = 20; 
}; 

template <typename T> 
void func1(const T value) 
{ 
    std::cout << SomeTrait<T>::value << std::endl; 
    // Do some stuff 
} 

Answer 2

Dies benötigt eindeutig eine Vorlagenfunktion. Dies erfordert C++ 11

#include <type_traits> 

template <typename T 
      // This constrains the template function instantiation to only 
      // integral and floating types 
      typename = typename std::enable_if<std::is_integral<T>::value 
              || 
              std::is_floating_point<T>::value>::type> 
void func1(T input) 
{ 
    ...... 
    T tmp; // Use the same data type inside function 
} 

Wenn Sie es einfach und w/o C++ 11 halten wollen, dann tun nur

template <typename T> 
void func1(T input) 
{ 
    ...... 
    T tmp; // Use the same data type inside function 
} 

Der Nachteil ist, dass Sie nicht die Instanziierung einschränken können diese Funktionsvorlage nur für Integral- und Floating-Typen. Sie können boost :: enable_if und andere Typeigenschaften anstelle von 'std :: enable_if' und std :: type_traits in diesem Fall verwenden.

Answer 3

Sie können es als Template-Funktion definieren:

template<typename T> void func1(T input) { 
    // ... 
} 

Dann es so nennen:

float f = 1.234; 
func1<float>(f); 

int32_t i32 = 45678; 
func1<int32_t>(i32); 

Answer 4

Sie können Vorlagen verwenden, wenn die Implementierung der Funktionen gleich sind:

template <typename T> 
void func1(const T value) 
{ 
    // Do some stuff 
} 

Wenn die Implementierung für einige Eingabearten unterschiedlich ist, können Sie diese Spezialisierung angeben, z .G.

void func1(const complex value) 
{ 
    // Do some stuff related to complex values 
} 

Answer 5

Der beste Weg, dies zu tun ist die Verwendung von Template-Funktion.

template <typename T> 
void your_function(const T input){ 

// do something 

} 

in der anderen Hand, können Sie Ihre Template-Funktion

template <> 
void your_function(const float input){ 


// do some specific things 

}