C++ making a template class as place holder in another class

Question

I am trying to make a template class as placeholder class which can hold something like and string and type T object. Below is the code which I have written for the same.

#include <iostream>
#include <string>
#include <map>

using namespace std;

//A class which act as placeholder to hold
//unknown object. Something similar as Object
//in Java
template <typename T>
class Genric
{
    public:
        map<string, T> addP; //This will be placeholder for time
        // being.
};

class A
{
    public:
        Genric t1; //Have object of Genric class so that we can
        // access the member variable in future.
        void foo()
        {
            cout<<"Calling foo"<<endl;
        }
};

int main()
{
    A a1;
    a1.foo();
}

But when I tried to compile I am getting below error.

$ g++ tempClass.cxx
tempClass.cxx:21:9: error: invalid use of template-name 'Genric' without an argument list

The purpose of above Genric class is just to act as placeholder class for one of the member variables which can be populated in future. So is there a way we can write such Genric class.

Answer 1

You need something like boost::any:

map<string, boost::any> anywayzz;

You can store any object in it. You don't need Genric class template.

If you're not using boost, then you can implement any yourself. Look for its implementation, or type-erasure, on this site. You will surely get some idea. Start from here:

• Type erasure techniques

Answer 2

You are defining Genric as a template class, but then trying to initialize t1 without giving a type to it. That is the error you are getting. Try for example:

Genric<int> t1;

Or, if you are looking for a truly runtime generic, look into boost::any.

Answer 3

A template is "generic" until the program is compiled. At that point the compile must be made aware of what types it has to deal with.

If you want something that can contain a compile-time unknown (better: not yet known) type template are not the solution. Since the actual type will be known just at runtime, you have to go towards runtime-based polymorphism (inheritance from a polymorphic base) eventually wrapped inside an "handler".

In essence you need a base with at leas t a virtual function that allow you to check the type, and generic derived class that implement that function in a suitable way for all types.

boost::any can be an implementation, but there can be simpler ways, especially considering that "a function that allows to discover a runtime type" is no more than ... dynamic_cast.

You can so cometo a solution like this

#include <memory>

class any_value
{
    template<class T>
    class wrapper; //see below

    class common_base
    {
    public:
        virtual ~common_base() {} //this makes the type polymorphic

        template<class T>
        T* has_value()
        { 
            auto* ptr = dynamic_cast<wrapper<T>*>(this); 
            return ptr? &ptr->m: nullptr;
        }
    };

    template<class T>
    class wrapper: public common_base
    {
    public:
        wrapper() :m() {}
        wrapper(const T& t) :m(t) {}

        T m;
    };

    std::unique_ptr<common_base> pb;

public:

    any_value() {}

    template<class T>
    any_value(const T& t) :pb(new wrapper<T>(t)) {}

    template<class T>
    any_value& operator=(const T& t)
    { pb = std::unique_ptr<common_base>(new wrapper<T>(t)); return *this; }

    any_value(any_value&&) =default;
    any_value& operator=(any_value&&) =default;

    //NOW THE GETTERS
    template<class T>
    T* get() const //nullptr if not holding a T*
    { return bool(pb)? pb->has_value<T>(): nullptr; }

    template<class T>
    bool get(T& t)
    { 
        T* pt = get<T>(); 
        if(pt)  t = *pt;
        return bool(pt);
    }
};

#include <iostream>
#include <string>

int main()
{
    any_value a(5), b(2.7192818), c(std::string("as a string"));
    int vi=0; double vd=0; std::string vs;

    if(!a.get(vi)) vi=0; //will go
    if(!a.get(vd)) vd=0; //will fail
    if(!a.get(vs)) vs.clear(); //will fail
    std::cout <<"vi = "<<vi<<", vd = "<<vd<<", vs = "<<vs<<" \n";
    if(!b.get(vi)) vi=0; //will fail
    if(!b.get(vd)) vd=0; //will go
    if(!b.get(vs)) vs.clear(); //will fail
    std::cout <<"vi = "<<vi<<", vd = "<<vd<<", vs = "<<vs<<" \n";
    if(!c.get(vi)) vi=0; //will fail
    if(!c.get(vd)) vd=0; //will fail
    if(!c.get(vs)) vs.clear(); //will go
    std::cout <<"vi = "<<vi<<", vd = "<<vd<<", vs = "<<vs<<" \n";
}

---

Following Abhinav comment:

Since the C++ type system is static, you cannot -in general- deserialize an "unknown", unless you first deserialize something that can be "Known".

For this you first need a way to represet a C++ type (not object) into an recognizable value (sort of type-uid), and a "factory" that creates the wrappers appropriated for those "values".

On saving, you just save that uid, then ask via a common_base virtual function to save the wrapped value. On loading, you first load the uid, than create a new wrapper with appropriate type (see after) and than load the value via a common_base virtual function.

To create an appropriate wrapper, you need a table that maps the uid-s towards functions that create the wrapper associated with the type uid. This table must be pre-initialized for all the types you need to be able to serialize / deserialize.

But this goes long away your original question, that doesn't speak about serialization/deserialization.

If the problem is "serialization", the "type erasure" is not a complete solution. You should much more look at the "factory pattern". And post another question better suited for that argument.