具有基于概念的多态性的多重继承 C++

使用基于概念的多态，重点是使用值语义和类型擦除来实现类型多态，如何实现多重继承？

界面示例如下所示。它定义了一个可序列化的类型，以要求具有适当签名的函数序列化和大小。

#include <iostream>
#include <memory>

using namespace std;

class Serializable {
public:
  template <typename T>
  Serializable(T x) : self_(new model<T>(move(x)))
  { }

  friend size_t serialize(const Serializable& x, uint8_t* buffer, size_t bufferSize) {
    x.self_->serialize_(buffer, bufferSize);
  }
  friend size_t size(const Serializable& x) {
    x.self_->size_();
  }

private:
  struct Concept {
    virtual ~Concept() = default;
    virtual size_t serialize_(uint8_t*, size_t bufferSize) const = 0;
    virtual size_t size_() const = 0;
  };
  template <typename T>
  struct model : Concept {
    model(T x) : data_(move(x)) { }
    size_t serialize_(uint8_t* buffer, size_t bufferSize) const
    { serialize(data_, buffer, bufferSize); }
    size_t size_() const
    { size(data_); }

    T data_;

  };

  shared_ptr<const Concept> self_;
};

然后实现接口的类如下所示。它没有直接继承纯虚函数，而是使用相同的函数名。MyClassB 后来使用并且是相同的实现，只是名称不同。

class MyClassA {
public:
  MyClassA(const string& name) :
    name_(name)
  { }

  friend size_t serialize(const MyClassA& x, uint8_t* buffer, size_t bufferSize);
  friend size_t size(const MyClassA& x);
private:
  const string name_;
};

size_t serialize(const MyClassA& x, uint8_t* buffer, size_t bufferSize) {
  size_t bytesToWrite = size(x);
  if(bytesToWrite <= bufferSize) {
      memcpy(buffer, x.name_.c_str(), bytesToWrite);
    } else {
      bytesToWrite = 0;
    }
  return bytesToWrite;
}

size_t size(const MyClassA& x) {
  x.name_.length();
}

此外，为向量创建了相同的签名。

size_t size(const vector<Serializable>& x) {
  size_t totalSize = 0;
  for (auto& e : x) {
    totalSize += size(e);
  }
  return totalSize;
}

size_t serialize(const vector<Serializable>& x, uint8_t* buffer, size_t bufferSize) {
  size_t bytesToWrite = size(x);
  size_t offset = 0;
  if(bytesToWrite <= bufferSize) {
      for (auto& e : x) {
        offset += serialize(e, buffer + offset, bufferSize - offset);
      }
    } else {
      bytesToWrite = 0;
    }
  return bytesToWrite;
}

然后使用类型、MyClassA、MyClassB 和向量，下面的客户端代码创建对象，将它们添加到向量中，然后打印它们。

int main() {
  vector<Serializable> channel;
  uint8_t buffer[30] = {};

  MyClassA myClassA("Hello World!");
  serialize(myClassA, buffer, sizeof buffer);
  cout << buffer << endl;

  cout << "-------------------" << endl;

  channel.emplace_back(MyClassA(" Apples"));
  channel.emplace_back(MyClassB(" Oranges"));
  serialize(channel, buffer, sizeof buffer);
  cout << buffer << endl;

  cout << "-------------------" << endl;

  cout << size(channel) << endl;

  cout << "-------------------" << endl;

  vector<Serializable> channel2;
  channel2.emplace_back(channel);
  channel2.emplace_back(channel);
  serialize(channel2, buffer, sizeof buffer);
  cout << buffer << endl;
}

代码已在以下存储库中准备好。在根目录中构建运行 scons：https : //github.com/moritz89/type-erasure-test? files =1

回到最初的问题，是否可以创建额外的接口，例如 ReportError 或 Client，来定义必须实现的功能，并且可以统一创建多继承结构？