link list node passed as parameter,argument pointer to pointer notation

[glennpl]

I was having problems changing the value of my head node I passed it as an argument as head which would be the address. The parameter was defined as struct node *head. like this

bool deleteNode(struct node *head, struct node *delptr)

I tried manipultaing pointer values to change head node value but it did not work. I saw some code online which used pointer to pointers(in code below) to change head node value it worked I dont fully understand why. Would like better understanding of why. Would also like to know why the argument call needed &head instead of just head. remove = deleteNode(&head,found); opposed to
remove = deleteNode(head,found);

#include "stdafx.h"
#include<iostream>

struct node{
		int  data;
		node *next;
	};

void initNode(struct node *head,int nodeData)
{
		head->data = nodeData;
		head->next = NULL;
}

void addNode(struct node *head,int newdata)
	{
		using namespace std;
		node *current = head; 
		
	while(current->next !=NULL)
	 {
        
		 current = current->next;
     }
      if (current->next == NULL)
		 {
          node *newNode = new node;
		  current->next = newNode;
		  newNode->data = newdata;
		  newNode->next = NULL;
		 } 
	}

void insertFront(struct node **head,int frontData)
	{
		node *frontNode = new node;
		frontNode->next = *head;
		frontNode->data = frontData;
		*head = frontNode;

	}

  node *searchNode(struct node *head,int key)
	{
		node *cur = head;
		node *nodeFound = cur;
		using namespace std;
		while(cur)
		{
			if (cur->data == key)
				{
				nodeFound = cur;
		        return nodeFound;
			    }
			cur = cur->next;
		}	
		   
		return nodeFound;
	}

bool deleteNode(struct node **head, struct node *delptr)
	{
		node *cur = *head;
		node *tempNextptr= cur;
		using namespace std;

		 while(cur)
		{
			if (cur == delptr)
			{
		        tempNextptr->next = delptr->next;
				if(cur == *head)
					*head = cur->next;
				
				delete cur;
				return true;
			}
	
			    tempNextptr = cur;
			    cur = cur->next;
		}

          return false;
	}

void reverse(struct node **head )
	{
       node *cur = *head;
	   node *nxtptr = *head;
	   node *tempcur = *head;
	   
	   while(cur)
	   {
		   if(cur->next == NULL)
              *head = cur;
		   else
		   {
			 nxtptr = cur->next;
			 cur->next = tempcur;
		   }

         tempcur = cur;
         cur = nxtptr->next;
	   }

	}



struct node	*copyLinkedlist(struct node *head)
	{
		using namespace std;
		node *cur = head;
		node *newHead;
		
		while(cur)
		{
		   cout<<"cur= "<<cur<<endl;
           node *newNode = new node;
		   if(cur == head)
			  newHead = newNode;

		   newNode->data = cur->data;
           newNode->next = cur->next;
		   cur = cur->next;
		}
		return newHead;
	}

/*	comparelinklist()
	{

	}
*/
void deletelinklist(struct node *head)
	{
		node *cur = head;
		node *tmptr; 
		while (cur)
		 {
			 if (cur->next == NULL)
				 delete cur;
			 else
			 {
			   tmptr = cur->next;
			   delete cur;
			 }
			 cur = tmptr;
		 }
	}


void display(struct node *head)
	{
		using namespace std;
		node *cur = head;
		while(cur)
		{
          cout<<"data = "<< cur->data<< endl;
		  cur = cur->next;
		}
	} 


int main()
{
	using namespace std;

    node *head = new node;
	node *newList;
    struct node *found;
	bool remove;

	initNode(head,10);
	display(head);
    addNode(head,20);
	display(head);
	addNode(head,30);
	display(head);
	found = searchNode(head,30);
	cout<<"search node = "<< found->data<< endl;
	remove = deleteNode(&head,found);
	//cout<<"head= "<<head<<endl;
    display(head);
	addNode(head,40);
	addNode(head,50);
	display(head);
	//reverse(&head);
	newList = copyLinkedlist(head);
	cout<<"newlist"<<endl;
	display(newList);
	insertFront(&head,60);
    
	display(head);

	if(remove)
	  cout<<"true"<<endl;
	else
	  cout<<"false"<<endl;


	cin.clear();
	cin.ignore(255,'/n');
	cin.get();

	return 0;
}

[Smac89]

Remember that pointers are types in c/c++. So if the delete node function had been declared as:

bool deleteNode(struct node *head, struct node *delptr)

The head node will be passed by value (which makes a copy of the struct) and will not affect the head node in main.

when you do it this way:
bool deleteNode(struct node **head, struct node *delptr)

You ensure that the actual object is passed to the function not a copy of it.
With that being said, you should change the syntax of other functions which modify the struct to accept a pointer to pointer node object