Est-il possible de transférer des appels de fonction avec le type de modèle correspondant pour un conteneur std :: any-like?

Si vous souhaitez écrire une petite classe wrapper pour chaque fonction de type processData , vous pouvez faire quelque chose comme ceci:

// One like this for each function.
struct ProcessDataWrapper {
  template <typename... Args>
  static auto run(Args&&... args) {
    return processData(std::forward<Args>(args)...);
  }
};

template <typename Wrapper>
auto ProcessGeneric(BaseContainer* aContainer) {
    switch (vContainer->getType()) {
        case DataTypes::INT8:
            return Wrapper::run(dynamic_cast<DataContainer<int8_t>>(vContainer)->getData());
    // ...
}

// Called as
ProcessGeneric<ProcessDataWrapper>(myContainer);

C'est possible, mais comme le disent les commentaires, cela pourrait valoir la peine de considérer std :: visit.

Voici une solution nécessitant C ++ 17 qui ne nécessite que deux lignes pour chaque modèle de fonction que vous voulez envelopper. Vous pouvez utiliser une simple macro pour simplifier davantage l'écriture.

L'idée de base est d'avoir une fonction cast qui mappe d'une énumération DataType à la correspondant à DataContainer , puis pour tirer parti des expressions c ++ 17 fold pour envelopper l'instruction switch dans votre code.

Voici la fonction cast , nous avons donc exactement un endroit pour mapper de DataType au DataContainer actuel :

    ([&]{ if(c.GetDataType() == types ) {  std::invoke(f, cast<types>(c), args...); return true; } return false; }() || ...  || []() -> bool{ throw (std::runtime_error("Type not supported")); }());
                                                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

C'est plutôt une aide pratique pour faire le code suivant un peu plus lisible. Le bloc de code suivant utilise l'expression c ++ 17 fold pour distribuer la fonction en fonction du type du conteneur.

int main() {

    DataContainer<float> f;
    DataContainer<int> i;
    pd(f, 2); // prints float, 2
    pd(i, 4); // prints int, 4
}

L'idée de base est d'envelopper la fonction dans un lambda qui vérifie le DataType du DataContainer et n'appelle la fonction que si elle correspond. L'expression Fold sur l'opérateur || est utilisée pour décompresser les DataTypes.

Exemple d'utilisation:

template<typename T>
void processData(DataContainer<T>& c, int arg) {
    if constexpr(std::is_same_v<T, int>) std::cout << "int";
    else if constexpr(std::is_same_v<T, float>) std::cout << "float";
    std::cout << ", arg: " << arg << '\n';
}

Vous ne pouvez pas passer les surcharges par nom, mais vous pouvez passer fonctor avec operator () surchargé comme lambda générique.

Donc

dispatch(vContainer, [](auto* data){ return processData(data); });

avec utilisation

template <typename F>
auto dispatch(BaseContainer& vContainer, F f) {
    switch (vContainer.getType()) {
        case DataTypes::INT8:
            return f(dynamic_cast<DataContainer<int8_t>&>(vContainer).getData());
        case DataTypes::UINT8:
            return f(dynamic_cast<DataContainer<uint8_t>&>(vContainer).getData());
        case DataTypes::INT16:
            return f(dynamic_cast<DataContainer<int16_t>&>(vContainer).getData());
        case DataTypes::UINT16:
            return f(dynamic_cast<DataContainer<uint16_t>&>(vContainer).getData());
...
        default:
            throw (std::runtime_error("Type not supported"));
    }
}