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

考虑以下类定义：

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);
            }
        }
}

---

将来，可以在Car中定义更多的类实例。有没有办法减少重载构造函数和update（）函数的数量？可能使用模板？我觉得它看起来很难看，在设计上很明智，使用了这么多重载函数。

另一种代码可能是：

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);                        
}

---

另一种代码可以是：

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);                        
}

---

我的想法是使用std：：any来做这件事。假设Car类中的每种类型只有一个实例

以下是我的解决方案：

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);
            }

        }
    }

}

车辆类别：公共车辆{
私人：
std：：无序的_映射组件；
公众：
汽车（标准：任何和车载）{
字符串类型名（obj.type（）.name（））；
插入（组成一对（类型名称，obj））；
}
模板
无效更新（T&F、T&a1）
{
（std：：any_cast（found））.更新（std：：any_cast（a1））；
}
无效更新（标准：：任何&a1）{
std:：string typeName（a1.type（）.name（））；
std:：any found=components.find（typeName）；
如果（找到！=组件.end（））
{
if（typeName==std:：string（typeid（TouchScreen）.name（））
{
更新（第二次发现，a1）；
}
else if（typeName==std:：string（typeid（RadioAntenna）.name（））
{
更新（第二次发现，a1）；
}
else if（typeName==std:：string（typeid（Blah）.name（））
{
更新（第二次发现，a1）；
}
}
}
}

我的想法是使用std:：any来实现。假设在Car类中每种类型只有一个实例

以下是我的解决方案：

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);
            }

        }
    }

}

车辆类别：公共车辆{
私人：
std：：无序的_映射组件；
公众：
汽车（标准：任何和车载）{
字符串类型名（obj.type（）.name（））；
插入（组成一对（类型名称，obj））；
}
模板
无效更新（T&F、T&a1）
{
（std：：any_cast（found））.更新（std：：any_cast（a1））；
}
无效更新（标准：：任何&a1）{
std:：string typeName（a1.type（）.name（））；
std:：any found=components.find（typeName）；
如果（找到！=组件.end（））
{
if（typeName==std:：string（typeid（TouchScreen）.name（））
{
更新（第二次发现，a1）；
}
else if（typeName==std:：string（typeid（RadioAntenna）.name（））
{
更新（第二次发现，a1）；
}
else if（typeName==std:：string（typeid（Blah）.name（））
{
更新（第二次发现，a1）；
}
}
}
}

if语句中的条件应该颠倒。不，我的意思是检查指针是否为null，然后取消引用它们。应该检查它们是否为null。因此

if（a1）a.update（*a1）

等等。if语句中的条件应该颠倒。不，我的意思是你要检查指针是否为null，然后取消对它们的引用。你应该检查它们是否为null。所以

if（a1）a.update（*a1）

等等。