Useful C++ tricks and helper functions

My brain sucks. It can remember the lyrics to songs or the power draw of a electronic component, but I keep forgetting those simple, useful helper functions you sometimes need. This sends me off Google again, searching through excellent sites like StackOverflow etc. Time to make a list…


Remove characters from a string:

#include <algorithm>
#include <iterator>
std::string input;
std::string result;
std::remove_copy(input.begin(), input.end(), std::back_inserter(result), 'a');

Replace characters in a string:

std::string input;
std::replace(input.begin(), input.end(), 'a', 'b');

Convert integer to std::string without the << operator:

std::to_string((long long)number); 

Create a shared_ptr managing an array:

C++ < 17 -> std::shared_ptr<unsigned char> data = std::shared_ptr(new unsigned char[size], [](unsigned char *p) { delete[] p; });
C++ >= 17 -> std::shared_ptr<unsigned char[]> data = std::shared_ptr(new unsigned char[size]);

(In C++ < 17 you must use a custom deleter, because by default delete is called, not delete[]. Here a lambda function is passed to the shared_ptr constructor)


Advance an iterator by a number:

std::vector<SOME_TYPE> list;
std::vector::const_iterator iter = list.cbegin();
std::advance(iter, 5);

Append std::vector elements from one vector to another:

std::vector<SOME_TYPE> destination;
std::vector<SOME_TYPE> source;
destination.insert(destination.end(), source.cbegin(), source.cend());

(Why there is no push_back() overload for this is beyond me…)


Append std::vector elements from one vector to another (without duplicates):

std::vector<SOME_TYPE> destination;
std::vector<SOME_TYPE> source;
std::copy_if(source.cbegin(), source.cend(), std::back_inserter(destination), [&](const int & element) { return std::find(destination.cbegin(), destination.cend(), element) == destination.cend(); });

Conditionally erase elements from a vector:

std::vector<SOME_TYPE> src;
src.erase(std::remove_if(src.begin(), src.end(), [](auto & entry){ return <ERASE_CONDITION>;}), src.end());

For loops with iterator and auto:

std::vector<SOME_TYPE> foo;
for (auto fooIt = foo.cbegin(); fooIt != foo.cend(); ++fooIt) {
    //...
}

Use this when you need an iterator.


For each with auto:

std::vector<SOME_TYPE> foo;
for (const auto & oneOfFoo : foo) {
    //...
}

Make sure oneOfFoo is the type you want. Be careful when using auto-pointers etc.


Automatic loop counter type deduction (IdeOne):

std::vector<SOME_TYPE> foo;
for (decltype(foo)::size_type i = 0; i < v.size(); i++) {
    //...
}

Here, i automatically has the type same type as std::vector<SOMETYPE>::size_type. Useful if you need to use an index for looping.


Output all content of a std::vector to a stream:

std::vector<std::string> words; //contains some strings
std::stringstream ss;
std::copy(words.begin(), words.end(), std::ostream_iterator(ss));

Bind a class member function to a std::function object:

class Foo {
    void doSomething() {}
    void doWithParameter(int p)
}
Foo foo;
std::bind(&Foo::doSomething, foo);
std::bind(&Foo::doWithParameter, foo, std::placeholders::_1);

Removing const from a decltype result

const int CONST_INT = 0;
std::decay<decltype(CONST_INT)>::type _NORMAL_INT = 5;

Using std::enable_if to conditionally compile functions / class members

template<typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
static size_t getSize(const T & value)
{
    return sizeof(T);
}

template<typename T, typename std::enable_if<std::is_same<std::string, T>::value, int>::type = 0>
static size_t getSize(const T & value)
{
    return value.size();
}

The trick is that default parameters are not part of the signature of the template. This can be used for class member functions too:

template <typename T>
class Foo
{
    template<typename U = T, typename std::enable_if<std::is_same<U, int>::value, int>::type = 0>
    static U get()
    {
        ...
    }

    template<typename U = T, typename std::enable_if<std::is_same<U, double>::value, int>::type = 0>
    static U get()
    {
        ...
    }
};

Published by HorstBaerbel

Software developer by trade and interest, but I venture into the electronics- and diy-world from time to time.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Create your website at WordPress.com
Get started
%d bloggers like this: