Wie kann ich eine Funktion schreiben, die eine variable Anzahl von Argumenten akzeptiert? Ist das möglich, wie?

Im C++11 Sie haben zwei neue Optionen, als die Variadische Argumente Bezugsseite im Abschnitt Alternativen Zustände:

• Variadische Vorlagen können auch verwendet werden, um Funktionen zu erstellen, die eine variable Anzahl von Argumenten annehmen. Sie sind oft die bessere Wahl, da sie keine Beschränkungen für die Typen der Argumente auferlegen, keine Ganzzahl- und Gleitkomma-Umwandlungen durchführen und typsicher sind. (seit C++11)
• Wenn alle Variablenargumente einen gemeinsamen Typ haben, bietet eine std::initializer_list einen bequemen Mechanismus (wenn auch mit einer anderen Syntax) für den Zugriff auf Variablenargumente.

Unten ist ein Beispiel, das beide Alternativen zeigt (live sehen):

#include <iostream>
#include <string>
#include <initializer_list>

template <typename T>
void func(T t) 
{
    std::cout << t << std::endl ;
}

template<typename T, typename... Args>
void func(T t, Args... args) // recursive variadic function
{
    std::cout << t <<std::endl ;

    func(args...) ;
}

template <class T>
void func2( std::initializer_list<T> list )
{
    for( auto elem : list )
    {
        std::cout << elem << std::endl ;
    }
}

int main()
{
    std::string
        str1( "Hello" ),
        str2( "world" );

    func(1,2.5,'a',str1);

    func2( {10, 20, 30, 40 }) ;
    func2( {str1, str2 } ) ;
} 

Wenn Sie verwenden gcc oder clang wir können die verwenden SCHÖNE_FUNKTION magische Variable um die Typsignatur der Funktion anzuzeigen, die hilfreich sein kann, um zu verstehen, was vor sich geht. Zum Beispiel mit:

std::cout << __PRETTY_FUNCTION__ << ": " << t <<std::endl ;

würde im Beispiel für variadische Funktionen folgendes int ergeben (live sehen):

void func(T, Args...) [T = int, Args = <double, char, std::basic_string<char>>]: 1
void func(T, Args...) [T = double, Args = <char, std::basic_string<char>>]: 2.5
void func(T, Args...) [T = char, Args = <std::basic_string<char>>]: a
void func(T) [T = std::basic_string<char>]: Hello

In Visual Studio können Sie verwenden FUNCSIG.

Update vor C++11

Vor C++11 die Alternative für std::initializer_list wäre std::Vektor oder einer der anderen Standardbehälter:

#include <iostream>
#include <string>
#include <vector>

template <class T>
void func1( std::vector<T> vec )
{
    for( typename std::vector<T>::iterator iter = vec.begin();  iter != vec.end(); ++iter )
    {
        std::cout << *iter << std::endl ;
    }
}

int main()
{
    int arr1[] = {10, 20, 30, 40} ;
    std::string arr2[] = { "hello", "world" } ; 
    std::vector<int> v1( arr1, arr1+4 ) ;
    std::vector<std::string> v2( arr2, arr2+2 ) ;

    func1( v1 ) ;
    func1( v2 ) ;
}

und die Alternative für abwechslungsreiche Vorlagen wäre variadische Funktionen obwohl sie es nicht sind typsicher und allgemein fehleranfällig und kann unsicher in der Anwendung sein aber die einzige andere mögliche Alternative wäre die Verwendung Standardargumente, obwohl das nur begrenzten Nutzen hat. Das folgende Beispiel ist eine modifizierte Version des Beispielcodes in der verknüpften Referenz:

#include <iostream>
#include <string>
#include <cstdarg>
 
void simple_printf(const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
 
    while (*fmt != '\0') {
        if (*fmt == 'd') {
            int i = va_arg(args, int);
            std::cout << i << '\n';
        } else if (*fmt == 's') {
            char * s = va_arg(args, char*);
            std::cout << s << '\n';
        }
        ++fmt;
    }
 
    va_end(args);
}
 

int main()
{
    std::string
        str1( "Hello" ),
        str2( "world" );

    simple_printf("dddd", 10, 20, 30, 40 );
    simple_printf("ss", str1.c_str(), str2.c_str() ); 

    return 0 ;
} 

Verwenden variadische Funktionen kommt auch mit Einschränkungen in den Argumenten, die Sie übergeben können, die in detailliert beschrieben werden Entwurf des C++-Standards im Abschnitt 5.2.2 Funktionsaufruf Absatz 7:

Wenn es für ein gegebenes Argument keinen Parameter gibt, wird das Argument so übergeben, dass die empfangende Funktion den Wert des Arguments erhalten kann, indem sie va_arg (18.7) aufruft. Die Lvalue-zu-rvalue- (4.1), Array-zu-Zeiger- (4.2) und Funktion-zu-Zeiger- (4.3) Standardkonvertierungen werden für den Argumentausdruck durchgeführt. Wenn das Argument nach diesen Konvertierungen keinen Arithmetik-, Enumerations-, Zeiger-, Zeiger-auf-Member- oder Klassentyp hat, ist das Programm falsch formatiert. Wenn das Argument einen Nicht-POD-Klassentyp hat (Klausel 9), ist das Verhalten undefiniert. […]

Das sollten Sie wahrscheinlich nicht, und Sie können wahrscheinlich auf sicherere und einfachere Weise tun, was Sie tun möchten. Technisch gesehen, um eine variable Anzahl von Argumenten in C zu verwenden, schließen Sie stdarg.h ein. Daraus erhälst du die va_list Typ sowie drei Funktionen, die darauf operieren aufgerufen va_start(), va_arg() und va_end().

#include<stdarg.h>

int maxof(int n_args, ...)
{
    va_list ap;
    va_start(ap, n_args);
    int max = va_arg(ap, int);
    for(int i = 2; i <= n_args; i++) {
        int a = va_arg(ap, int);
        if(a > max) max = a;
    }
    va_end(ap);
    return max;
}

Wenn Sie mich fragen, ist das ein Durcheinander. Es sieht schlecht aus, ist unsicher und voller technischer Details, die nichts mit dem zu tun haben, was Sie konzeptionell erreichen möchten. Erwägen Sie stattdessen die Verwendung von Überladung oder Vererbung/Polymorphismus, Builder-Muster (wie in operator<<() in Streams) oder Standardargumente usw. Diese sind alle sicherer: Der Compiler erfährt mehr darüber, was Sie zu tun versuchen, sodass es mehr Gelegenheiten gibt, in denen er Sie aufhalten kann, bevor Sie sich das Bein brechen.

Eine C++17-Lösung: vollständige Typsicherheit + schöne Aufrufsyntax

Seit der Einführung von Variadic-Templates in C++11 und Fold-Ausdrücken in C++17 ist es möglich, eine Template-Funktion zu definieren, die auf der Aufruferseite aufrufbar ist, als wäre sie eine Varidic-Funktion, aber mit den Vorteilen :

• stark typsicher sein;
• arbeiten ohne die Laufzeitinformationen der Anzahl der Argumente oder ohne die Verwendung eines “stop”-Arguments.

Hier ist ein Beispiel für gemischte Argumenttypen

template<class... Args>
void print(Args... args)
{
    (std::cout << ... << args) << "\n";
}
print(1, ':', " Hello", ',', " ", "World!");

Und ein weiterer mit erzwungener Typübereinstimmung für alle Argumente:

#include <type_traits> // enable_if, conjuction

template<class Head, class... Tail>
using are_same = std::conjunction<std::is_same<Head, Tail>...>;

template<class Head, class... Tail, class = std::enable_if_t<are_same<Head, Tail...>::value, void>>
void print_same_type(Head head, Tail... tail)
{
    std::cout << head;
    (std::cout << ... << tail) << "\n";
}
print_same_type("2: ", "Hello, ", "World!");   // OK
print_same_type(3, ": ", "Hello, ", "World!"); // no matching function for call to 'print_same_type(int, const char [3], const char [8], const char [7])'
                                               // print_same_type(3, ": ", "Hello, ", "World!");
                                                                                              ^

Mehr Informationen:

1. Variadische Vorlagen, auch als Parameterpaket bekannt Parameterpaket (seit C++11) – cppreference.com.
2. Ausdrücke falten Faltungsausdruck (seit C++17) – cppreference.com.
3. Ein … sehen vollständige Programmdemonstration auf coliru.

in c++11 können Sie Folgendes tun:

void foo(const std::list<std::string> & myArguments) {
   //do whatever you want, with all the convenience of lists
}

foo({"arg1","arg2"});

Listeninitialisierer FTW!

In C++11 gibt es eine Möglichkeit, Vorlagen mit variablen Argumenten zu erstellen, die zu einer wirklich eleganten und typsicheren Möglichkeit führen, Funktionen mit variablen Argumenten zu haben. Bjarne selbst gibt ein schönes Beispiel dafür printf mit variablen Argumentvorlagen in dem C++11FAQ.

Ich persönlich halte das für so elegant, dass ich mich nicht einmal mit einer Funktion für variable Argumente in C++ beschäftigen würde, bis dieser Compiler Unterstützung für C++11-Vorlagen für variable Argumente bietet.

Variadic-Funktionen im C-Stil werden in C++ unterstützt.

Die meisten C++-Bibliotheken verwenden jedoch ein alternatives Idiom, z. B. während die 'c' printf Die Funktion übernimmt variable Argumente c++ cout Objekt nutzt << Überladen, das Typsicherheit und ADTs adressiert (vielleicht auf Kosten der Einfachheit der Implementierung).

Abgesehen von Varargs oder Überladen könnten Sie in Betracht ziehen, Ihre Argumente in einem std::vector oder anderen Containern (z. B. std::map) zu aggregieren. Etwas wie das:

template <typename T> void f(std::vector<T> const&);
std::vector<int> my_args;
my_args.push_back(1);
my_args.push_back(2);
f(my_args);

Auf diese Weise würden Sie Typsicherheit gewinnen und die logische Bedeutung dieser vielfältigen Argumente wäre offensichtlich.

Sicherlich kann dieser Ansatz Leistungsprobleme haben, aber Sie sollten sich darüber keine Gedanken machen, es sei denn, Sie sind sicher, dass Sie den Preis nicht bezahlen können. Es ist eine Art “Pythonic”-Ansatz für C++ …