Question

My declaration was unordered_map<Comparison,int> Chs when Comparison is a class name.
Now I have few questions;

A. How can I insert, when the constructor called, some elements (like done with vector) ?

e.g. :

unordered_map<Comparison,int> Chs =
{
    (new Equal_to<int>,10),
    (new Not_equal_to<int>,30),        
    (new Greater<int>,20)
};

this code get now compile error.

B. How to free the memory that allocated (with new) in this declaration?

C. In inherit class:

template <class T,class V>
class RC : public unordered_map<T, V>

How should I write the RC constructor, so its can initialize with elements like A question?

Thank you, and sorry about my poor English.

Answer 1

You’d rather not inherit from standard containers, they weren’t designed for it.

Also, as mentioned, to have the contained Comparisons behave polymorphically, you need to either store references or pointers. Pointers are much simpler to work with.

In order to avoid having to worry with freeing up the memory, use smart pointers (std::unique_ptr or std::shared_ptr).

The following snippet shows the workings of most of the above, including how to do uniform initialization on your own container class (RC<>):

#include <unordered_map>
#include <memory>

struct Comparison {};
template <class T> struct Equal_to     : Comparison { };
template <class T> struct Not_equal_to : Comparison { };
template <class T> struct Greater      : Comparison { };

template <class T,class V>
class RC
{
    typedef std::unordered_map<T,V> comps_t;
    typedef typename comps_t::value_type value_type;
    comps_t comps;

  public:
    RC(std::initializer_list<value_type> init) : comps(init) { }
};

int main(int argc, const char *argv[])
{
    RC<std::shared_ptr<Comparison>, int> demo = { 
        { std::make_shared<Equal_to<int>>(),10 },
        { std::make_shared<Not_equal_to<int>>(),30 },        
        { std::make_shared<Greater<int>>(),20 } };

    return 0;
}

In the department of (likely useless optimization, you can have a perfect forwarding constructor if it doesn’t conflict with your other constructor needs. This would have the benefit of supporting move semantics correctly:

template <typename... A>
    RC(A&&... a) : comps(std::forward<A...>(a...)) { }