Dans le C ++ moderne (GCC 5.1.0, donc C ++ 14, je suppose), quel est le moyen le plus rapide de transmettre, au moment de la compilation, une liste de valeurs d'un enum, puis, au moment de l'exécution, de vérifier quelles valeurs sont dans Là?
enum foobar { foo, bar, baz };
template<????>
void f() {
if( contains<????, foo>() )
std::cout << "foo!";
if( contains<????, bar>() )
std::cout << "bar!";
if( contains<????, baz>() )
std::cout << "baz!";
}
f<foo,bar>();
Remarque: Ceci est pour les tests unitaires, donc la vitesse, etc. n'est généralement pas pertinente et l'objectif principal est qu'elle soit déchiffrable par quelqu'un qui n'est pas familier avec le code.
Voici une proposition
#include <initializer_list>// pulled in by a lot of stuff
enum class options { foo,bar,baz };
void test_func(options opt)
{
}
int main()
{
auto test_vector = { options::foo, options::bar };
for (auto option : test_vector)
{
test_func(option);
}
return 0;
}
Un peu plus compliqué à vérifier que les vecteurs de test fournis contiennent ce qu'ils doivent contenir:
#include <initializer_list>
#include <algorithm>
#include <stdexcept>
enum class options { foo, bar, baz, wuz };
void test_func(options)
{
}
template<typename AT, typename BT>
void assert_test_vectors(AT a, BT check_these_items)
{
for (auto item : check_these_items)
{
auto test = std::find(a.begin(), a.end(), item) != a.end();
if (!test)
{
return throw std::runtime_error("You suck");
}
}
}
template<typename T>
void run_tests(T tests)
{
const auto better_have_these = { options::foo, options::bar };
assert_test_vectors(tests, better_have_these);
for (auto test : tests)
{
test_func(test);
}
}
int main()
{
const auto test_vectors = { options::foo, options::wuz };
run_tests(test_vectors);
return 0;
}
Cet article est collecté sur Internet, veuillez indiquer la source lors de la réimpression.
En cas d'infraction, veuillez [email protected] Supprimer.
laisse moi dire quelques mots