6

我开始学习 c++，但我被困在析构函数中。我们需要实现一个向量，这就是我目前所拥有的。

#include<string.h>
#include<cassert>
#include<iostream>

using namespace std;
template<class T>
class Vector {
    template<class U> friend ostream& operator<<(ostream&, const Vector<U>&);
private:
    T* data;
    unsigned len;
    unsigned capacity;
public:
    Vector(unsigned = 10);
    Vector(const Vector<T>&);
    virtual ~Vector(void);
    Vector<T>& operator =(const Vector<T>&);
    bool operator==(const Vector<T>&);
    T& operator[](unsigned);
};

//PROBLEM! 
template <class T>
~ Vector() {
    delete data;

}

template<class T>
Vector<T>::Vector(unsigned int _capacity)
{
    capacity = _capacity;
    len = _capacity;
    data = new T[_capacity];
}

template<class T>
Vector<T>::Vector(const Vector<T> & v)
{
    len = v.len;
    capacity = v.capacity;
    data = new T[len];
    for (unsigned int i = 0; i < len; i++)
        data[i] = v.data[i];
}



template<class T>
Vector<T> & Vector<T>::operator = (const Vector<T> & v)
{
    delete[ ] data;
    len = v.len;
    capacity = v.capacity;
    data = new T [len];
    for (unsigned int i = 0; i < len; i++)
        data[i] = v.data[i];
    return *this;
}

template<class T>
bool Vector<T>::operator == (const Vector<T> & v)
{
    bool check = true;
    check &= (len == v.len);
    if (!check) return false;
    check &= (capacity == v.capacity);
    if (!check) return false;
    for (unsigned int i = 0; i < len; i++) {
        check &= (data[i] == v.data[i]);
        if (!check) return false;

    }
    return true;
}

template<class T>
T& Vector<T>::operator[](unsigned int index)
{
    return data[index];
}

给出了接口，我需要实现它。但这与 C 和 Java 有很大的不同，我有点迷茫。

在第二个练习中，我们需要使用 a) 以前的 Vector 实现作为派生类和 b) Vector 作为组合类来实现类似的东西，所以也许我们会在其中一种方法中使用虚拟析构函数？

void testAssociativeArray() { 
AssociativeArray<String, int> table;
 table["abc"] = 15;
 table["jkl"] = 12;
 table["xyz"] = 85;
 assert(table["jkl"], 12);
 }

template<class P, class Q>
class Pair {
P p;
Q q; public:
      Pair(const P& _p = P(), const Q& _q = Q()): p(_p), q(_q) {}
      P& objectP() {return p;}
      Q& objectQ() {return q;}
};
4

3 回答 3

10

首先，你为什么认为析构函数应该是virtual？你在使用多态性吗？

其次，您对阵列的使用delete不正确。

由于您使用：

data = new T[length];

您必须使用数组语法：

delete [] data;

第三，您需要将命名空间放在所有类函数定义的前面：

template <class T>
Vector<T>::~Vector()
{
    delete [] data;
}

只是为了您的信息，您像这样声明析构函数......

virtual ~Vector(void);

正如我所提到的，virtual除非您以多态方式将此类用作基类或派生类，否则这是不必要的。有关何时需要使用virtual析构函数的更多信息，请查看此问题的答案。

此外，void参数中的 也是不必要的。这曾经在旧的 C 标准中是必需的，但在 C++ 中却没有。

您应该能够像这样声明它：

~Vector();

如果您AssociativeArray<P,Q>使用与 的has-a关系进行定义Vector<T>，那么您可以简单地使该类包含一个Vector<Pair<P,Q> >. virtual在这种情况下，不需要声明方法，但仍然可以使用——有一些额外的开销。

如果您AssociativeArray<P,Q>使用与 的is-a关系进行Vector<Pair<P,Q> >定义，那么您应该在 中定义一些virtual方法Vector<T>，包括virtual析构函数。

只有在通过指针和引用多态地使用对象时，virtual方法的使用才有意义。请参阅此页面。

AssociativeArray<String,Int>* myDerivedMap = new AssociativeArray<String,Int>();
delete myDerivedMap; //NO virtual methods necessary here. using a pointer to derived class

Vector<Pair<String,Int> >* myBaseMap = new AssociativeArray<String,Int>();
delete myBaseMap; //virtual methods ARE necessary here. using a pointer to base class
于 2012-10-26T12:06:05.280 回答
3 
template<class T> 
Vector<T>::~Vector()
{
    delete [] data;
}

请注意，您必须使用delete []而不是delete

于 2012-10-26T12:04:37.177 回答
1

应该

template <class T>
Vector<T>::~Vector() {
    delete[] data;
}
于 2012-10-26T12:05:55.067 回答