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*。我想要一个类似trait的行为：在公共基类中定义它，而定义只适用于派生类。

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

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)
  {
  }
  ...
};

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

2 个答案: