std::flat_set<Key,Compare,KeyContainer>::contains

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Tables

Iterator invalidation

Member function table

Non-member function table

 

std::flat_set

Member types

Member functions

flat_set::flat_set flat_set::operator= Iterators flat_set::beginflat_set::cbegin flat_set::endflat_set::cend flat_set::rbeginflat_set::crbegin flat_set::rendflat_set::crend Capacity flat_set::size flat_set::max_size flat_set::empty Observers flat_set::key_comp flat_set::value_comp      Modifiers flat_set::clear flat_set::insert flat_set::insert_range flat_set::emplace flat_set::emplace_hint flat_set::erase flat_set::swap flat_set::extract flat_set::replace Lookup flat_set::count flat_set::find flat_set::contains flat_set::equal_range flat_set::lower_bound flat_set::upper_bound Non-member functions operator==operator<=> swap(std::flat_set) erase_if(std::flat_set)

Helper classes

uses_allocator<std::flat_set>

Tags

sorted_unique      sorted_unique_t

Deduction guides

 

bool contains( const Key& key ) const;	(1)	(since C++23)
template< class K > bool contains( const K& x ) const;	(2)	(since C++23)

1) Checks if there is an element with key equivalent to key in the container.

2) Checks if there is an element with key that compares equivalent to the value x. This overload participates in overload resolution only if the qualified-id Compare::is_transparent is valid and denotes a type. It allows calling this function without constructing an instance of Key.

Parameters

key	-	key value of the element to search for
x	-	a value of any type that can be transparently compared with a key

Return value

true if there is such an element, otherwise false.

Complexity

Logarithmic in the size of the container.

Example

Run this code

#include <iostream>
#include <flat_set>
 
int main()
{
    std::flat_set<int> example{1, 2, 3, 4};
 
    for (int x : {2, 5})
        if (example.contains(x))
            std::cout << x << ": Found\n";
        else
            std::cout << x << ": Not found\n";
}

Output:

2: Found
5: Not found

See also

find	finds element with specific key (public member function)
count	returns the number of elements matching specific key (public member function)
equal_range	returns range of elements matching a specific key (public member function)