如何在只在派生类中工作的基类中定义方法？

Question

标题有点含糊不清，所以我将提供一个我想要实现的例子：

class ValuePtr {
public:
    operator const void*() {
        return glm::value_ptr(*this); // value ptr won't work on this class 
                                      //(only works on glm types)
    }
};

class Mat4x4: public glm::mat4x4, public ValuePtr {
    // ...but would work here
};
class Vec3: public glm::vec3, public ValuePtr {
    // ...and here.
}

在某种程度上这样的事情可能吗？

glm::value_ptr只适用于glm类型，如glm::mat4x4 ， glm::vec3等。因此，如果我直接在派生类中实现它，上面提到的方法会起作用，但是它们都应该定义operator const void*完全相同的方式。 我想要一个类似特质的行为：在公共基类中定义它，而定义仅在派生类中起作用。

---

感谢答案，这是我将使用的解决方案：

template<class T>
class ValuePtr: public T {
public:
    operator const void*() {
        return glm::value_ptr(*this);
    }
};

class Mat4x4: public ValuePtr<glm::mat4x4> {
};

Answer 1

编辑：我想我现在根据其他评论/编辑了解问题。 我的下一个建议是尝试一个模板：

template<typename GlmType>
class ValuePtr {
private:
   const GlmType& m_glm;

public:
   ValuePtr(const GlmType& glm)
     :m_glm(glm)
   {
   }

   operator const void*() {
      return glm::value_ptr(m_glm);
   }
};

class Mat4x4: public glm::mat4x4, public ValuePtr<Mat4x4> {
public:
   Mat4x4()
      : ValuePtr(*this)
   {
   }
};

如果你需要每个人都有一个共同的基类，你只需要在模板化的基础之上的另一层。

原版的：

我不完全确定你需要做什么，所以我会尽力覆盖所有的基础。 一种可能性是基类ValuePtr根本不需要operator const void*() 。 在这种情况下，只需将其移动到Mat4x4：

class ValuePtr {
};

class Mat4x4: public glm::mat4x4, public ValuePtr {
    operator const void*() {
        return glm::value_ptr(*this);
    }
};

但也许你想在这两个类中都有这个功能，并且在每种情况下做一些不同的事情。 我不知道你想要基本版本做什么，所以让我们让它返回null：

class ValuePtr {
   operator const void*() {
      return nullptr;
   }    
};

class Mat4x4: public glm::mat4x4, public ValuePtr {
   operator const void*() {
      return glm::value_ptr(*this);
   }
};

最后，也许你将从ValuePtr派生出多个类，并且所有这些类都需要可以转换为const void *，但是在基础本身中没有合理的方法来实现它。 在这种情况下，使用纯虚函数：

class ValuePtr {
    virtual operator const void*() = 0;
};

class Mat4x4: public glm::mat4x4, public ValuePtr {
   virtual operator const void*() override {
      return glm::value_ptr(*this);
   }
};

（ override关键字是可选的，实际上可能不起作用，具体取决于您拥有的编译器）。

Answer 2

你的意思是这样的？

template<class GLM_THING> class has_value_ptr {
  has_value_ptr(const GLM_THING& data)
  : _glmData(data) { }
public:
  operator void*() {
    return &_glmData;
  }

  GLM_THING& glmData() { return _glmData; }
  const GLM_THING& glmData() const { return _glmData; }

private:    
  GLM_THING _glmData;
};

class Mat4x4 : public has_value_ptr<glm::mat4x4> {
public:
  Mat4x4(const glm::mat4x4& data)
  : has_value_ptr<glm::max4x4>(data)
  {
  }
  ...
};