Double Linked List based in C++

Below is the double linked list example that based on console.

Specially this application use macro by define function provided by ANSI C.
It's just like inline function that C++ provides.

#include <stdio.h>
#include <stdlib.h>
/* Constants */
#define EXIT_OK
/* Macros */
#define CHOICE(answer)
printf("Choice: ");
scanf("%i", &answer);
struct nodo
{
	int 	nclient; 	/* primary key of the "record" */
	char    name[40];       /* name */
	float	total;          /* how much this client owes us */
	struct	nodo * next;    /* pointer to the next struct */
	struct	nodo * prev;	/* pointer to the previous struct */
};
/* Functions */
void AddClient 		(struct nodo ** list);
void Exit       	(struct nodo ** list);
void SeeAll		(struct nodo ** list);
void OneByOne		(struct nodo ** list);
void Search		(struct nodo ** list);
void Delete		(struct nodo ** list);
void FreeAll		(struct nodo ** list);
void Flush2File		(struct nodo ** list);
void ReadFile		(struct nodo ** list);
void Money		(struct nodo ** list);
void CalcTotal		(struct nodo ** list);
void HighestTotal       (struct nodo ** list);
void LowestTotal	(struct nodo ** list);
void Average		(struct nodo ** list);
void AddBegin		(struct nodo ** list, struct nodo * add);
void AddEnd		(struct nodo ** list, struct nodo * add);
void AddBetween		(struct nodo ** list, struct nodo * add);
int NumberExists	(struct nodo ** list, int number);
void ShowData		(struct nodo * data);
int  StrCompare		(char * s1, char * s2);
void ErrorOpeningFile 	(void);
int main (void)
{
	struct nodo * list = NULL; 	/* list will be a pointer to the first
					node of the linked list */
	int	choice;
	do
	{
		clrscr();
		textcolor (4);
		cputs ("\nDouble Linked Lists - Nicolas Raitman");
		textcolor (7);
		puts("\n\n0 - Exit");
		puts("1 - New Item");
		puts("2 - See All Items in the Linked List");
		puts("3 - Show Items One by One");
		puts("4 - Search Item");
		puts("5 - Delete Item");
		puts("6 - Delete Entire List");
		puts("7 - Money");
		puts("8 - Flush Linked List to File");
		puts("9 - Read File and Create Linked List");
		CHOICE (choice);
		switch (choice)
		{
			case 0:	Exit(&list); break;
			case 1: AddClient(&list); break;
			case 2: SeeAll(&list); break;
			case 3: OneByOne(&list); break;
			case 4: Search(&list); break;
			case 5: Delete(&list); break;
			case 6: FreeAll(&list); break;
			case 7: Money (&list); break;
			case 8: Flush2File(&list); break;
			case 9: ReadFile(&list); break;
			default: break;
		}
	} while (choice != 0);
	return EXIT_OK;
}
void ReadFile (struct nodo ** list)
{
	/* creates a new linked list from data in 'dlist.bin'
	deleting all repeated entries, filtering by nodo->nclient */
	struct nodo * aux = NULL;
	FILE	* fp;
	int	sizenodo = sizeof(struct nodo);
	/* first we make sure to free all the memory used by the list
	since we are going to create a new one */
	FreeAll (list);
	*list = NULL;
	if ((fp = fopen("dlist.bin", "rb")) == NULL)
	{
		ErrorOpeningFile();
		return;
	}
	/* we read the first record on the file and we add it to the
	beginning of the list */
	aux = (struct nodo *) malloc (sizenodo);
	fread(aux, sizenodo, 1, fp);
	AddBegin (list, aux);
	/* we do the loop while we are not in the end of file */
	while (!feof(fp))
	{
		aux = (struct nodo *) malloc (sizeof(struct nodo));
		if(fread(aux, sizenodo, 1, fp))
		{
			/* if nclient does not exist in our list then
			we add the node to the list */
			if (!NumberExists(list, aux->nclient))
				AddBetween(list, aux);
			else
				/* since I did not add the item to the list
				I free the memory used by it */
				free (aux);
		}
	}
	free (aux);
	printf("Data was read from 'dlist.bin' and Double Linked List was created.
Press any key to continue...");
	getch();
}
void ErrorOpeningFile (void)
{
	/* it shows a message stating that the file could not be opened*/
	printf("
Error while opening file.");
	getch();
}
int NumberExists (struct nodo ** list, int number)
{
	/* searches for number in all act->nclient, and if it finds
	any match it return 1, else it returns 0 */
	struct nodo * act = NULL;
	act = *list;
	while (act)
	{
		if (act->nclient == number)
			return 1;
		act = act->next;
	}
	/* if we reach this point then no match was found */
	return 0;
}
void Flush2File (struct nodo ** list)
{
	/* flushes all the items in the linked list into a file */
	struct nodo * act = NULL;
	FILE	* fp;
	int	choice;
	if (! *list)
		return;
	act = *list;
	printf("

1 - New File");
	printf("
2 - Append Data");
	CHOICE (choice);
	if (choice == 1)
	{
		/* we delete all the contents of the file and open it to write */
		if ((fp = fopen("dlist.bin", "wb")) == NULL)
		{
			ErrorOpeningFile();
			return;
		}
	}
	else
	{
		/* we open the file to append data */
		if ((fp = fopen("dlist.bin", "ab")) == NULL)
		{
			ErrorOpeningFile();
			return;
		}
	}
	/* while we have a node pointing to a differnt address than NULL... */
	while (act)
	{
		/* now we write into the file each node of the linked list */
		fwrite (act, sizeof (struct nodo), 1, fp);
		act = act->next;
	}
	fclose(fp);
	printf("

Data was flushed into 'dlist.bin'. Press any key to continue...");
	getch();
}
void Money (struct nodo ** list)
{
	/* this function shows a loop and it calls different functions to
	perform several calculation with the field "total" in the struct
	Not a big deal, just to show basic arithmetic calculations. Most
	of the functions that are called are described by its name */
	int choice;
	if (! *list)
	{
		printf("
Empty List. No calculations can be performed.");
		getch();
		return;
	}
	do
	{
		puts("
0 - Exit");
		puts("1 - Calculate Total");
		puts("2 - Highest Total");
		puts("3 - Lowest Total");
		puts("4 - Average Total");
		CHOICE(choice);
		switch (choice)
		{
			case 0: break;
			case 1: CalcTotal(list); break;
			case 2: HighestTotal(list); break;
			case 3: LowestTotal(list); break;
			case 4: Average(list); break;
			default: break;
		}
	} while (choice != 0);
}
void Average (struct nodo ** list)
{
	/* calculates the average of all the act->total for each node in the
	linked list */
	struct nodo * act = NULL;
	int	count = 0;
	float	total = 0, average;
	act = *list;
	while (act)
	{
		total += act->total;
		count++;
		act = act->next;
	}
	average = total / count;
	printf ("
Average = %.2f
", average);
}
void LowestTotal (struct nodo ** list)
{
	struct nodo * act = NULL, * lowest = NULL;
	act = *list;
	lowest = *list;
	while (act)
	{
		if (act->total < lowest->total)
			lowest = act;
		act = act->next;
	}
	ShowData(lowest);
}
void HighestTotal (struct nodo ** list)
{
	struct nodo * act = NULL, * highest = NULL;
	act = *list;
	highest = *list;
	while (act)
	{
		if (act->total > highest->total)
			highest = act;
		act = act->next;
	}
	ShowData(highest);
}
void CalcTotal (struct nodo ** list)
{
	struct nodo * act = NULL;
	float	total = 0;
	act = *list;
	while (act)
	{
		total += act->total;
		act = act->next;
	}
	printf("
Total = %.2f
", total);
}
void Delete (struct nodo ** list)
{
	/* this functions deletes a specific node in the list */
	struct nodo * act = NULL, * prev = NULL;
	int number;
	if (! *list)
		return;
	act = *list;
	prev = *list;
	printf("
Number to Delete: "); scanf("%i", &number);
	while (act)
	{
		/* we search until we find a the same number */
		if (act->nclient == number)
		{
			if (prev == act)
			{
				/* if trying to delete the first node
				then the beginning of the list will be the
				address of the next struct... */
				*list = act->next;
				/* so we assign a NULL address to the prev
				field of the next struct */
				act->next->prev = NULL;
			}
			else
			{
				/* this is easy to understand... just
				reordering the pointers to the next and
				previous structures since we deleted one */
				prev->next = act->next;
				act->next->prev = prev;
			}
			free (act);
			printf("
Item Deleted. Press Any Key.");
			getch();
		}
		prev = act;
		act = act->next;
	}
}
int StrCompare (char * s1, char * s2)
{
	/* if the string are equal return 1, otherwise return 0
	just trying to implement something similar to strcmp */
	int cont, lens1, lens2, different;
	lens1 = strlen(s1);
	lens2 = strlen(s2);
	for (cont = 0, different = 1; (cont < lens1) && (cont < lens2); cont++)
		if ( (*(s1 + cont)) != (*(s2 + cont)) )
			/* if I found one different character they are not equal */
			different = 0;
	return different;
}
void Search (struct nodo ** list)
{
	/* this function searches for either a number of a client or for
	its name. We present a menu until the user exits the loop */
	struct nodo * act = NULL;
	int	choice, number, foundit = 0;
	char	name[40];
	if (! *list)
		return;
	do
	{
		act = *list;
		puts("

0 - Exit");
		puts("1 - Search By Name");
		puts("2 - Search By Number");
		CHOICE(choice);
		switch (choice)
		{
			case 1:
				printf("Name: "); scanf("%s", name);
				while (act)
				{
					if (StrCompare(name, act->name))
					{
						foundit = 1;
						break;
					}
					act = act->next;
				}
				if (foundit)
				{
					printf("
	Found it!");
					ShowData(act);
				}
				break;
			case 2:
				printf("
Search Number: "); scanf("%i", &number);
				while (act)
				{
					if (act->nclient == number)
					{
						foundit = 1;
						break;
					}
					act = act->next;
				}
				if (foundit)
				{
					printf("
	Found it!");
					ShowData(act);
				}
				else
					printf("

	No Data was found");
				break;
			default:
				break;
		}
	} while (choice != 0);
}
void OneByOne (struct nodo ** list)
{
	/* this is my favourite function! When this function is called for the
	first time, the first node of the list is shown. Then the user has the
	possibility to look at the next, the previous, the last and the first
	*/
	struct nodo * act = NULL;
	int choice;
	if (! *list)
	{
		printf("
Empty List.");
		return;
	}
	act = *list;
	ShowData(act);
	do
	{
		printf("

0 - Exit");
		printf("
1 - Next");
		printf("
2 - Previous");
		printf("
3 - First");
		printf("
4 - Last");
		CHOICE(choice);
		switch (choice)
		{
			case 0: break;
			case 1:
				if (!act->next)
					/* if we have a NULL address in
					act->next then we are looking at the
					last one */
					printf ("		No more entries.");
				else
				{
					/* we point to the address of the next
					structure and show it */
					act = act->next;
					ShowData(act);
				}
				break;
			case 2:
				if (!act->prev)
					/* if act->prev == NULL then we are
					showing the first one */
					printf("		No previous entries.");
				else
				{
					/* we point to address of the previous
					structure */
					act = act->prev;
					ShowData(act);
				}
				break;
			case 3:
				/* to show the first item */
				while (act->prev)
					act = act->prev;
				ShowData(act);
				break;
			case 4:
				/* to show the last item */
				while (act->next)
					act = act->next;
				ShowData(act);
				break;
			default:
				printf("Invalid Choice");
				break;
		}
	} while (choice != 0);
}
void ShowData (struct nodo * data)
{
	printf("

	Number:		%i", data->nclient);
	printf("
	Name:		%s", data->name);
	printf("
	Total:		%.2f", data->total);
}
void SeeAll (struct nodo ** list)
{
	struct nodo * act = NULL;
	int	itemshown = 0;
	if (! *list)
	{
		printf("
No Data to Show. Empty List.");
		getch();
		return;
	}
	act = *list;
	while (act)
	{
		if (itemshown == 5)
		{
			/* since no more than 5 items can be shown on screen
			we hold until the user presses a key */
			itemshown = 0;
			printf("
Press any key to continue...");
			getch();
		}
		itemshown++;
		ShowData(act);
		act = act->next;
	}
	printf("

Press any key to continue..."); getch();
}
void AddClient (struct nodo ** list)
{
	/* this functions adds a new node to the linked list. The node can
	be added at the beginning, at the end or ordered by number */
	struct nodo * aux = NULL;
	char	temp[40];
	int	number, choice;
	aux = (struct nodo *) malloc (sizeof (struct nodo));
	if (aux)
	{
		/* we ask for the information about the new client */
		printf("
Number: "); scanf("%i", &(aux->nclient));
		printf("Name: "); scanf("%s", aux->name);
		printf("Total: "); scanf("%f", &(aux->total));
		if (! *list)
		{
			/* we are creating the list. There are neither previous
			nor nexts. So, we have to specify it by assigning NULL
			to those addresses */
			*list = aux;
			aux->next = NULL;
			aux->prev = NULL;
		}
		else
		{
			puts("
0 - Cancel");
			puts("1 - Add at the beginning.");
			puts("2 - Add at the end.");
			puts("3 - Add ordered");
			CHOICE(choice);
			switch (choice)
			{
				case 0: free(aux); break;
				case 1: AddBegin(list, aux); break;
				case 2: AddEnd(list, aux); break;
				case 3: AddBetween(list, aux); break;
				default: break;
			}
		}
	}
	else
	{
		puts ("Memory unavailable.");
		getch();
	}
}
void AddEnd (struct nodo ** list, struct nodo * add)
{
	/* we will be adding "add" to the end of "list" */
	struct nodo * prev = NULL, * act = NULL;
	act = *list;
	/* we serch for the last node in the list */
	while (act)
	{
		prev = act;
		act = act->next;
	}
	/* easy to understand... */
	prev->next = add; /* the previous node addressing to the next will be addressing to add */
	add->next = NULL; /* the one we are adding addressing to next will be addressing NULL, since it's the last one */
	add->prev = prev; /* finally, the one we are adding addressing the previous one will address prev */
}
void AddBegin (struct nodo ** list, struct  nodo * add)
{
	/* Add a new node to the beginning of the list */
	struct nodo * act = NULL;
	act = *list;
	act->prev = add;
	add->prev = NULL; /* since it's the first one then there are not any previous one */
	add->next = act;
	*list = add;
}
void AddBetween (struct nodo ** list, struct nodo * add)
{
	struct nodo * act = NULL, * prev = NULL;
	/* this function will add the item in the linked list
	according to nodo->nclient. This function will never create the
	list, since all the functions that call this one, check if they
	have to create the list. The function can add items at the beginning,
	middle or end of the list. */
	act = *list;
	prev = *list;
	while (act && (act->nclient <= add->nclient))
	{
		prev = act;
		act = act->next;
	}
	if (! act)
		AddEnd (list, add);
	else if (prev == act)
		AddBegin (list, add);
	else
	{
		/* once again we rearrange pointers. Easy to get the idea
		if you look at the names */
		prev->next = add;
		add->next = act;
		add->prev = prev;
		act->prev = add;
	}
}
void Exit (struct nodo ** list)
{
	FreeAll (list);
}
void FreeAll (struct nodo ** list)
{
	/* we free the memory allocated for each struct */
	struct nodo * act = NULL, * next = NULL;
	if (! *list)
		return;
	act = *list;
	while (act)
	{
		next = act->next;
		free (act);
		act = next;
	}
	*list = NULL;
}