Tower of Hanoi - Why are my functions not updating the pointers correctly?

First, I defined most of my functions recursively to practice recursion.

When I looked at the debugger, I noticed several things:

1. My functions swap() is NOT updating the pointer variables in the tower_of_hanoi() function
2. My functions push() and pop() are not handling the exceptions.
3. Since my swap() function is not updating my pointers, the base case is never reached.

I tried to catch several exceptions, but I notice that it still did not help. I was expecting each of the swap() calls to update the pointers, but it is not properly updating the pointer variables. So the height of my 3rd tower is ALWAYS a height of 0, and the problem is never solved.

Here is the code:

#include <iostream>
#include <string>

using namespace std;

struct disk {
	int value;
	disk* top;
};

// Initializing Structures
disk* tower_1 = NULL;
disk* tower_2 = NULL;
disk* tower_3 = NULL;
disk* tower_1_top = NULL;
disk* tower_2_top = NULL;
disk* tower_3_top = NULL;

// Function 
disk* push(disk* tower, int value); // push (disk* tower to push into, int value we want the disk to have)
void push_helper(disk* current_disk, disk* new_disk); 
disk* pop(disk* tower); // pop(disk* tower to pop off top disk)
disk* top_disk(disk* tower);
int tower_height(disk* tower);
int tower_height_recursive(disk* tower);
void display_tower(disk* tower);
void display_tower_recursive(disk* tower);
void swap_disk(disk* swap_tower_a, disk* swap_tower_b);
void tower_of_hanoi_solver(disk* tower1, disk* tower2, disk* tower3, int max_height);

int main()
{
	char user_continue = 'y';

	tower_1 = push(tower_1, 4);
	tower_1 = push(tower_1, 2);
	tower_1 = push(tower_1, 1);
	tower_1_top = top_disk(tower_1);

	cout << "Tower 1: \n";
	display_tower_recursive(tower_1);
	cout << endl << endl;
	cout << "Tower 1 Height: " << tower_height_recursive(tower_1) << endl;
	cout << "Top of Tower 1: " << tower_1_top->value << endl << endl;


	cout << "Tower 2: \n";
	display_tower_recursive(tower_2);
	cout << endl << endl;
	cout << "Tower Height: " << tower_height_recursive(tower_2) << endl << endl;

	cout << "Tower 3: \n";
	display_tower_recursive(tower_3);
	cout << endl << endl;
	cout << "Tower Height: " << tower_height_recursive(tower_3) << endl << endl;



	// Call to do the Tower of Hanoi game
	int max_height_tower = tower_height_recursive(tower_1);
	tower_of_hanoi_solver(tower_1, tower_2, tower_3,max_height_tower);

	//Final Towers After Game
	cout << "Final Towers: \n\n";

	cout << "Tower 1: \n";
	display_tower_recursive(tower_1);
	cout << endl << endl;
	cout << "Tower Height: " << tower_height_recursive(tower_1) << endl << endl;

	cout << "Tower 2: \n";
	display_tower_recursive(tower_2);
	cout << endl << endl;
	cout << "Tower Height: " << tower_height_recursive(tower_2) << endl << endl;

	cout << "Tower 3: \n";
	display_tower_recursive(tower_3);
	cout << endl << endl;
	cout << "Tower Height: " << tower_height_recursive(tower_3) << endl << endl;


	cin.ignore();
	cin.get();
}

disk* push(disk* tower, int value)
{
	disk* p_new_disk = new disk;
	p_new_disk->value = value;
	p_new_disk->top = NULL;

	if (p_new_disk == NULL)
	{
		return NULL;
	}
	else if (tower == NULL)
	{
		tower = p_new_disk;
		return tower;
	}
	else 
	{
		if (tower->top == NULL)
		{
			tower->top = p_new_disk;
			return tower;
		}
		else if (tower->top->top == NULL)
		{
			tower->top->top = p_new_disk;
		}
		else
		{
			push(tower->top->top, value);
		}
		//push_helper(tower, p_new_disk);
	}
	

	return tower;
}

void push_helper(disk* current_disk, disk* new_disk)
{
	if (current_disk -> top == NULL)
	{
		current_disk->top = new_disk;
	}
	else
	{
		push_helper(current_disk->top, new_disk);
	}
}

disk* pop(disk* tower)
{
	if (tower == NULL)
	{
		return NULL;
	}

	if (tower->top == NULL) 
	{
		return NULL;
	}
	else 
	{
		if (tower->top != NULL && tower->top->top == NULL)
		{
			disk* p_temp = tower->top;
			tower->top = NULL;
			delete p_temp;
			return tower;
		}
		else
		{
			return pop(tower->top);
		}
	}

}

disk* top_disk(disk* tower)
{

	if (tower == NULL)
	{
		return NULL;
	}
	else if (tower->top == NULL)
	{
		return tower;
	}
	else
	{
		return top_disk(tower->top);
	}
}

int tower_height(disk* tower)
{
	disk* current_disk = tower;
	int count = 0;

	while (current_disk != NULL)
	{
		count++;
		current_disk = current_disk->top;
	}

	return count;
}

int tower_height_recursive(disk* tower)
{
	disk* current_disk = tower;

	if (current_disk == NULL) // Handles if the(current_disk has NO disks.
	{
		return 0;
	}
	else
	{
		return 1 + tower_height_recursive(current_disk->top);
	}
}

void display_tower(disk* tower)
{
	disk* current_disk = tower;
	while (current_disk != NULL)
	{
		cout << current_disk->value << endl;
		current_disk = current_disk->top;
	}
}

void display_tower_recursive(disk* tower)
{
	if (tower == NULL)
	{
		cout << "None!\n";
	}
	else
	{
		cout << tower->value << endl;
		display_tower_recursive(tower->top);
	}

}

void swap_disk(disk* swap_tower_a, disk* swap_tower_b)
{
	disk* top_tower_a = top_disk(swap_tower_a);
	disk* top_tower_b = top_disk(swap_tower_b);

	if (swap_tower_a == NULL && swap_tower_b == NULL) 
	{
		return;
	}
	else if (swap_tower_a != NULL && swap_tower_b == NULL)
	{
		swap_tower_b = push(swap_tower_b, top_tower_a->value);
		swap_tower_a = pop(swap_tower_a);
	}
	else
	{
		if (top_tower_a != NULL && top_tower_b != NULL) {
			if (top_tower_a->value < top_tower_b->value)
			{
				swap_tower_b = push(swap_tower_b, top_tower_a->value);
				swap_tower_a = pop(swap_tower_a);
			}
			else
			{
				return;
			}
		}
	}
	
}

void tower_of_hanoi_solver(disk* tower1, disk* tower2, disk* tower3, int max_height)
{
	int tower_1_height = tower_height_recursive(tower1);

	// Tower 1
	if (tower_1_height % 2 == 0)
	{
		swap_disk(tower1, tower2);
	}
	else
	{
		swap_disk(tower1, tower3);
	}

	// Tower 2
	swap_disk(tower2, tower3);
	swap_disk(tower2, tower1);

	// Tower 3
	swap_disk(tower3, tower2);
	swap_disk(tower3, tower1);

	int tower_3_height = tower_height_recursive(tower3);

	if (tower_3_height == max_height)
	{
		return;
	}
	else
	{
		tower_of_hanoi_solver(tower1, tower2, tower3,  max_height);
	}


}

I first defined my pointers to be global for the towers - tower_1, tower_2, and tower_3 - so my entire program can manipulate and change the value. I did not put the word 'const' in front of them.

I wanted the tower_of_hanoi_solver() function to use the swap() function, but my debugger says my pointers are not being updated. Here's the code for the swap() and tower_of_hanoi_solver() functions

void swap_disk(disk* swap_tower_a, disk* swap_tower_b)
{
	disk* top_tower_a = top_disk(swap_tower_a);
	disk* top_tower_b = top_disk(swap_tower_b);

	if (swap_tower_a == NULL && swap_tower_b == NULL) 
	{
		return;
	}
	else if (swap_tower_a != NULL && swap_tower_b == NULL)
	{
		swap_tower_b = push(swap_tower_b, top_tower_a->value);
		swap_tower_a = pop(swap_tower_a);
	}
	else
	{
		if (top_tower_a != NULL && top_tower_b != NULL) {
			if (top_tower_a->value < top_tower_b->value)
			{
				swap_tower_b = push(swap_tower_b, top_tower_a->value);
				swap_tower_a = pop(swap_tower_a);
			}
			else
			{
				return;
			}
		}
	}
	
}

void tower_of_hanoi_solver(disk* tower1, disk* tower2, disk* tower3, int max_height)
{
	int tower_1_height = tower_height_recursive(tower1);

	// Tower 1
	if (tower_1_height % 2 == 0)
	{
		swap_disk(tower1, tower2);
	}
	else
	{
		swap_disk(tower1, tower3);
	}

	// Tower 2
	swap_disk(tower2, tower3);
	swap_disk(tower2, tower1);

	// Tower 3
	swap_disk(tower3, tower2);
	swap_disk(tower3, tower1);

	int tower_3_height = tower_height_recursive(tower3);

	if (tower_3_height == max_height)
	{
		return;
	}
	else
	{
		tower_of_hanoi_solver(tower1, tower2, tower3,  max_height);
	}


}

Why is the swap() function not updating the pointers in the tower_of_hanoi_solver() function - and hence the original pointers as well?

There is too much code there for me to give you a fix, but generally I think the problem is that you are misunderstanding what happens when you pass a pointer to a function as an argument.

In a call likevoid swap_disk(disk* swap_tower_a, disk* swap_tower_b) the pointers swap_tower_a and swap_tower_b are being passed by value, this means inside of swap_disk you have access to copies of the pointer values you passed in, not those variables themselves. So for example the following is not doing what you think it is doing:

// ...
else if (swap_tower_a != NULL && swap_tower_b == NULL)
{
	swap_tower_b = push(swap_tower_b, top_tower_a->value);
	// ...
}

Say swap_tower_a is not null and swap_tower_b is null, then push is going to return a newly allocated disk and that is being assigned to swap_tower_b but swap_tower_b is just a copy of the pointer variable passed into swap_disk. Assigning a new value to a local copy of it will not affect the variable used by the calling code. To do that you would need swap_disk to either take pointers to pointers to disks or references to pointers to disks -- which is up to you, typically in C++ you use references, but you are writing very C-looking code so might prefer disk**.