Gibt es eine Möglichkeit, die Leere als Argument zu übergeben?

Question

Ich habe eine Variadic-Funktion, die eine Funktion für jedes Argument aufruft.

Dies ist, wie es aussieht: es PushArg<int>(2) zweimal anrufen und dann Call() rufen

void Call() 
{ 

} 

template<typename T> 
void Call(T arg) 
{ 
    PushArg(arg); 
    Call(); 
} 

template<typename T, typename ...Args> 
void Call(T arg, Args... args) 
{ 
    PushArg(arg); 
    Call(std::forward<Args...>(args)...); 
} 

template<typename T> 
void PushArg(T arg) 
{ 

} 

template<> 
void PushArg<int>(int arg) 
{ 

} 

Wenn ich die Funktion mit Call(2, 2) nennen. Aber ich muss PushArg anrufen können, aber ohne Wert.

Was ich in der Lage sein wollen, ist Call(2, void, 4) zu tun zu tun und haben es PushArg<int>(2) nennen, PushArg<void>(), dann PushArg<int>(4).

Im Moment habe ich eine "Null" -Klasse, die nur existiert, um mir zu erlauben, einen Wert ohne Wert zu übergeben, aber es macht den Aufruf der Funktion peinlich. Ist das möglich, was ich beschrieben habe (oder etwas Ähnliches)?

Answer 1

Nein, Sie können einen Typ nicht als Argument einer Funktion übergeben. Die einzige Lösung, die ich denken kann, ist ein spezieller Typ (Ihre "Nullklasse", nehme ich an), um void zu ersetzen.

Ich denke, es ist eine saubere Lösung, so schlage ich vor, ein beispiel

#include <utility> 
#include <iostream> 

struct voidWrp 
{ }; 

void PushArg() 
{ std::cout << "- void PushArg" << std::endl; } 

template <typename T> 
void PushArg (T arg) 
{ std::cout << "- generic (T) PushArg" << std::endl; } 

template <> 
void PushArg<int> (int arg) 
{ std::cout << "- int PushArg" << std::endl; } 

void Call() 
{ } 

template <typename T> 
void Call (T arg) 
{ 
    PushArg(arg); 
    Call(); 
} 

template <typename T, typename ... Args> 
void Call (T arg, Args ... args) 
{ 
    PushArg(arg); 
    Call(std::forward<Args>(args)...); 
} 

template <typename ... Args> 
void Call (voidWrp const &, Args ... args) 
{ 
    PushArg(); 
    Call(std::forward<Args>(args)...); 
} 

int main() 
{ 
    Call("std::string value", 3, voidWrp{}, 6, 7L); 
} 

Das Beispielprogramm druckt

- generic (T) PushArg 
- int PushArg 
- void PushArg 
- int PushArg 
- generic (T) PushArg