Question

假设我想要一个指向std :: vector的指针的成员变量，但我不想指定它存储的变量类型。我想只访问那些独立于它的实际泛型类型的函数。这可能用c ++吗？像这样的东西：

class Foo{
public:
    void setVec(std::vector* someVec){
        myVec = someVec;
    };
    int getSize(){
        return myVec.size();
    };
private:
    std::vector* myVec;
};


int main(){
    Foo foo;
    vector<int> vec1;
    vector<float> vec2;
    foo.setVec(&vec1);
    cout<<foo.getSize();
    foo.setVec(&vec2);
    cout<<foo.getSize();
}

注意：我不想模板Foo，我想只使用一个Foo实例和不同类型的矢量。

当然 - 如果我可以改变类向量，那么我可以创建一个未模板化的基类

class Ivector{
    virtual int size()=0;
};

然后制作

class vector<T> : public IVector...

继承自Ivector。但是，如果我不能改变有问题的类并且模板化的类没有这样一个没有模板的基类，我该怎么办？

谢谢！

Answer 1

你差不多答案了。不要让std :: vector继承自Ivector，而是创建一个新类：

template <typename T>
class IVectorImpl : public Ivector
{
public:
    explicit IVectorImpl(std::vector<T> * Data) : m_Data(Data){}
    std::vector<T> * m_Data;
 ...
     virtual int size() const {return m_Data->size();}
  // Implement all the Ivector functions here to call the respective functions off of m_Data
};

现在让你的Foo类保持一个指向Ivector而不是std :: vector的指针。

使Foo :: setVec模板化

template <typename T>
void setVec(std::vector<T> * vec)
{
   Ivector * newVec = new IVectorImpl<T>(vec);
   delete myVec;
   myVec = newVec;
}

Answer 2

你可以这样做：

class vector_container_base
{
public:
    ~vector_container_base() {}

    virtual std::size_t size() const = 0;
};

template <typename T>
class vector_container :
    public vector_container_base
{
public:
    typedef std::vector<T> vector_type;

    std::size_t size() const
    {
        return mVector.size();
    }

private:
    vector_type mVector;
};

依此类推，但我怀疑这在任何实际情况下都太有用了。

Answer 3

该行

std::vector* myVec

在语法上不正确。必须指定向量元素的类型。

可能想要在

行上做点什么

template< typename T >
class Foo{
  private:
    std::vector<T> * myVec;
};

然而，即使这样看起来不太好，重新评估设计在这里可能更为重要。

指向任意类型的std :: vector（或任何其他模板化类）的指针

3 个答案: