Überprüfen, ob das Element in der Liste enthalten ist (enthält)

Question

Ich habe eine Liste von Elementen, zum Beispiel Ganzzahlen, und ich möchte überprüfen, ob meine Variable (eine andere Ganzzahl) eines der Elemente aus der Liste ist. In Python würde ich folgendes tun:

my_list = [1,2,3,4] # Elemente
my_var = 3 # meine Variable
my_var in my_list # gibt boolean zurück

Wie mache ich das in C++? Ich dachte daran, std::list zu verwenden, aber ich finde keine find Methode darin. Ich sehe eine solche Methode in der std::set Struktur.

Etwas tiefergehend ist das Problem, dass mein Programm einige eindeutige IDs erhält (eine Liste, ein Set, was auch immer) und ich über eine lange Liste von Eingabedaten (IDs) iteriere und überprüfe, ob sie in der Liste enthalten sind (boolscher Wert wird für jeden Iterationsschritt zurückgegeben). Und ich bin mir nicht sicher, wie ich das in C++ machen soll.

Answer 1

Verwenden Sie std::find, etwas wie:

if (std::find(std::begin(my_list), std::end(my_list), my_var) != std::end(my_list))
    // my_list hat my_var

Answer 2

Deklarieren Sie zusätzliche Hilfsfunktionen wie folgt:

template 
bool vectorContains(const vector& v, I& t)
{
    bool gefunden = (std::find(v.begin(), v.end(), t) != v.end());
    return gefunden;
}

Und verwenden Sie es so:

void Project::AddPlatform(const char* platform)
{
    if (!vectorContains(platforms, platform))
        platforms.push_back(platform);
}

Eine Beispielaufnahme finden Sie hier:

https://github.com/tapika/cppscriptcore/blob/b7f3d62747494a52a440482e841ffb016a3fc56e/SolutionProjectModel/Project.cpp#L13

Answer 3

In C++23 können Sie einfach std::ranges::contains verwenden. Wenn Sie das darin enthaltene Beispiel für Listen anpassen:

#include 
#include 
#include 

int main()
{
    auto haystack = std::list{3, 1, 4, 1, 5};
    auto needle = std::list{1, 4, 1};
    auto bodkin = std::list{2, 5, 2};
    auto increment = [](int x) { return ++x; };
    auto decrement = [](int x) { return --x; };

  assert (
        std::ranges::contains(haystack, 4) &&
       !std::ranges::contains(haystack, 6) &&
        std::ranges::contains_subrange(haystack, needle) &&
       !std::ranges::contains_subrange(haystack, bodkin) &&
        std::ranges::contains(haystack, 6, increment) &&
       !std::ranges::contains(haystack, 1, increment) &&
        std::ranges::contains_subrange(haystack, bodkin, {}, increment) &&
       !std::ranges::contains_subrange(haystack, bodkin, {}, decrement) &&
        std::ranges::contains_subrange(haystack, bodkin, {}, {}, decrement));
}

Answer 4

Seit C++20 können Sie l.contains(my_var) verwenden

https://www.modernescpp.com/index.php/more-convenience-functions-for-containers-with-c-20