Bagaimana Anda memeriksa bahwa suatu elemen ada di dalam suatu set?

Apakah ada persamaan yang lebih sederhana dari kode berikut:

myset.find(x) != myset.end()

Cara khas untuk memeriksa keberadaan di banyak kontainer STL seperti std::map, std::set, ... adalah:

const bool is_in = container.find(element) != container.end();

Cara lain untuk mengatakan apakah suatu elemen ada adalah dengan memeriksa count()

if (myset.count(x)) {
   // x is in the set, count is 1
} else {
   // count zero, i.e. x not in the set
}

Namun, sebagian besar waktu, saya menemukan diri saya membutuhkan akses ke elemen di mana pun saya memeriksa keberadaannya.

Jadi saya harus menemukan iteratornya. Maka, tentu saja, lebih baik membandingkannya endjuga.

set< X >::iterator it = myset.find(x);
if (it != myset.end()) {
   // do something with *it
}

C ++ 20

Dalam set C ++ 20 mendapat containsfungsi, jadi yang berikut menjadi mungkin seperti yang disebutkan di: https://stackoverflow.com/a/54197839/895245

if (myset.contains(x)) {
  // x is in the set
} else {
  // no x 
}

Hanya untuk memperjelas, alasan mengapa tidak ada anggota seperti contains()dalam jenis wadah ini adalah karena itu akan membuka Anda untuk menulis kode yang tidak efisien. Metode seperti itu mungkin hanya akan melakukan this->find(key) != this->end()internal, tetapi pertimbangkan apa yang Anda lakukan ketika kuncinya memang ada; dalam kebanyakan kasus, Anda akan ingin mendapatkan elemen dan melakukan sesuatu dengannya. Ini berarti Anda harus melakukan yang kedua find(), yang tidak efisien. Lebih baik menggunakan find secara langsung, sehingga Anda dapat men-cache hasil Anda, seperti:

auto it = myContainer.find(key);
if (it != myContainer.end())
{
    // Do something with it, no more lookup needed.
}
else
{
    // Key was not present.
}

Tentu saja, jika Anda tidak peduli dengan efisiensi, Anda selalu dapat menggunakan roll Anda sendiri, tetapi dalam hal ini Anda mungkin tidak boleh menggunakan C ++ ...;)

Dalam C ++ 20 kita akhirnya akan mendapatkan std::set::containsmetode.

#include <iostream>
#include <string>
#include <set>

int main()
{
    std::set<std::string> example = {"Do", "not", "panic", "!!!"};

    if(example.contains("panic")) {
        std::cout << "Found\n";
    } else {
        std::cout << "Not found\n";
    }
}

Jika Anda akan menambahkan containsfungsi, mungkin terlihat seperti ini:

#include <algorithm>
#include <iterator>

template<class TInputIterator, class T> inline
bool contains(TInputIterator first, TInputIterator last, const T& value)
{
    return std::find(first, last, value) != last;
}

template<class TContainer, class T> inline
bool contains(const TContainer& container, const T& value)
{
    // This works with more containers but requires std::begin and std::end
    // from C++0x, which you can get either:
    //  1. By using a C++0x compiler or
    //  2. Including the utility functions below.
    return contains(std::begin(container), std::end(container), value);

    // This works pre-C++0x (and without the utility functions below, but doesn't
    // work for fixed-length arrays.
    //return contains(container.begin(), container.end(), value);
}

template<class T> inline
bool contains(const std::set<T>& container, const T& value)
{
    return container.find(value) != container.end();
}

Ini bekerja dengan std::set, wadah STL lainnya, dan bahkan susunan dengan panjang tetap:

void test()
{
    std::set<int> set;
    set.insert(1);
    set.insert(4);
    assert(!contains(set, 3));

    int set2[] = { 1, 2, 3 };
    assert(contains(set2, 3));
}

Edit:

Seperti yang ditunjukkan dalam komentar, saya tidak sengaja menggunakan fungsi baru untuk C ++ 0x ( std::begindan std::end). Berikut ini implementasi hampir sepele dari VS2010:

namespace std {

template<class _Container> inline
    typename _Container::iterator begin(_Container& _Cont)
    { // get beginning of sequence
    return (_Cont.begin());
    }

template<class _Container> inline
    typename _Container::const_iterator begin(const _Container& _Cont)
    { // get beginning of sequence
    return (_Cont.begin());
    }

template<class _Container> inline
    typename _Container::iterator end(_Container& _Cont)
    { // get end of sequence
    return (_Cont.end());
    }

template<class _Container> inline
    typename _Container::const_iterator end(const _Container& _Cont)
    { // get end of sequence
    return (_Cont.end());
    }

template<class _Ty,
    size_t _Size> inline
    _Ty *begin(_Ty (&_Array)[_Size])
    { // get beginning of array
    return (&_Array[0]);
    }

template<class _Ty,
    size_t _Size> inline
    _Ty *end(_Ty (&_Array)[_Size])
    { // get end of array
    return (&_Array[0] + _Size);
    }

}

Anda juga dapat memeriksa apakah suatu elemen diatur atau tidak saat memasukkan elemen. Versi elemen tunggal mengembalikan pasangan, dengan pasangan anggotanya :: set pertama ke iterator yang menunjuk ke elemen yang baru saja dimasukkan atau ke elemen setara yang sudah ada di set. Elemen pasangan :: kedua dalam pasangan diatur ke true jika elemen baru dimasukkan atau salah jika elemen yang setara sudah ada.

Sebagai contoh: Misalkan set sudah memiliki 20 sebagai elemen.

 std::set<int> myset;
 std::set<int>::iterator it;
 std::pair<std::set<int>::iterator,bool> ret;

 ret=myset.insert(20);
 if(ret.second==false)
 {
     //do nothing

 }
 else
 {
    //do something
 }

 it=ret.first //points to element 20 already in set.

Jika elemen baru dimasukkan daripada pasangan :: pertama akan menunjuk ke posisi elemen baru di set.

Tulis milik Anda sendiri:

template<class T>
bool checkElementIsInSet(const T& elem, const std::set<T>& container)
{
  return container.find(elem) != container.end();
}

saya menggunakan

if(!my_set.count(that_element)) //Element is present...
;

Tetapi itu tidak seefisien

if(my_set.find(that_element)!=my_set.end()) ....;

Versi saya hanya menghemat waktu saya dalam menulis kode. Saya lebih suka cara ini untuk pengkodean kompetitif.

Saya dapat menulis containsfungsi umum untuk std::listdan std::vector,

template<typename T>
bool contains( const list<T>& container, const T& elt )
{
  return find( container.begin(), container.end(), elt ) != container.end() ;
}

template<typename T>
bool contains( const vector<T>& container, const T& elt )
{
  return find( container.begin(), container.end(), elt ) != container.end() ;
}

// use:
if( contains( yourList, itemInList ) ) // then do something

Ini sedikit membersihkan sintaks.

Tapi saya tidak bisa menggunakan templat parameter templat ajaib untuk membuat karya ini wadah stl sewenang-wenang.

// NOT WORKING:
template<template<class> class STLContainer, class T>
bool contains( STLContainer<T> container, T elt )
{
  return find( container.begin(), container.end(), elt ) != container.end() ;
}

Setiap komentar tentang meningkatkan jawaban terakhir akan menyenangkan.

// Sintaksis umum

       set<int>::iterator ii = find(set1.begin(),set1.end(),"element to be searched");

/ * dalam kode di bawah ini saya mencoba untuk menemukan elemen 4 di dan int ditetapkan apakah ada atau tidak * /

set<int>::iterator ii = find(set1.begin(),set1.end(),4);
 if(ii!=set1.end())
 {
    cout<<"element found";
    set1.erase(ii);// in case you want to erase that element from set.
 }