Heap Corruption!?

[davermont]

I have a small program that compiles and runs, but after execution, Visual Studio is giving me the following error message:

Windows has triggered a breakpoint in LAN.exe. This may be due to a corruption of the heap, which indicates a bug in LAN.exe or any of the DLLs it has loaded.

I noticed that if I comment out the second to last line in Network::add then I don't get the error, which suggests that I am assigning the Node to the Node* incorrectly. However, it compiles and outputs correctly to the console. As you can see from Main.cpp, only the Network constructor, Network::add, and the Node constructor are actually called. I would very much appreciate it if anyone can see what the problem is. :D

// Main.cpp
#include <iostream>
#include <cstdlib>
#include "Network.h"

using namespace std;

int main() {
	Network network;
	Node node;
	network.add(node);
	cout << "network.size(): " << network.size() << endl;
	network.add(node);
	cout << "network.size(): " << network.size() << endl;
	Node node2;
	network.add(node2);
	cout << "network.size(): " << network.size() << endl;

	system("pause");
	return EXIT_SUCCESS;
}

// Network.h
#ifndef NETWORK_H
#define NETWORK_H

#include "Node.h"

class Network {
public:
	Network(const unsigned = 10);
	bool add(Node&);
	const unsigned size() const;
	~Network();

private:
	void realloc();

	Node** nodes;
	unsigned node_count;
	unsigned capacity;
};
#endif

// Network.cpp
#include "Network.h"

Network::Network(const unsigned init_capacity)
: node_count(0), capacity(init_capacity) {
	nodes = new Node*[capacity];
	for (unsigned i = 0; i < capacity; i++) {
		nodes[i] = 0;
	}
}

Network::~Network() {
	for (unsigned i = 0; i < node_count; i++){
		delete nodes[i];
	}
	delete [] nodes;
}

bool Network::add(Node& node) {
	for (unsigned i = 0; i < node_count; i++) {
		if (nodes[i] == &node) {
			return false;
		}
	}
	if (node_count == capacity) {
		realloc();
	}
	nodes[node_count++] = &node;
	return true;
}

void Network::realloc() {
	Node** new_nodes = new Node*[capacity *= 2];
	unsigned i = 0;
	for (; i < node_count; i++) {
		new_nodes[i] = nodes[i];
	}
	for (; i < capacity; i++) {
		new_nodes[i] = 0;
	}
	delete [] nodes;
	nodes = new_nodes;
}

const unsigned Network::size() const {
	return node_count;
}

// Node.h
#ifndef NODE_H
#define NODE_H

class Node {
public:
	Node();
	~Node();

private:
	Node* nodes;
	const unsigned id;
	static unsigned id_count;
};

#endif

// Node.cpp
#include "Node.h"

unsigned Node::id_count = 0;

Node::Node()
: id(id_count++), nodes(0) {
}

Node::~Node() {
}

[kbw]

Network assumes the Nodes come from the heap, but you're passing one off the stack.

[jrohde]

In the Network() destructor, you're trying to delete a stack variable - since you didn't allocate it with new, delete won't work on that address. That's why it says there's a corruption of the heap - it's not on the heap to start with.

[davermont]

Well, that explains it. Originally it was allocated from the heap and I changed it. I guess I forgot about the destructor. Thanks.