強制派生的 class 覆蓋一組虛擬函數中的一個

Question

給定具有一些虛函數的基本 class ，任何人都可以想出一種方法來強制派生的 class 在編譯時恰好覆蓋一組虛函數中的一個嗎？ 或者實現相同目的的 class 層次結構的替代公式？

在代碼中：

struct Base
{
    // Some imaginary syntax to indicate the following are a "pure override set"
    // [
    virtual void function1(int) = 0;
    virtual void function2(float) = 0;
    // ...
    // ]
};

struct Derived1 : Base {}; // ERROR not implemented
struct Derived2 : Base { void function1(int) override; }; // OK
struct Derived3 : Base { void function2(float) override; }; // OK

struct Derived4 : Base // ERROR too many implemented
{
    void function1(int) override;
    void function2(float) override;
};

我不確定我是否真的有一個實際的用例，但是當我正在實現一些松散地遵循這種模式的東西時，我突然想到這是一個值得思考的有趣問題，如果沒有別的。

Answer 1

不，但你可以偽造它。

Base 具有非虛擬 float 和 int 方法，它們轉發到純虛擬 std 變體之一。

兩個輔助類，一個 int 一個 float，實現 std 變體之一，將兩種情況轉發到純虛擬 int 或 float 實現。

它負責處理“錯誤類型”案件。

派生繼承自一個或另一個助手，並且僅實現 int 或 float。

struct Base
{
    void function1(int x) { vfunction(x); }
    void function2(float x) { vfunction(x); }
    virtual void vfunction(std::variant<int,float>) = 0;
};
struct Helper1:Base {
    void vfunction(std::variant<int,float> v) final {
      if (std::holds_alternative<int>(v))
        function1_impl( std::get<int>(v) );
    }
    virtual void function1_impl(int x) = 0;
};
struct Helper2:Base {
    void vfunction(std::variant<int,float> v) final {
      if (std::holds_alternative<float>(v))
        function2_impl( std::get<float>(v) );
    }
    virtual void function2_impl(float x) = 0;
};

struct Derived1 : Base {}; // ERROR not implemented
struct Derived2 : Helper1 { void function1_impl(int) override; }; // OK
struct Derived3 : Helper2 { void function2_impl(float) override; }; // OK

這使用https://en.wikipedia.org/wiki/Non-virtual_interface_pattern - 接口包含非虛擬方法，可以覆蓋其細節以使其行為不同。

如果你害怕人們會覆蓋vfunction ，你可以使用私有鎖技術，和/或只是給它一個名字，比如private_implementation_detail_do_not_implement並相信你的代碼審查過程。

Answer 2

或者實現相同目的的 class 層次結構的替代公式？

一種選擇是使用實現一個 function 的中間基礎 class。

struct Base
{
    virtual ~Base() {};
    virtual void function(int) = 0;
    virtual void function(float) = 0;
};

template <typename T>
struct TBase : Base
{
   virtual void function(T) override {} 
};

struct Derived1 : Base {};
struct Derived2 : TBase<float> { void function(int) override {} };
struct Derived3 : TBase<int> { void function(float) override {} };

int main()
{
   Derived1 d1; // ERROR. Virtual functions are not implemented
   Derived2 d2; // OK.
   Derived3 d3; // OK.
}

請注意，在這種方法中，函數被命名為function ，而不是function1和function2 。

Answer 3

如果您不覆蓋所有抽象虛擬方法，您的類將保持抽象。 如果你想實例化 object，你必須做所有這些。