Question

我有一个名为DiGraph的类，它包含一个Node节点数组：

DiGraph::DiGraph(int Size) : count(0){
    nodes = new Node *[Size];
}

现在我想定义函数getNodes（），它本质上应该以列表形式返回数组：

Liste<Node*> DiGraph::getNodes() {
    Liste<Node*> nlist(count+1);
    for (int i = 0; i < count; i++) {
        nlist.append(nodes[i]);
    }
    return nlist;
}

在函数结束时，nlist被正确填充，但不知何故，函数调用的结果副本不包含正确的指针，而是包含所有其他变量。

DiGraph a(6);
a.addNode(new Node("A", 50, 50));
Liste<Node*> gN = a.getNodes(); //gN does not contain the same pointers that were returned

“Liste”类基本上是一个带有模板和一些奇特函数的动态数组。

现在我认为答案可能是nlist在函数结束后被销毁但是指针在nodes变量中仍然有效，那么为什么副本包含无效的？

修改

这是列表类：

#ifndef _LISTE_H
#define _LISTE_H

// -------------------------------------------------------------------
template <typename T>
class Liste {
private:
    T *_values;
    int _last;
    int _size;

    bool isFull();
    int find(T value);
    void increase();
    void decrease();

public:
    Liste(int size = 8);
    Liste(Liste &list);
    ~Liste();
    void append(T value);
    void remove(T value);
    T getValueAt(int pos);
    int size();

    T operator[](int pos);
};

// -------------------------------------------------------------------
template <typename T>
Liste<T>::Liste(int size) {
    _size = size;
    _last = 0;
    _values = new T[size];
}

template <typename T>
Liste<T>::Liste(Liste &list) {
    _size = list._size;
    _last = list._last;
    _values = list._values;
}


// -------------------------------------------------------------------
template <typename T>
Liste<T>::~Liste() {
    delete[] _values;
}

// -------------------------------------------------------------------
template <typename T>
void Liste<T>::increase() {
    T *tmp = new T[_size * 2];

    for (int i = 0; i < _size; i++)
        tmp[i] = _values[i];

    delete[] _values;
    _values = tmp;
    _size *= 2;
}

// -------------------------------------------------------------------
template <typename T>
void Liste<T>::decrease() {
    _size /= 2;
    T *tmp = new T[_size];

    for (int i = 0; i < _size; i++)
        tmp[i] = _values[i];

    delete[] _values;
    _values = tmp;
}

// -------------------------------------------------------------------
template <typename T>
bool Liste<T>::isFull() {
    return _last == _size;
}

// -------------------------------------------------------------------
template <typename T>
int Liste<T>::find(T val) {
    int pos;

    for (pos = 0; pos < _last; pos++)
        if (_values[pos] == val)
            return pos;
    return -1;
}

// -------------------------------------------------------------------
template <typename T>
T Liste<T>::getValueAt(int pos) {
    if (pos < 0 || pos >= _last)
        throw "OutOfBoundsException";

    return _values[pos];
}

// -------------------------------------------------------------------
template <typename T>
void Liste<T>::append(T val) {
    if (isFull())
        increase();

    _values[_last] = val;
    _last += 1;
}

// -------------------------------------------------------------------
template <typename T>
void Liste<T>::remove(T val) {
    int pos = find(val);

    if (pos == -1)
        throw "ValueNotFoundException";

    for (; pos < _last - 1; pos++)
        _values[pos] = _values[pos + 1];
    _last -= 1;

    if (_last < _size / 4)
        decrease();
}

// -------------------------------------------------------------------
template <typename T>
int Liste<T>::size() {
    return _last;
}

// -------------------------------------------------------------------
template <typename T>
T Liste<T>::operator[](int pos) {
    return getValueAt(pos);
}

#endif

Answer 1

dict["videoID"]

此代码的作用是使新的Liste对象（从复制构造函数构造）指向现有Liste对象的内存地址。但是这个对象会被破坏，所以你会得到一个悬垂的指针。您需要执行值的硬拷贝。

template <typename T>
Liste<T>::Liste(Liste &list) {
    _size = list._size;
    _last = list._last;
    _values = list._values;
}

将指针成员包装到智能指针（例如template <typename T> Liste<T>::Liste(const Liste &list) { // <--- const _size = list._size; _last = list._last; _values = new T[_size]; for( std::size_t iter = 0 ; iter < _size ; ++iter ) { _values[iter] = list._values[iter]; } }）是一种很好的现代做法。通过这种方式，您永远不会忘记删除所有内容，即使在构造函数不完整的情况下也会保证对象保持被清除（抛出异常）。

如果您计划按值返回，则应研究如何使您的Liste类感知移动

您的unique_ptr<>也可以通过引用返回一个包含项，以允许立即修改对象（T operator[](int pos);）原因，因为它返回一个位于{{1的对象的副本并且很可能不是你想要的。同样适用于您的T& operator[](int pos);公开方法。

列表类填充返回

1 个答案: