[C++] Co zrobić, żeby funkcja mogła przyjmować nieograniczoną/nie określoną z góry ilość argumentów?

Question

Witam! Chciałbym udekorować klasę string o funkcję comp() (odpowiednik compare). Która zwracałaby zero (czyli w tym przypadku prawdę, jak normalny compare) jeżeli jedna z przekazanych do niej wartości jest równa danemu stringowi. Jednakże tych wartości może być kilka, a stu funkcji pisać nie będę. Nie chcę też przekazywać do niej tablicy stringów, bo nie ma sensu... Chyba, że nie ogarnę rozwiązania mojego problemu...

 

Słyszałem o jakimś cstarg? O jakimś va_start itd, ale nie potrafię tego ogarnąć. Czy mógłby mi to ktoś wytłumaczyć?

Answer 1

Obsługa takich argumentów możliwa jest z pomocą makr va_* i parsowania któregoś z argumentów. Jest to jednak technika silnie nie zalecana, pełna możliwości popełnienia błędu a wręcz zabroniona w embedded gdzie możesz zabić człowieka.

#include <stdarg.h>
#include <stdio.h>

double average(int count, ...) {
    va_list ap;
    int j;
    double sum = 0;

    va_start(ap, count); 
    for (i = 0; i < count; ++i) {
        sum += va_arg(ap, int); 
    }
    va_end(ap);

    return sum / count;
}

int main(void) {
	printf("%f\n", average(3, 1, 2, 3) );
	return 0;
}

Ogólnie, możesz zobaczyć jak działa, poczytać ale .. bardzo staraj się tego nie robić. Tak... tylko że w C, jeśli nie chcesz przesyłać kontenera (tj. wskaźnika) i wielkości lub masz dane różnych typów, wymaga to niezłej gimnastyki :-/

Szczęśliwie dla C++ masz od C++11 "szablony wariadyczne". Dają możliwość przekazania dowolnych argumentów do funkcji:

#include <iostream>

template<typename T>
void showArguments(T t) {
	std::cout << t << ' ';
}

template<typename T, typename... Args>
void showArguments(T t, Args... args) {
	showArguments(t);
	showArguments(args...);
}

int main() {
	showArguments("kaczka", 23.3, 1231L, 3232.3F, []{});
	std::cout << '\n';
}

W C++17 z kolei doszło fold expressions:

#include <iostream>
#include <type_traits>

template<typename... Args>
auto average(Args&&... args) -> std::common_type_t<Args...> {
	return (args + ... ) / sizeof...(args);
}

int main() {
	std::cout << average(1, 12.2, 33) << '\n';
}

A co do compare w C++17, zrobił bym je tak:

#include <iostream>
#include <iomanip>

template<typename... Args>
bool any(Args... args) { return ( ... || args); }

template<typename T, typename... Args>
bool myCompare(T t, Args... args) {
    return any((t == args)...);
}


int main() {
	std::cout << std::boolalpha 
        << myCompare("ala", "maciej", "adam", "franek", "ala") << '\n';
    std::cout << std::boolalpha 
        << myCompare("ala", "maciej", "adam", "franek", "zenek") << '\n';    
}

 

Comments

A nie lepiej byłoby to zrobić tak?
 

#include <iostream>
#include <iomanip>

template<typename T, typename... Args>
bool myCompare(T t, Args... args) {
    return ((t == args) || ...);
}
 
 
int main() {
    std::cout << std::boolalpha 
        << myCompare("ala", "maciej", "adam", "franek", "ala") << '\n';
    std::cout << std::boolalpha 
        << myCompare("ala", "maciej", "adam", "franek", "zenek") << '\n';
}

To nie sarkazm, tylko prawdziwe pytanie jakby co xd

---

Ależ oczywiście że tak także można :-) Moją intencją było pokazanie także any(...) i stwierdziłem że będzie to bardziej zrozumiałe co się dzieje w szablonie :-)

Answer 2

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

bool compare(const std::string& lhs, const std::vector<std::string>& rhs) {
    return std::any_of(rhs.begin(), rhs.end(), [&lhs](const auto& str) { return lhs == str; }); 
}
    
int main() {
    std::cout << compare("one", {"three", "two", "one"}) << "\n";
    std::cout << compare("one", {"three", "two", "four"}) << "\n";
    
}

 

Comments

Haha xD. Dzięki.