Question

我花了好几个小时，当我意识到只有我的代码的模板化版本有错误时才完全陷入困境。

在以下代码中，当myMap中的push_back元素时，原始向量myVec1和myVec2被修改并在执行结束时包含垃圾。如果我取消所有内容的模板，只需将template<T>替换为double，那么代码就可以正常工作（原始数组不受影响）。

有趣的是，如果我在cout中放置copy constructor，如果代码是模板化的，则不会调用它。但是，如果我用原始类型Vector<T2>将Vector<T>替换为复制构造函数，则会调用它，然后一切正常。

为什么编译器不会知道T2==T，因为我只使用double？

（请注意，代码已尽可能短，以便显示错误 - 因此我删除了访问者，使所有内容公开等。）

#include <vector>
#include <map>


template<class T>
class Vector{
public:
    Vector():n(0),data(0){};
    Vector(int N):n(N),data(new T[N]){};
    Vector(T x, T y):n(2),data(new T[2]){data[0]=x; data[1]=y;};
    template<class T2> Vector(const Vector<T2>& rhs):n(rhs.n), data(new T[n])
    {
        for (int i=0; i<n; i++)
            data[i] = T(rhs.data[i]);
    }   
    ~Vector(){delete[] data;}

    Vector& operator=(const Vector& rhs)
    {
        if (rhs.n != n)
        {
            if (data)
                delete[] data;
            data = new T[rhs.n];
        }
        n = rhs.n;
        memcpy(data, rhs.data, n*sizeof(T));
        return *this;
    }
    T& operator[](int i){return data[i];}
    const T& operator[](int i) const {return data[i];}
    int n;
    T* data;
};

typedef  Vector<double> Vectord;

template <class T> inline bool operator<(const Vector<T>& v1, const Vector<T>& v2)
{
    for (int i=0; i<v1.n; i++)
    {
        if (v1[i]<v2[i]) return true;
        if (v1[i]>v2[i]) return false;
    }
    return false;
}


int main(int argc, char** argv)
{
    std::vector<Vectord> myVec1(3);
    myVec1[0] = Vectord(1.,3.);
    myVec1[1] = Vectord(3.,3.);
    myVec1[2] = Vectord(1.,5.);

    std::vector<Vectord> myVec2(3);
    myVec2[0] = Vectord(4.,1.);
    myVec2[1] = Vectord(2.,5.);
    myVec2[2] = Vectord(6.,5.);

    std::map<Vectord, std::vector<Vectord> > myMap;
    for (int i=0; i<3; i++)
    {
        myMap[myVec1[i]].push_back(myVec2[i]);
    }



    return 0;
}

Answer 1

模板化构造函数永远不是复制构造函数。

所以你的类正在使用自动生成的拷贝构造函数。

干杯＆amp;第h。，

模板化代码在非模板化代码工作时不起作用！

1 个答案: