Small improved std::list to manage doubloons and pointers
I see no reason to have this be an entirely new data structure that inherits from std::list&lt;T&gt;. All of the new member functions you've defined are really just wrapper functions that could just be delegated to std::list&lt;T&gt; functions or functions that could be implemented as regular procedural functions.

For example, the contains() and at() and insertItem() (which should really just be named insertItemBefore()) functions could simply be:

namespace list_util {

template &lt;class T&gt;
bool contains(const std::list&lt;T&gt;&amp; l, const T&amp; elem)
{
    return std::find(l.begin(), l.end(), elem) != l.end();
}

template &lt;class T&gt;
T&amp; at(const std::list&lt;T&gt;&amp; l, std::size_t index)
{
    assert(index &lt; l.size());
    auto begin = l.begin();
    std::advance(begin, index);
    return *begin;
}

template &lt;class T&gt;
bool insertItemBefore(std::list&lt;T&gt;&amp; l, const T&amp; ref_item, const T&amp; elem)
{
    auto itemItr = std::find(l.begin(), l.end(), ref_item);

    // if we found the item, itemItr != l.end()
    if (itemItr != l.end()) {
        l.insert(itemItr, elem);
        return true;
    }
    return false;
}

}


You'd have to #include&lt;algorithm&gt; and #include&lt;iterator&gt; for this to work. Notice that the index parameter is now std::size_t to avoid having to check for negative indexes. They could then simply be called as: list_util::contains(the_list, elem); and list_util::at(the_list, the_index);.

Moreover, containsDoubloons() could be implemented using std::find() and destroyContents() is really just a call to std::list&lt;T&gt;::clear():

namespace list_util {

template&lt;class T&gt;
bool containsDoubloons(const std::list&lt;T&gt;&amp; l)
{
    for (auto it = l.begin(); it != l.end(); ++it) {
        const auto beginItr = std::next(it);
        if (beginItr != l.end() &amp;&amp; 
            std::find(beginItr, l.end(), *it) != l.end()) {
            return true;
        }
    }
    return false;
}

template&lt;class T&gt;
void destroyContents(std::list&lt;T&gt;&amp; l)
{
    l.clear();
}

}


Moreover, since the new functions we've written are completely generic and use the STL iterators for all operations, there's no reason to limit them only to std::list&lt;T&gt;. We could allow any container of containing T to be a parameter. An example is the contains() function:

template &lt; template &lt;class&gt; class C, class T&gt;
bool contains(const C&lt;T&gt;&amp; cont, const T&amp; elem)
{
    return std::find(cont.begin(), cont.end(), elem) != cont.end();
}