Почему копирующему конструктору не удается «скопировать» - PullRequest
Новая
       21

Почему копирующему конструктору не удается «скопировать»

0 голосов
/ 20 мая 2018

Я пытаюсь лучше понять конструкторы копирования.

Когда я создаю новый экземпляр закрытых значений в конструкторе копирования, он должен отличаться от исходного значения.

Однако,это не вариант.Я не присваиваю значения через ссылку и не присваиваю указатель, но когда я смотрю на отладчик, области памяти остаются неизменными.

Что делает «новое», если результирующее действие остаетсято же самое? 

// copy control within a template
NTree(const NTree& aOtherNTree)
{
    fKey = new T;
    fNodes[N] = new NTree<T, N>;

    fKey = aOtherNTree.fKey;
    for (int i = 0; i < N; i++)
    {
        fNodes[i] = aOtherNTree.fNodes[i];
    }

Полный код 

#pragma once

#include <stdexcept>

#include "TreeVisitor.h"
#include "DynamicQueue.h"

template <class T, int N>
class NTree {
private:
    const T* fKey; // 0 for empty NTree
    NTree<T, N>* fNodes[N]; // N subtress of degree N

    NTree(); // sentinel constructor

public:
    static NTree<T, N> NIL; // sentinel

    NTree(const T& aKey); // a simple NTree with key and N subtrees of degree N

    bool isEmpty() const; // is tree empty
    const T& key() const; // get key (node value)

    // indexer (allow for result modification by client - no const in result)
    NTree& operator[](unsigned int aIndex) const;

    // tree manipulators (using constant references)
    void attachNTree(unsigned int aIndex, const NTree<T, N>& aNTree);
    const NTree& detachNTree(unsigned int aIndex);

    // depth-first traversal
    void traverseDepthFirst(const TreeVisitor<T>& aVisitor) const;

    // copy control
    NTree(const NTree& aOtherNTree)
    {
        fKey = new string;
        fNodes[N] = new NTree<string, N>;

        fKey = aOtherNTree.fKey;
        for (int i = 0; i < N; i++) {
            fNodes[i] = aOtherNTree.fNodes[i];
        }
    }

    ~NTree()
    {
        for (int i = 0; i < N; i++) {
            if (!isEmpty()) {
                if (!fNodes[i]->isEmpty()) {
                    delete fNodes[i];
                }
            }
        }
    }

    NTree& operator=(const NTree& aOtherNTree)
    {
        fKey = new T;
        fNodes[N] = new NTree<T, N>;

        fKey = aOtherNTree.fKey;
        for (int i = 0; i < N; i++) {
            fNodes[i] = aOtherNTree.fNodes[i];
        }

        return *this;
    }

    // breadth-first traversal
    void traverseBreadthFirst(const TreeVisitor<T>& aVisitor) const
    {
        DynamicQueue<const NTree<T, N>*> lQueue;
        lQueue.enqueue(this);

        while (!lQueue.isEmpty()) {
            const NTree<T, N>& head = *lQueue.top();
            lQueue.dequeue();

            aVisitor.visit(head.key());

            for (int i = 0; i < N; i++) {
                if (head.fNodes[i]->fKey != NULL) {
                    lQueue.enqueue(&head[i]);
                }
            }
        }
    }
};

// implementation

template <class T, int N>
NTree<T, N> NTree<T, N>::NIL;

// sentinel constructor
template <class T, int N>
NTree<T, N>::NTree()
{
    fKey = (T*)0;
    for (int i = 0; i < N; i++)
        fNodes[i] = &NIL;
}

// node constructor
template <class T, int N>
NTree<T, N>::NTree(const T& aKey)
{
    fKey = &aKey;
    for (int i = 0; i < N; i++)
        fNodes[i] = &NIL;
}

// isEmpty
template <class T, int N>
bool NTree<T, N>::isEmpty() const
{
    return this == &NIL;
}

// key
template <class T, int N>
const T& NTree<T, N>::key() const
{
    if (!isEmpty())
        return *fKey;
    else
        throw std::domain_error("Empty NTree.");
}

// indexer
template <class T, int N>
NTree<T, N>& NTree<T, N>::operator[](unsigned int aIndex) const
{
    if (isEmpty())
        throw std::domain_error("Empty NTree!");

    if (aIndex < N && fNodes[aIndex] != &NIL) {
        return *fNodes[aIndex]; // return reference to subtree
    }
    else
        throw std::out_of_range("Illegal subtree index!");
}

// tree manipulators
template <class T, int N>
void NTree<T, N>::attachNTree(unsigned int aIndex, const NTree<T, N>& aNTree)
{
    if (isEmpty())
        throw std::domain_error("Empty NTree!");

    if (aIndex < N) {
        if (fNodes[aIndex] != &NIL)
            throw std::domain_error("Non-empty subtree present!");

        fNodes[aIndex] = (NTree<T, N>*)&aNTree;
    }
    else
        throw std::out_of_range("Illegal subtree index!");
}

template <class T, int N>
const NTree<T, N>& NTree<T, N>::detachNTree(unsigned int aIndex)
{
    if (isEmpty())
        throw std::domain_error("Empty NTree!");

    if ((aIndex < N) && fNodes[aIndex] != &NIL) {
        const NTree<T, N>& Result = *fNodes[aIndex]; // obtain reference to subtree
        fNodes[aIndex] = &NIL; // set to NIL
        return Result; // return subtree (reference)
    }
    else
        throw std::out_of_range("Illegal subtree index!");
}

template <class T, int N>
void NTree<T, N>::traverseDepthFirst(const TreeVisitor<T>& aVisitor) const
{
    // visit every subtree (no invisit)
    if (!isEmpty()) {
        aVisitor.preVisit(key());
        for (unsigned int i = 0; i < N; i++) {
            fNodes[i]->traverseDepthFirst(aVisitor);
        }
        aVisitor.postVisit(key());
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "NTree.h"

1 Ответ

0 голосов
/ 20 мая 2018

Не уверен, к каким адресам памяти вы обращаетесь, но вопреки вашему утверждению "и я не назначаю указатель" , ваш код фактически назначает указатель.Многие из них, на самом деле.Это почти все, что он делает, это назначать указатели.Сначала здесь: 

fKey = new T;

Это назначение указателя.Так что это: 

fNodes[N] = new NTree<T, N>;

Это также случается присваивание элементу вне границ массива.То есть fNodes является массивом N указателей, fNodes[N-1] является последним элементом (указателем) в этом массиве, а fNodes[N] выходит за пределы.

Это также присвоение указателя: 

fKey = aOtherNTree.fKey;

Это также утечка памяти, так как вы теперь записали значение, которое было возвращено из вызова new T ранее в функции.И поэтому у вас нет доступа и нет возможности освободить этот объект.

И, наконец, ваш цикл for состоит из назначений указателей N. 

for (int i = 0; i < N; i++)
{
    fNodes[i] = aOtherNTree.fNodes[i];
}

Вы просто копируете указатели из *От 1024 * до fNodes.

...