C++ set lower_bound
The C++ set lower_bound function is employed to retrieve an iterator that points to the key in the set container that matches the value provided as a parameter.
If the value is absent within the set container, it will yield an iterator indicating the next closest element that is greater than the specified value.
Syntax
iterator lower_bound (const value_type& val); //until C++ 11
iterator lower_bound (const value_type& val); //since C++ 11
const_iterator lower_bound (const value_type& val) const; //since C++ 11
Parameter
val : Value to be searched in the set container.
Return value
It returns an iterator pointing to the value in the set collection that matches the val provided as a parameter. If no such element exists, it will return end.
Complexity
Logarithmic in size.
Iterator validity
No changes.
Data Races
The container is accessed (neither the const nor the non-const versions alter the container).
Simultaneously retrieving the elements of a set is considered to be a secure operation.
Exception Safety
If an error occurs and an exception is thrown, the contents of the container remain unchanged.
Example 1
Let's explore a straightforward example to retrieve the minimum boundary of the provided key:
#include <iostream>
#include <set>
using namespace std;
int main(void) {
set<char> m = {'a','b','c','d','e'};
auto it = m.lower_bound('c');
cout << "Lower bound is(=) " << *it;
return 0;
}
Output:
Lower bound is(=) c
In the above example, lower bound of c is c.
Example 2
Let's examine a basic illustration of removing the element of a set from the lower boundary to the upper boundary:
#include <iostream>
#include <set>
using namespace std;
int main ()
{
set<int> myset;
set<int>::iterator itlow,itup;
for (int i=1; i<10; i++) myset.insert(i*10); // 10 20 30 40 50 60 70 80 90
itlow=myset.lower_bound (30); // ^
itup=myset.upper_bound (60); // ^
myset.erase(itlow,itup); // 10 20 70 80 90
std::cout << "myset contains:";
for (set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)
cout << ' ' << *it;
cout << '\n';
return 0;
}
Output:
myset contains: 10 20 70 80 90
In the aforementioned example, the erase method removed the set element starting from the lower bound (inclusive) up to the upper bound (exclusive), and displayed the remaining data.
Example 3
Let's see a simple example:
#include <set>
#include <iostream>
using namespace std;
int main( )
{
using namespace std;
set <int> s1;
set <int> :: const_iterator s1_AcIter, s1_RcIter;
s1.insert( 10 );
s1.insert( 20 );
s1.insert( 30 );
s1_RcIter = s1.lower_bound( 20 );
cout << "The element of set s1 with a key of 20 is: "
<< *s1_RcIter << "." << endl;
s1_RcIter = s1.lower_bound( 40 );
// If no match is found for the key, end( ) is returned
if ( s1_RcIter == s1.end( ) )
cout << "The set s1 doesn't have an element "
<< "with a key of 40." << endl;
else
cout << "The element of set s1 with a key of 40 is: "
<< *s1_RcIter << "." << endl;
// The element at a specific location in the set can be found
// by using a dereferenced iterator that addresses the location
s1_AcIter = s1.end( );
s1_AcIter--;
s1_RcIter = s1.lower_bound( *s1_AcIter );
cout << "The element of s1 with a key matching "
<< "that of the last element is: "
<< *s1_RcIter << "." << endl;
return 0;
}
Output:
The element of set s1 with a key of 20 is: 20.
The set s1 doesn't have an element with a key of 40.
The element of s1 with a key matching that of the last element is: 30.
Example 4
Let's see a simple example:
#include<set>
#include<iostream>
using namespace std;
int main()
{
set<int> mp;
// insert elements in random order
mp.insert( 2 );
mp.insert( 1 );
mp.insert( 5 );
mp.insert( 4 );
cout<<"Elements are: \n";
for (auto it = mp.begin(); it != mp.end(); it++) {
cout << (*it)<< endl;
}
// when 2 is present
auto it = mp.lower_bound(2);
cout << "The lower bound of key 2 is ";
cout << (*it)<< endl;
// when 3 is not present
// points to next greater after 3
it = mp.lower_bound(3);
cout << "The lower bound of key 3 is ";
cout << (*it)<< endl;
// when 6 exceeds
it = mp.lower_bound(6);
cout << "The lower bound of key 6 is ";
cout << (*it);
return 0;
}
Output:
Elements are:
1
2
4
5
The lower bound of key 2 is 2
The lower bound of key 3 is 4
The lower bound of key 6 is 4
When attempting to determine the lower boundary of a value that surpasses the container's limits or is absent from the set container, the function will return the end position.
