ОГРОМНАЯ утечка памяти при возврате std :: map & lt; std :: string, int & gt; от разыменованного итератора

**Быть осторожен**, не только эта программа зависает, но, видимо, она занимает все вашей памяти навсегда, делая ваш компьютер медленным и ужасным беспорядком. Я очень долго боролся с этим и выяснил многое, кроме того, почему он действительно зависает. Извините, что кода так много, но я вырезал все, что не имеет значения, и это то, что осталось.

LinkedList

//=====================
// Linked List

#include <stdexcept>

template<class T> struct LinkedList {
public:
LinkedList();
LinkedList(const LinkedList& srcList);
~LinkedList();

void addObject (T& addedObject);

class ListIterator {
public:
ListIterator();
explicit ListIterator(LinkedList<T>& parentList);

// Operators
ListIterator& operator++();
T& operator*() const;
bool operator!=(const ListIterator& otherIter);

private:
typename LinkedList::Node* current_;
};

ListIterator begin();
ListIterator end();
std::size_t size_;

private:
struct Node {
Node();
Node(T& object);
Node(const Node&) = delete;
T* const object_;
Node* next_;
Node* prev_;
};

Node head_;
Node tail_;
};

//====================
// Classes (Implementation)

// Linked List default constructor
template<class T> LinkedList<T>::LinkedList()
: size_{0} {
head_.next_ = &tail_;
tail_.prev_ = &head_;
};

// Linked List copy constructor
template<class T> LinkedList<T>::
LinkedList(const LinkedList& srcList) {
size_ = srcList.size_;
head_.next_ = &tail_;
tail_.prev_ = &head_;
ListIterator nodesToCopy = srcList.begin();

while (nodesToCopy != srcList.end()) {
this->addObject(*nodesToCopy);
srcList.removeObject(1);
};
delete &srcList;
};

// Linked List destructor
template<class T> LinkedList<T>::~LinkedList() {
for (unsigned int ii = 1; ii == size_; ++ii) {
Node* toDelete = head_.next_;
head_.next_ = head_.next_->next_;
delete toDelete;
};
};

// Add object to Linked List
template<class T> void LinkedList<T>::addObject(T& addedObject) {
Node* node = new Node(addedObject);
node->prev_ = tail_.prev_;
tail_.prev_->next_ = node;
tail_.prev_ = node;
node->next_ = &tail_;
++size_;
};

// Linked List Iterator constructor
template<class T> LinkedList<T>::ListIterator::
ListIterator(LinkedList<T>& parentList) {
current_ = parentList.head_.next_;
};

// Iterator operators
// Increment forward
template<class T> typename LinkedList<T>::ListIterator& LinkedList<T>::
ListIterator::operator++() {
current_ = current_->next_;
return *this;
};

// Return object pointed to
template<class T> T& LinkedList<T>::ListIterator::
operator*() const {
return *(current_->object_);
};

template<class T> bool LinkedList<T>::ListIterator::
operator!=(const ListIterator& otherIter) {
return &(**this) != &(*otherIter);
};

// Return an iterator object via begin() and end()
template<class T> typename LinkedList<T>::ListIterator
LinkedList<T>::begin() {
ListIterator beginIterator(*this);
return beginIterator;
};
template<class T> typename LinkedList<T>::ListIterator
LinkedList<T>::end() {
ListIterator endIterator(*this);
for (unsigned int ii = 0; ii < size_; ++ii) { ++endIterator; };
return endIterator;
};

// Node constructors
template<class T> LinkedList<T>::Node::Node()
: object_(nullptr), next_(nullptr), prev_(nullptr) {};

template<class T> LinkedList<T>::Node::Node(T& object)
: object_(&object) {};

Вещь

//=====================
// Item
//====================
// Included dependencies
#include <string>
#include <array>
#include <map>
#include <iostream>

class Item {
public:
Item();
Item(std::string name);
Item(std::string name, std::array<int, 2> stats);
std::map<std::string, int> getStats();

std::string name_;

private:
std::map<std::string, int> enhancements_;
};

// Constructors
Item::Item() {
enhancements_["Str"] = 0;
enhancements_["Def"] = 0;
};

Item::Item(std::string name) : Item::Item() { name_ = name; };
Item::Item(std::string name, std::array<int, 2> stats)
: Item::Item(name) {
enhancements_["Str"] = stats[0];
enhancements_["Def"] = stats[1];
};

// Return map of stats
std::map<std::string, int> Item::getStats() { return enhancements_; };

Номер

//====================
// Room
class Room {
public:
void addItem(Item item);
LinkedList<Item>::ListIterator getItems();
LinkedList<Item> itemsInThisRoom_;
};

// Add item to room
void Room::addItem(Item item) { itemsInThisRoom_.addObject(item); };

// Get iterator which iterates over items in room
LinkedList<Item>::ListIterator Room::getItems() {
return itemsInThisRoom_.begin();
};

главный

int main() {
std::array<int, 2> swordStats = {{5, 0}};
std::array<int, 2> shieldStats = {{0, 2}};
std::array<int, 2> armorStats = {{0, 3}};

Item sword("Sword", swordStats);
Item shield("Shield", shieldStats);
Item armor("Armor", armorStats);
Room room;

room.addItem(shield);
room.addItem(sword);
room.addItem(armor);
LinkedList<Item>::ListIterator roomItems = room.itemsInThisRoom_.begin();

while (roomItems != room.itemsInThisRoom_.end()) {
(*roomItems).getStats();
++roomItems;
};

return 0;
};

Все это можно поместить в один файл и скомпилировать (я разделил его по классам, чтобы было легче читать). Это линия, в главный, где висит:

(*roomItems).getStats();

Это приводит меня к мысли, что с моим оператором разыменования что-то не так, верно? Если мы создадим итератор вне класса Room, разыменуйте его, и getStats точно так же — все работает нормально.

… так это проблема с классом комнаты?

Но если мы изменим Вещь а также главный к следующему:

//=====================
// Item
//====================
// Included dependencies
#include <string>
#include <array>
#include <map>
#include <iostream>

class Item {
public:
Item();
Item(std::string name);
Item(std::string, int);
int getStats();

std::string name_;

private:
int enhancements_;
};

// Constructors
Item::Item() {
enhancements_ = 0;
};

Item::Item(std::string name) : Item::Item() { name_ = name; };
Item::Item(std::string name, int stats)
: Item::Item(name) {
enhancements_ = stats;
};

// Return map of stats
int Item::getStats() { return enhancements_; };

//====================
// Room
class Room {
public:
void addItem(Item item);
LinkedList<Item>::ListIterator getItems();
LinkedList<Item> itemsInThisRoom_;
};

// Add item to room
void Room::addItem(Item item) { itemsInThisRoom_.addObject(item); };

// Get iterator which iterates over items in room
LinkedList<Item>::ListIterator Room::getItems() {
return itemsInThisRoom_.begin();
};

int main() {
Item sword("Sword", 1);
Item shield("Shield", 2);
Item armor("Armor", 3);
Room room;

room.addItem(shield);
room.addItem(sword);
room.addItem(armor);
LinkedList<Item>::ListIterator roomItems = room.itemsInThisRoom_.begin();
while (roomItems != room.itemsInThisRoom_.end()) {
(*roomItems).getStats();
++roomItems;
};

return 0;
};

Все отлично работает. Я могу вернуться ИНТ ценности в порядке.

… так что … это не проблема ни с классом Room, ни с оператором разыменования, но возврате станд :: карта? ГБД сказать особо нечего. Когда я ломаюсь на оскорбительной строке и шаге, я получаю:

24  std::map<std::string, int> Item::getStats() { return enhancements_; };
(gdb) step
_Rb_tree_impl (__a=<optimized out>, __comp=..., this=0x7fffffffced0)
at /usr/include/c++/4.9/bits/stl_tree.h:474
474         _M_header(), _M_node_count(0)
(gdb) step
475       { _M_initialize(); }
(gdb) step
_M_initialize (this=0x7fffffffced0)
at /usr/include/c++/4.9/bits/stl_tree.h:484
484         this->_M_header._M_left = &this->_M_header;
(gdb) step
485         this->_M_header._M_right = &this->_M_header;
(gdb) step
_Rb_tree (__x=..., this=0x7fffffffced0)
at /usr/include/c++/4.9/bits/stl_tree.h:674
674     if (__x._M_root() != 0)
(gdb) step
_M_root (this=0x7fffffffd048)
at /usr/include/c++/4.9/bits/stl_tree.h:498
498       { return this->_M_impl._M_header._M_parent; }
(gdb) step
_Rb_tree (__x=..., this=0x7fffffffced0)
at /usr/include/c++/4.9/bits/stl_tree.h:674
674     if (__x._M_root() != 0)
(gdb) step
676         _M_root() = _M_copy(__x._M_begin(), _M_end());
(gdb) step
std::_Rb_tree<std::string, std::pair<std::string const, int>, std::_Select1st<std::pair<std::string const, int> >, std::less<std::string>, std::allocator<std::pair<std::string const, int> > >::_M_copy (
this=this@entry=0x7fffffffced0, __x=0x619f10,
__p=__p@entry=0x7fffffffced8)
at /usr/include/c++/4.9/bits/stl_tree.h:1207
1207          _Link_type __top = _M_clone_node(__x);

… что бред для меня. 🙁 Это делает это бесконечно, поэтому я знаю, что это (как-то) описывает зависание.

у меня есть нет Понять, что здесь происходит, ха-ха. Я очень плохо знаком с C ++ и с этим боролся с тех пор, как проснулся, поэтому, насколько я знаю, мой код ужасен, и мне должно быть плохо от написания его.

Есть идеи?