减少重载函数和构造函数的数量

Question

Consider the following class definition:

class Car : public Vehicle {
    private:
        TouchScreen a;
        RadioAntenna b;
        Blah c;
    public:
        Car(TouchScreen &a1) {
            a = a1; //copy ctor
        }
        Car(RadioAntenna &b1) {
            b = b1;
        }
        Car(Blah &c1) {
            c = c1;
        }
        void update(Touchscreen &a1) {
            a.update(a1);
        }
        void update(RadioAntenna &b1) {
            b.update(b1);
        }
        void update(Blah &c1) {
            c.update(c1);
        }
}

class Fleet {
    private:
        std::map<int, Car> _fleet; //vehicle number, Car
    public:
        template <typename T>
        void update(int vehicle_num, T &t) {
            auto it = _fleet.find(vehicle_num);
            if (it == _fleet.end()) {
                _fleet[vehicle_num] = Car(t);
            }
            else {
                it->second.update(t);
            }
        }
}

Fleet contains a collection of cars. If you want to update a specific car's member variable,

Fleet f;
f.update<TouchScreen>(4, a1);
f.update<Blah>(10, c1); 

In the future, more class instances can be defined inside Car. Is there a way to reduce the number of overloaded Constructor and update() functions? Using templates maybe? I feel it looks ugly, design wise, using so many overloaded functions.

Answer 1

An alternative code could be:

void Car::update(Touchscreen* a1=nullptr, RadioAntenna* b1=nullptr, Blah* c1=nullptr ) {
        if(a1) a.update(*a1);
        if(b1) b.update(*b1);
        if(c1) c.update(*c1);                        
}

Answer 2

My idea is to use std::any for doing it. Assumed you have only one instance for each type inside Car class.

Here is my solution:

class Car : public Vehicle {
private:
    std::unordered_map<std::string, std::any> components;
public:
    Car(std::any &obj) {
        std::string typeName(obj.type().name());
        components.insert(make_pair(typeName, obj));
    }

    template<typename T> 
    void update(T& found, T &a1)
    {
        (std::any_cast<T>(found)).update(std::any_cast<T>(a1));
    }

    void update(std::any  &a1) {
        std::string typeName(a1.type().name());
        std::any found  =  components.find(typeName);
        if (found != components.end())
        {
            if (typeName ==  std::string(typeid(TouchScreen).name())
            {
                update<TouchScreen>(found.second, a1);
            }
            else if (typeName ==  std::string(typeid(RadioAntenna ).name())
            {
                update<RadioAntenna>(found.second, a1);
            }
            else if (typeName ==  std::string(typeid(Blah  ).name())
            {
                update<Blah>(found.second, a1);
            }

        }
    }

}