Question

I need a container/wrapper C++ class which holds a single, arbitrary value. Once this value is set only values of the same type should be accepted.

This is the code I’ve been experimenting with.

struct Genome {

struct FitnessConcept {};

template<typename T>
struct Fitness : public FitnessConcept{
    T value;        
    Fitness(T value) : value(value){}
};

std::shared_ptr<FitnessConcept> fitness;

template<typename T> 
void setFitness(T value) {
    fitness.reset(new Fitness<T>(value));               
}

template<typename T>
T getFitness() {
    return static_cast<Fitness<T>*>(fitness.get())->value;
}           
};

While Genome can hold arbitrary values, it does not restrict the type once the first is set, i.e. the following code is valid:

Genome g;
g.setFitness(0.2);
g.setFitness("foo"); //this should fail

UPDATE

Both compile and runtime failures are ok.

Answer 1

Apart from using libraries like Boost.Any, a small modification of your source already works. Simply add a templated constructor to initialize the Genome, and have an equality test using the (implementation defined) typeid() operator between the new and old types.

#include<stdexcept>
#include<memory>
#include<typeinfo>

class Genome 
{
private:
        class FitnessConcept 
        {
        public:
                virtual ~FitnessConcept() {}
        };

        template<typename T>
        class Fitness
        : 
                public FitnessConcept
        {
        public:
                explicit Fitness(T v)
                : 
                        value_(v) 
                {}      

                T value() 
                { 
                        return value_; 
                }

        private:
                T value_;                   
        };

public:
        template<typename T>
        explicit Genome(T v)
        : 
                fitness_(new Fitness<T>(v)) 
        {}

        template<typename T> 
        void setFitness(T v) 
        {
                auto u = std::make_shared< Fitness<T> >(v);
                if (typeid(fitness_).name() == typeid(u).name())
                        fitness_ = u;
                else
                        throw std::invalid_argument("cannot change initialized genome type\n");
        }

        template<typename T>
        T getFitness() {
                return static_cast<Fitness<T>*>(fitness_.get())->value();
        }

private:
        std::shared_ptr<FitnessConcept> fitness_;           
};

int main()
{
        Genome g(1.0);          // OK
        g.setFitness(2.0);      // OK
        g.setFitness("3.0");    // throws exception

        return 0;
}

Output on Ideone. There are several variations possible. E.g. if you do a dynamic_cast< u->get() >(fitness_->get()) then this will throw a std::bad_cast exception if the current underlying type of Genome is not convertible to the new type. This would allow you to change Genome to derived type but not to completely unrelated types.