How to write classes with generic functions that accept parameters of different types and inherit from a base abstract class?

[Kulagin]

In my project, I have a base abstract class with an interface, which derived classes implement. These derived classes have generic functions that accept parameters of different types. I have written these generic functions in my derived classes using function templates.

I want to add these templated functions to the interface in my base class. So I can achieve polymorphism: accept base class in other functions and call these templated functions in derived classes.

When we have normal functions, we do virtual and override, but you can't do virtual with templated functions.

I tried to do pure abstract templated functions in my abstract base class but it doesn't work.

Here's a small program with the functionality I'm trying to achieve, which doesn't compile because of virtual <template...:

// bastAbstractTemplates.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include <iostream>
#include <vector>

class ObjectTransformerBaseAbstractClass {
public:
    virtual template<typename TStructure> TStructure ToStructure(std::vector<unsigned char> bytes) = 0;
    virtual template<typename TStructure> std::vector<unsigned char> ToBytes(TStructure structure) = 0;
};

class ObjectTransformer1 : public ObjectTransformerBaseAbstractClass {
    template <typename TStructure> TStructure ToStructure(std::vector<unsigned char> bytes) {
        unsigned char* bytePointer = &bytes[0];
        TStructure structure = reinterpret_cast<TStructure>(bytePointer);
        return structure;
    }

    template <typename TStructure> std::vector<unsigned char> ToBytes(TStructure structure) {
        const std::unique_ptr<unsigned char[]> bytesArray = std::make_unique<unsigned char[]>(reinterpret_cast<unsigned char[sizeof(structure)]>(structure));
        return std::vector<unsigned char>(bytesArray.get(), bytesArray.get() + sizeof(structure));
    }
};

class ObjectTransformer2 : public ObjectTransformerBaseAbstractClass {
    template <typename TStructure> TStructure ToStructure(std::vector<unsigned char> bytes) {
        TStructure structure{};
        std::memcpy(&structure, &bytes[0], sizeof(TStructure));
        return structure;
    }
    template <typename TStructure>
    std::vector<unsigned char> ToBytes(TStructure structure) {
        std::vector<unsigned char> bytes{};
        bytes.resize(sizeof(TStructure));
        std::memcpy(&bytes[0], &structure, sizeof(TStructure));
        return bytes;
    }
};

template <typename TStructure>
void coutStructureBytes(ObjectTransformerBaseAbstractClass *objectTransformerBaseAbstractClass, TStructure structure) {
    auto bytes = objectTransformerBaseAbstractClass->ToBytes<TStructure>(structure);
    for(auto byte : bytes) {
        std::cout << byte << ' ';
    }
    std::cout << std::endl;
}

int main() {
    ObjectTransformer1 objectTransformer1{};
    ObjectTransformer1 objectTransformer2{};

    int integer = 5;
    float someFloat = 9.79;

    coutStructureBytes(&objectTransformer1, integer);
    coutStructureBytes(&objectTransformer2, someFloat);
}

In my base class I need to say "Implement these pure abstract generic functions which accept different parameters of different types and do stuff in derived classes". And in my derived classes I need to implement these pure abstract generic functions that accept parameters of different types.

I don't understand how to achieve this functionality I want to have(which you can see in the above program if it compiled and worked). Please, help.

[dhayden]

The second answer here: https://stackoverflow.com/questions/2354210/can-a-class-member-function-template-be-virtual

Member function templates cannot be declared virtual. This constraint is imposed because the usual implementation of the virtual function call mechanism uses a fixed-size table with one entry per virtual function. However, the number of instantiations of a member function template is not fixed until the entire program has been translated. Hence, supporting virtual member function templates would require support for a whole new kind of mechanism in C++ compilers and linkers. In contrast, the ordinary members of class templates can be virtual because their number is fixed when a class is instantiated

[ne555]

playing around with multiple dispatch

#include <cstring>
#include <iostream>
#include <vector>

// all the different specializations
class Transformer_Copy;
class Transformer_Zero;

// abstract base class to pass around the different structures
class Wrapper {
public:
  // for every transformer specialization you'll need these two functions
  // Transformer_Copy
  virtual void to_object(std::vector<unsigned char> bytes,
                         Transformer_Copy *transformer) = 0;
  virtual std::vector<unsigned char>
  to_bytes(Transformer_Copy *transformer) = 0;

  // Transformer_Zero
  virtual void to_object(std::vector<unsigned char> bytes,
                         Transformer_Zero *transformer) = 0;
  virtual std::vector<unsigned char>
  to_bytes(Transformer_Zero *transformer) = 0;
};

class Transformer {
public:
  // note that it works with a Wrapper, no templates here
  // all specializations will implement these two functions the same way
  // so using CRTP for that
  virtual void to_object(std::vector<unsigned char> bytes,
                         Wrapper *structure) = 0;
  virtual std::vector<unsigned char> to_bytes(Wrapper *structure) = 0;
};

// CRTP
// call the appropriate function in the Wrapper class according to the template
// parameter
template <class T> class Transformer_Instance : public Transformer {
public:
  virtual void to_object(std::vector<unsigned char> bytes,
                         Wrapper *structure) override {
    structure->to_object(bytes, reinterpret_cast<T *>(this));
  }
  virtual std::vector<unsigned char> to_bytes(Wrapper *structure) override {
    return structure->to_bytes(reinterpret_cast<T *>(this));
  }
};

class Transformer_Copy : public Transformer_Instance<Transformer_Copy> {
public:
  // actual work
  // yes, they are template, but not virtual
  template <class T> std::vector<unsigned char> to_bytes_template(T structure) {
    std::vector<unsigned char> bytes{};
    bytes.resize(sizeof(structure));
    std::memcpy(&bytes[0], &structure, sizeof(structure));
    return bytes;
  }
  template <class T>
  void to_object_template(std::vector<unsigned char> bytes, T &structure) {
    std::memcpy(&structure, &bytes[0], sizeof(structure));
  }
};

// another specialization
class Transformer_Zero : public Transformer_Instance<Transformer_Zero> {
public:
  // actual work
  template <class T> std::vector<unsigned char> to_bytes_template(T structure) {
    std::vector<unsigned char> bytes{};
    bytes.resize(sizeof(structure));
    return bytes;
  }
  template <class T>
  void to_object_template(std::vector<unsigned char> bytes, T &structure) {
    bzero(&structure, sizeof(bytes.size()));
  }
};

// the dispatcher
template <class T> class Wrapper_Instance : public Wrapper {
public:
  T value;
  Wrapper_Instance(T value) : value(value) {}

  // here we deal with the derived class directly, so can call their specific
  // member functions
  // again, note that all specializations have the same code

  // Transformer_Copy
  virtual void to_object(std::vector<unsigned char> bytes,
                         Transformer_Copy *transformer) override {
    transformer->to_object_template(bytes, value);
  }
  virtual std::vector<unsigned char>
  to_bytes(Transformer_Copy *transformer) override {
    return transformer->to_bytes_template(value);
  }

  // Transformer_Zero
  virtual void to_object(std::vector<unsigned char> bytes,
                         Transformer_Zero *transformer) override {
    transformer->to_object_template(bytes, value);
  }
  virtual std::vector<unsigned char>
  to_bytes(Transformer_Zero *transformer) override {
    return transformer->to_bytes_template(value);
  }
};

// usage example
template <typename TStructure>
void cout_bytes(Transformer *transformer, TStructure structure) {
  Wrapper_Instance<TStructure> wrapper(structure); // wrapping
  auto bytes = transformer->to_bytes(&wrapper);
  for (auto byte : bytes) {
    std::cout << (int)byte << ' ';
  }
  std::cout << std::endl;
}

template <typename TStructure>
void recover(Transformer *transformer, std::vector<unsigned char> v,
             TStructure &structure) {
  Wrapper_Instance<TStructure> wrapper(structure); // wrapping
  transformer->to_object(v, &wrapper);

  structure = wrapper.value;
}

int main() {
  Transformer_Copy transformer_copy{};
  Transformer_Zero transformer_zero{};

  int integer = 5;
  float someFloat = 9.79;
  std::vector<unsigned char> v{215, 163, 28,
                               65}; // the bytes of the float in my case

  std::cout << "Copy\n";
  cout_bytes(&transformer_copy, integer);
  cout_bytes(&transformer_copy, someFloat);

  recover(&transformer_copy, v, integer);
  recover(&transformer_copy, v, someFloat);

  std::cout << integer << '\n' << someFloat << '\n';
  std::cout << "\n\nZero\n";
  cout_bytes(&transformer_zero, integer);
  cout_bytes(&transformer_zero, someFloat);

  recover(&transformer_zero, v, integer);
  recover(&transformer_zero, v, someFloat);

  std::cout << integer << '\n' << someFloat << '\n';
}

for each new Transformer specialization you'll need to do these things:
* forward declare it before Wrapper definition
* add your class to the Wrapper member function declaration (pure virtual)
* create your own to_bytes_template() and to_object_template() that do the actual work
* override in the Wrapper_Instance, calling the template version
macros may help, but still need to touch three classes...

[Kulagin]

Here's a C# version of the behavior I'm trying to achieve:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace baseAbstractTemplates.NET {
    interface IObjectTransformer {
        TStructure ToStructure<TStructure>(ICollection<byte> bytes);
        ICollection<byte> ToBytes<TStructure>(TStructure structure);
    };

    class ObjectTransformer1 : IObjectTransformer {

        #region Implementation of IObjectTransformerBaseAbstractClass

        public TStructure ToStructure<TStructure>(ICollection<byte> bytes) {
            throw new NotImplementedException();
        }

        public ICollection<byte> ToBytes<TStructure>(TStructure structure) {
            throw new NotImplementedException();
        }

        #endregion

    }

    class ObjectTransformer2 : IObjectTransformer {

        #region Implementation of IObjectTransformerBaseAbstractClass

        public TStructure ToStructure<TStructure>(ICollection<byte> bytes) {
            throw new NotImplementedException();
        }

        public ICollection<byte> ToBytes<TStructure>(TStructure structure) {
            throw new NotImplementedException();
        }

        #endregion

    }

    class Program {
        public static void CoutStructureBytes(IObjectTransformer objectTransformer) {
            var bytes = objectTransformer.ToBytes(3);
            Console.WriteLine(bytes);
        }

        static void Main(string[] args) {
            ObjectTransformer1 objectTransformer1 = new ObjectTransformer1();
            ObjectTransformer2 objectTransformer2 = new ObjectTransformer2();
            CoutStructureBytes(objectTransformer1);
            CoutStructureBytes(objectTransformer2);
        }
    }
}

In C# it just works in "haha C# interfaces, templates, polymorphism go brrr" style. Even if you're not familiar with C# at all but have C++ knowledge, I'm sure you can follow that C# code just fine.

This compiles and runs just fine, throws NotImplementedException because not implemented.

But in C++, unlike in C#, I can't just have interfaces with templates, inheritance and polymorphism using usual tools: pure abstract functions(which I override in derived classes), templates, inheritance and method overriding. Because I can't mix method templates with virtual.

After a few days of research I finally found how it's done here:
https://www.modernescpp.com/index.php/c-is-still-lazy


CRTP and Static Polymorphism. Finally, C++ version of the behavior I was trying to achieve:

// bastAbstractTemplates.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include <iostream>
#include <vector>
#include <string>

template<typename DerivedClass>
class IObjectTransformer {
public:
    template<typename TStructure> TStructure ToStructure(std::vector<unsigned char> bytes);
    template<typename TStructure> std::vector<unsigned char> ToBytes(TStructure structure);
private:
    IObjectTransformer() = default;

    friend DerivedClass;
};

template <typename DerivedClass>
template <typename TStructure>
TStructure IObjectTransformer<DerivedClass>::ToStructure(std::vector<unsigned char> bytes) {
    return static_cast<DerivedClass*>(this)->ToStructure(bytes);
}

template <typename DerivedClass>
template <typename TStructure>
std::vector<unsigned char> IObjectTransformer<DerivedClass>::ToBytes(TStructure structure) {
    return static_cast<DerivedClass*>(this)->ToBytes(structure);
}

class ObjectTransformer1 : public IObjectTransformer<ObjectTransformer1> {
public:
    template <typename TStructure> TStructure ToStructure(std::vector<unsigned char> bytes) {
        unsigned char* bytePointer = &bytes[0];
        TStructure structure = reinterpret_cast<TStructure>(*bytePointer);
        return structure;
    }

    template <typename TStructure> std::vector<unsigned char> ToBytes(TStructure structure) {
        char* bytesArray = reinterpret_cast<char*>(&structure);
        auto byteVec = std::vector<unsigned char>(bytesArray, bytesArray + sizeof(TStructure));
        return byteVec;
    }
};

class ObjectTransformer2 : public IObjectTransformer<ObjectTransformer2> {
public:
    template <typename TStructure> TStructure ToStructure(std::vector<unsigned char> bytes) {
        TStructure structure{};
        std::memcpy(&structure, &bytes[0], sizeof(TStructure));
        return structure;
    }
    template <typename TStructure>
    std::vector<unsigned char> ToBytes(TStructure structure) {
        std::vector<unsigned char> bytes{};
        bytes.resize(sizeof(TStructure));
        std::memcpy(&bytes[0], &structure, sizeof(TStructure));
        return bytes;
    }
};


template <typename DerivedClass, typename TStructure>
void CoutStructureBytes(IObjectTransformer<DerivedClass> *objectTransformerBaseAbstractClass, TStructure structure) {
    auto bytes = objectTransformerBaseAbstractClass->template ToBytes<TStructure>(structure);
    for(auto byte : bytes) {
        std::cout << std::to_string(byte) << ' ';
    }
    std::cout << std::endl;
}

int main() {
    ObjectTransformer1 objectTransformer1{};
    ObjectTransformer1 objectTransformer2{};

    int integer = 5;
    float someFloat = 9.79f;

    CoutStructureBytes(&objectTransformer1, integer);
    CoutStructureBytes(&objectTransformer2, someFloat);
}

PS I can barely follow this code myself even though I wrote it, but I guess I'll get used to it.