Is wrapping STL idioms for readability a good idea?

Question

I'm currently working on a C++ project that needs to have as few external dependencies as possible, and thus I'm pretty much sticking to STL and Boost. Until now, I've been almost exclusively living in Qt-land when it comes to C++. In general I tend to use C# and Python when I can.

Today I wanted to check whether a std::vector contained a certain item. With Qt, I'd do this like so:

QList< int > list;
list.append( 1 );
list.append( 2 );
list.append( 3 );

if ( list.contains( 2 ) )
{
    // do something
}

Nice and readable. But std::vector has no contains method, which was a surprise. Ok... what would the STL idiom for something like that be? Searching around, it seems to be this:

std::vector< int > list;
list.push_back( 1 );
list.push_back( 2 );
list.push_back( 3 );

std::vector< int >::const_iterator result =
    std::find( list.begin(), list.end(), 2 );

if ( result != list.end() )
{
    // do something
}

That (to me) is hardly readable and much too verbose. So I found myself writing a utility function that takes a vector and a value and returns bool depending on whether the value was found or not. Basically, a templated contains() method; a wrapper for the above std::find call. I can then use that in a way that is similar to the Qt example.

I have several similar utility functions in mind that would wrap other STL idioms for no other reason but a (perceived) increase in readability. What I want to know is... is this a bad idea? Do other people do the same? Am I missing something crucial? The code will be OSS at one point, and I'd rather not do something idiosyncratic that other C++ devs would find strange.

Answer 1

boost makes it much neater. I never use the STL iterator based algorithms anymore. The range based algorithms are a much neater abstraction and result in much cleaner code.

#include <boost/range/algorithm/find.hpp>

void foo(){
    std::vector<int> list;
    ...
    ...
    boost::find(list, 2) != list.end()
}

Answer 2

There is nothing wrong in writing the utility functions that will help you and will make your code cleaner. Other people do the same. Boost library is the biggest set of such utility functions and classes.

More to say C++ Standard explicitly proposes to extend the Standard Library (17.3.1.2/1):

The library can be extended by a C++ program. Each clause, as applicable, describes the requirements that such extensions must meet. Such extensions are generally one of the following:

• Template arguments
• Derived classes
• Containers, iterators, and/or algorithms that meet an interface convention