Both functions assume the input range is already sorted (or at least partitioned by the predicate); the result on an unsorted range is unspecified. The half-open interval [lower_bound, upper_bound) is exactly the run of elements equal to the target, so upper - lower gives the count of duplicates in O(log n). For a contains-check, compare *lower_bound with the target after verifying the iterator is not at end(). std::binary_search exists for this case but only returns a bool; lower_bound is more useful because you keep the iterator for further work.

To insert into a sorted vector while keeping it sorted, find the insertion point with lower_bound then call insert. The lookup is O(log n) but the insert is O(n) because the tail must shift; the amortised cost is therefore not better than appending and re-sorting once, but it is great for small vectors that need to stay sorted at all times (active-task lists, displayed leaderboards). For frequent insertions and deletions in the middle, switch to std::set or std::multiset, which give O(log n) for everything but lose cache locality.

The comparator overload of lower_bound lets you customise what 'less than' means, useful when searching by a key extracted from a struct (a.id < b.id). When your search criterion is a monotone predicate rather than an ordering on a key, reach for std::partition_point instead: it expects the range to be partitioned (predicate true for a prefix, false for the suffix, or vice versa) and returns the boundary in O(log n). Together these cover the full set of binary-search problems: ordered-key search, range-equal queries, and predicate boundaries. Always confirm the precondition (sorted or partitioned) before trusting the result.