Esto es de lo que estoy hablando.

<code>// some guy wrote this, used as a Policy with templates
struct MyWriter {
  void write(std::vector<char> const& data) {
    // ...
  }
};
</code>

En algunos códigos existentes, las personas no usaron plantillas, sino interfaces + borrado de tipo

<code>class IWriter {
public:
  virtual ~IWriter() {}

public:
  virtual void write(std::vector<char> const& data) = 0;
};
</code>

Alguien más quería ser utilizable con ambos enfoques y escrituras.

<code>class MyOwnClass: private MyWriter, public IWriter {
  // other stuff
};
</code>

MyOwnClass se implementa en términos de MyWriter. ¿Por qué las funciones de miembro heredadas de MyOwnClass no implementan la interfaz de IWriter automáticamente? En su lugar, el usuario tiene que escribir funciones de reenvío que no hacen más que llamar a las versiones de clase base, como

<code>class MyOwnClass: private MyWriter, public IWriter {
public:
  void write(std::vector<char> const& data) {
    MyWriter::write(data);
  }
};
</code>

Sé que en Java, cuando tiene una clase que implementa una interfaz y deriva de una clase que tiene métodos adecuados, esa clase base implementa automáticamente la interfaz para la clase derivada.

¿Por qué C ++ no hace eso? Parece algo natural tenerlo.