C TUTORIALS

C STRUCTURE

noreply@blogger.com (Ron Tinnel) — Fri, 23 Sep 2011 05:41:00 -0400

REVISED: Sunday, March 15, 2015

CONTENTS:
I. C STRUCTURE INTRODUCTION
II. C STRUCTURE VOCABULARY
III. THE C STRUCTURE
IV. C STRUCTURE EXAMPLE PROGRAM SOURCE CODE
V. EXAMPLE PROGRAM OUTPUT
VI. C STRUCTURE REFERENCES

YOU WILL LEARN:
1. C structure vocabulary.
2. How to declare a C structure.
3. How memory for a C structure is allocated.
4. How to declare an instance of a C structure.

• I. INTRODUCTION

Welcome to the “C Structure Tutorial.”

The C code shown in the tutorial were written using the Microsoft Visual C++ Express Edition Integrated Development Environment (IDE) and the “C99 subset.”

• II. VOCABULARY

A. What is a structure?

A structure is a collection of logically related variables of different types. A structure groups logically related standard or user defined data types. Once declared, a structure defines a template for creating compound variable type objects which are instances of a structure.

Structures can be nested as elements in other structures. Structures can be used recursively. Structures can be used to define new data types.

B. What is a tag?

A structure type name is referred to as a tag. The tag appears right after the keyword struct.

If your program uses only one structure_variable, you do not need the structure_type_name.

C. What do you call variables that make up a structure?

Members, elements, or fields are the names of variables that make up the structure.

• III. THE C STRUCTURE

A. How do you declare a structure?

The syntax for simultaneously declaring a structure template and creating compound variable type objects is as follows:

struct structure_type_name{
//keyword
struct and tag, user defined type
type member_name;
//members, elements, or fields
type member_name;
type member_name;
.
.
.
}structure_variables;
//compound variable type objects

B. How do you allocate memory for a structure?

Memory is automatically allocated for all the members by the compiler when a structure variable is declared.

C. How do you define an instance of a structure?

After the structure template has been defined, an instance of a physical compound variable type object, a structure_variable can be declared using the following syntax:

struct structure_type_name structure_variable;

• IV. EXAMPLE PROGRAM

//**********************************
// C STRUCTURE TUTORIAL
//**********************************

#include<conio.h>
//contains function prototypes
#include<ctype.h>
//character handling
#include<stdio.h>
//input/output
#include<stdlib.h>
//general utilities
#include<string.h>
//string handling

struct item
//structure declaration
{
int item_stock_number;
//member, element, or field

char *item_name;
//member, element, or field

char *item_description;
//member, element, or field

float item_cost;
//member, element, or field

float item_sales_price;
//member, element, or field

int item_inventory_quantity;
//member, element, or field

}item1, item2, item3;
//compound variable type objects

void f_item1(void);
//function prototype

void f_item2(void);
//function prototype

void f_item3(void);
//function prototype

void p_item1(void);
//function prototype

void p_item2(void);
//function prototype

void p_item3(void);
//function prototype

int main(void)
{
f_item1();
//function call

f_item2();
//function call

f_item3();
//function call

p_item1();
//function call

p_item2();
//function call

p_item3();
//function call

char ch;
ch = getch();
//keeps screen from closing
//until a key is pressed

return 0;
}

void f_item1(void)
//function definition
{
item1.item_stock_number = 128;

item1.item_name = "Diamond Cufflinks";

item1.item_description = "Each 3 Carat Skull Shaped, 9K (375Au) yellow gold.";

item1.item_cost = 250.00;

item1.item_sales_price = 2500.00;

item1.item_inventory_quantity = 10;
}

void f_item2(void)
//function definition
{
item2.item_stock_number = 142;

item2.item_name = "Ruby Cufflinks";

item2.item_description = "Each 3 Carat Skull Shapped, 9K (375Au) yellow gold.";

item2.item_cost = 500.00;

item2.item_sales_price = 5000.00;

item2.item_inventory_quantity = 20;
}

void f_item3(void)
//function definition
{
item3.item_stock_number = 187;

item3.item_name = "Sapphire Cufflinks";

item3.item_description = "Each 3 Carat Skull Shapped, 9K (375Au) yellow gold.";

item3.item_cost = 1000.00;

item3.item_sales_price = 10000.00;

item3.item_inventory_quantity = 30;
}

void p_item1(void)
//function definition
{
printf("Stock Number: %i \n", item1.item_stock_number);

printf("Name: %s \n", item1.item_name);

printf("Description: %s \n", item1.item_description);

printf("Cost: $%.2f \n", item1.item_cost);

printf("Sales Price: $%.2f \n", item1.item_sales_price);

printf("Inventory: %i \n\n\n", item1.item_inventory_quantity);
}

void p_item2(void)
//function definition
{
printf("Stock Number: %i \n", item2.item_stock_number);

printf("Name: %s \n", item2.item_name);

printf("Description: %s \n", item2.item_description);

printf("Cost: $%.2f \n", item2.item_cost);

printf("Sales Price: $%.2f \n", item2.item_sales_price);

printf("Inventory: %i \n\n\n", item2.item_inventory_quantity);
}

void p_item3(void)
//function definition
{
printf("Stock Number: %i \n", item3.item_stock_number);

printf("Name: %s \n", item3.item_name);

printf("Description: %s \n", item3.item_description);

printf("Cost: $%.2f \n", item3.item_cost);

printf("Sales Price: $%.2f \n", item3.item_sales_price);

printf("Inventory: %i \n\n\n", item3.item_inventory_quantity);

}

• V. EXAMPLE PROGRAM OUTPUT

Stock Number: 128
Name: Diamond Cufflinks
Description: Each 3 Carat Skull Shaped, 9K (375Au) yellow gold.
Cost: $250.00
Sales Price: $2500.00
Inventory: 10

Stock Number: 142
Name: Ruby Cufflinks Description: Each 3 Carat Skull Shapped, 9K (375Au) yellow gold.
Cost: $500.00
Sales Price: $5000.00
Inventory: 20

Stock Number: 187
Name: Sapphire Cufflinks
Description: Each 3 Carat Skull Shapped, 9K (375Au) yellow gold. Cost: $1000.00
Sales Price: $10000.00
Inventory: 30

• VI. REFERENCES

The C Programming Language by Brian Kernighan and Dennis Ritchie (Englewood Cliffs, N.J.: Prentice-Hall, 1978).

C++: The Complete Reference, Fourth Edition by Herbert Schildt (Berkeley, California: McGraw-Hill/Osborne, 2003).

YOU HAVE LEARNED:
1. C structure vocabulary.
2. How to declare a structure.
3. How memory for a structure is allocated.
4. How to declare an instance of a structure.

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"

C KEYBOARD INPUT AND SCREEN OUTPUT

noreply@blogger.com (Ron Tinnel) — Fri, 23 Sep 2011 05:26:00 -0400

REVISED: Sunday, March 15, 2015

CONTENTS:
I. C KEYBOARD INPUT AND SCREEN OUTPUT INTRODUCTION
II. READING FROM THE KEYBOARD
III. WRITING TO THE CONSOLE
IV. C KEYBOARD INPUT AND SCREEN OUTPUT REFERENCES

YOU WILL LEARN HOW TO:
1. Read from the keyboard.
2. Write to the console.

• I. C KEYBOARD INPUT AND SCREEN OUTPUT INTRODUCTION

Welcome to the “C Keyboard Input and Screen Output Tutorial.”

During this tutorial we will discuss the library functions C uses for keyboard input and screen output. The prototypes for these functions are in the header file conio.h.

C++ includes the entire C language; therefore, all C programs, with a few minor exceptions, are also C++ programs.

The C code shown in the tutorial were written using the Microsoft Visual C++ Express Edition Integrated Development Environment (IDE) and the “C99 subset.”

• II. READING FROM THE KEYBOARD

The following are basic keyboard functions:

getchar( ) reads a character from the keyboard; waits for a carriage return. Its prototype is:

int getchar(void);

getche( ) reads a character from the keyboard with echo to the screen; does not wait for carriage return. Its prototype is:

int getche(void);

getch( ) reads a character from the keyboard without echo to the screen; does not wait for carriage return. Its prototype is:

int getch(void);

gets( ) reads a string from the keyboard. Its prototype is:

char *gets(char *str);

str is a character array.

scanf( ) reads data from the keyboard. Its prototype is:

int scanf(const char *control_string, …);

The scanf( ) control string contains three parts. First, format specifiers. Second, white-space characters. Third, non-white-space characters.

Each scanf( ) format specifier is a %, followed by a format code. Each argument is matched with a format specifier in order from left to right.

The following are examples of scanf( ) format specifiers:

%c Read a single character.
%d Read a decimal integer.
%i Read an integer in either decimal, hexadecimal or octal format.
%e Read a floating point number.
%f Read a floating point number.
%g Read a floating point number.
%o Read an octal number.
%s Read a string.
%x Read a hexadecimal number.
%p Read a pointer.
%n Receives an integer value equal to the number of characters read so far.
%u Read an unsigned decimal integer.
%[ ] Scan for a set of characters.
%% Read a % sign.

A white-space character in the scanf( ) control string causes scanf( ) to skip over one or more leading white-space characters; e.g., space, tab, vertical tab, form feed, or newline in the input stream.

A non-white-space character in the scanf( ) control string causes scanf( ) to read and discard matching characters in the input stream.

• III. WRITING TO THE CONSOLE

The following are basic console functions:

putchar( ) writes a character to the screen. Its prototype is:

int putchar(int c);

puts( ) writes a string to the screen. Its prototype is:

int puts(const char *str);

printf( ) writes data to the console. Its prototype is:

int printf(const char *control_string, …);

The printf( ) control string is in two parts. The first part consists of characters that will be printed to the screen. The second part is format specifiers which define the display of the arguments.

Each printf( ) format specifier is a %, followed by a format code. Each argument is matched with a format specifier in order from left to right.

The following are examples of printf( ) format specifiers:

%c Character
%d Signed decimal integers
%i Signed decimal integers
%e Scientific notation lowercase e
%E Scientific notation uppercase e
%f Decimal floating point
%g Uses %e or %f, whichever is shorter
%G Uses %E or %F, whichever is shorter
%o Unsigned octal
%s String of characters
%u Unsigned decimal integers
%x Unsigned hexadecimal lowercase letters
%X Unsigned hexadecimal uppercase letters
%p Displays a pointer
%n The associated argument must be a pointer to an integer. This specifier causes the number of characters written so far to be put into that integer.
%% Prints a % sign

• IV. C KEYBOARD INPUT AND SCREEN OUTPUT REFERENCES

The C Programming Language by Brian Kernighan and Dennis Ritchie (Englewood Cliffs, N.J.: Prentice-Hall, 1978).

C++: The Complete Reference, Fourth Edition by Herbert Schildt (Berkeley, California: McGraw-Hill/Osborne, 2003).

YOU HAVE LEARNED HOW TO:
1. Read from the keyboard.
2. Write to the console.

Elcric Otto Circle

--> --> -->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"

C FILE INPUT AND OUTPUT

noreply@blogger.com (Ron Tinnel) — Fri, 23 Sep 2011 05:14:00 -0400

REVISED: Sunday, March 15, 2015

CONTENTS:
I. C FILE INPUT AND OUTPUT INTRODUCTION
II. C FILE INPUT AND OUTPUT VOCABULARY
III. WRITING TO A FILE
IV. READING FROM A FILE
V. C FILE INPUT AND OUTPUT EXAMPLE PROGRAM SOURCE CODE
VI. C FILE INPUT AND OUTPUT REFERENCES

YOU WILL LEARN:
1. C input and output vocabulary.
2. How to write to a binary file.
3. How to read from a binary file.

• I. C FILE INPUT AND OUTPUT INTRODUCTION

Welcome to the “C File Input and Output Tutorial.”

During this tutorial we will discuss the library functions C uses for file input and output. The prototypes for these functions are in the C header files; for example, <stdio.h>.

C++ includes the entire C language; therefore, all C programs, with a few minor exceptions, are also C++ programs.

The C code examples shown in the tutorial were written using the Microsoft Visual C++ Express Edition Integrated Development Environment (IDE) and the “C99 subset.”

• II. C FILE INPUT AND OUTPUT VOCABULARY

A. What is a field?

A field is a group of characters that conveys meaning such as a field representing a color of light.

B. What is a record?

A record is a group of related fields.

C. What is a stream?

A stream is a logical device.

Streams are device independent mental abstractions. When you use scanf() and stdin you are using a keyboard file stream. When you use printf() and stdout you are using a screen file stream.

A stream is a flow of related records. There are two types of streams: text and binary. A sequence of characters is a text file stream. A sequence of bytes is a binary file stream.

D. What is a FILE pointer?

A FILE pointer is used to enable the program to keep track of the stream being accessed, and to let the compiler perform input and output functions.

A program opens a file stream by calling a standard library function. The library function returns a FILE pointer. The file pointer is a pointer to a structure of type FILE. The file pointer points to the unique memory address of a file.

The syntax for a FILE pointer is as follows:

FILE *fp;

E. What is a file?

A file is an actual device.

A file is a container you can both read from and write to.

F. What is a header file?

The header files contain prototypes for the file input and output functions; and macros.

Prototypes declare functions before they are used.

The syntax for a function prototype is as follows:

type function_name(type parameter_name1, type parameter_name2,…, type parameter_nameN,);

When a function has no parameters, use void inside the parameter list.

type function_name(void);

G. What is POD?

POD is Plain Old Data. For example, in the case of a POD structure, the structure would contain no pointers and all members would be of a fixed size.

H. What is a Library?

C provides the basic functions you need to get started. However, you have to code everything else yourself.

When you notice you are rewriting the same code over and over take the time to turn that code into a generic library function.

A library consists of two parts: a header file and the actual code file. The library header file uses quotes instead of the symbols < and >, which are only used for system libraries.

Library C function calls should always pass arguments by value. In other words use regular function variables, do not use function pointers. This is done to ensure that only local “copies” of the values of the arguments are passed to the library function. Therefore, all changes made to the arguments in the local copy of the library function are only made to the local copy of the arguments and not to the original arguments themselves.

• III. WRITING TO A FILE

Writing to a file requires three steps:

A. Open the file.

To open a file use the fopen function, which returns a FILE pointer.

The open operation return pointer associates a stream with a specific file. If the file can not be opened, the return pointer is set to the value NULL.

The syntax for opening a file is as follows:

FILE *fopen(const char *filename, const char *mode);

The filename is a string containing the name of the file to be opened.

The mode is a string containing the way the file will be used.

Text file modes are as follows:

r Open file for reading. File must exist. NULL pointer returned if file does not exist.

w Open for writing. If file does not exist it is created. If file does exist it will be overwritten.

a Open file for appending. If file does not exist it is created. Appends if file exists.

r+ Open file for reading and writing. File must exist. Starts at beginning of existing file.

w+ Open file for reading and writing. If file does not exist it is created. Overwrites existing file.

a+ Open file for reading and writing. If file does not exist it is created. Appends if file exists.

Binary file modes are as follows:

rb Open file for reading. File must exist. NULL pointer returned if file does not exist.

wb Open for writing. If file does not exist it is created. If file does exist it will be overwritten.

ab Open file for appending. If file does not exist it is created. Appends if file exists.

r+b Open file for reading and writing. File must exist. Starts at beginning of existing file.

w+b Open file for reading and writing. If file does not exist it is created. Overwrites existing file.

a+b Open file for reading and writing. If file does not exist it is created. Appends if file exists.

For binary File I/O you use fread and frwrite.

When typing a file path, type double back-slashes. For example, typing

"j:\folder\example1.bin"

will not work.

You have to type

"j:\\folder\\example1.bin".

The folder has to exist. The program will crash if the folder does not exist.

An example of opening a binary file for writing is as follows:

FILE *fp;
fp=fopen(“j:\\examples\\example1.bin”,”wb”);

This code will open the binary file named example1.bin on drive j: in folder examples for writing. If file does exist it will be overwritten. If the file does not exist it will be created.

Always test to make sure the file opened before you try to write to the file.

An example of testing whether a file did not open is as follows:

if ((fp = fopen ("j:\\examples\\example1.bin","wb")) == NULL)
{
printf ("ERROR MESSAGE! File could not be opened!\n");
}

Once you know the file opened properly, use the FILE return pointer to tell the compiler to perform input and output functions on the file.

Use fread() and fwrite() for binary file fixed-length record I/O; for example:

size_t fwrite(const void *buffer, size_t num_bytes, size_t count, FILE *fp);

fwrite() takes four arguments:

1. const void * buffer

The first argument is a pointer to the name of the array or the address of the structure you want to write to the file.

2. size_t num_bytes

The second argument is the size of each element in bytes.

For example, if you have an array of characters, you would read the array in one byte at a time. Therefore, num_bytes would be one.

3. size_t count

The third argument is the count of the number of elements you want to write.

4. FILE * fp

The fourth argument is the stream file pointer.

B. Do all the writing.

An example of writing to a binary file is as follows:

//write to binary file

FILE *fp;
fp=fopen("j:\\examples\\example1.bin", "wb");

if (fp == NULL)
{
printf (" ERROR MESSAGE! Binary file could not be opened!\n\n\n\n");

}else
{
printf(" Binary file opened!\n\n\n\n");

fwrite(&write, sizeof(write[0]), sizeof(write)/sizeof(write[0]), fp);

printf(" %s character string array was written to the binary file.\n\n\n\n", write);

}

int returncode;

returncode = fclose (fp);

if (returncode == 0)
{
printf (" Binary file closed!\n\n\n\n");

}else
{
printf (" ERROR MESSAGE! Binary file did not close!\n\n\n\n");

}

C. Close the file.

Always close a file as soon as you are done using it. The syntax for closing a file is as follows:

int returncode;

returncode = fclose (fp);

if returncode == 0; the file pointed to by fp closed.

if returncode != 0; the file pointed to by fp did not close.

Always test to make sure the file closed. Zero is returned if the file closed. EOF is returned if the file did not close.

An example of testing whether a file closed is as follows:

if (fclose(fp) != 0)
{
printf ("ERROR MESSAGE! File did not close!\n");
}

if fclose(fp) == 0; the file pointed to by fp closed.

if (fclose(fp) != 0); the file pointed to by fp did not close.

• IV. READING FROM A FILE

Reading from a file requires three steps:

A. Open the file.

Test to make sure the file opened before you read the file.

//read from binary file

FILE *fpRead;
fpRead=fopen("j:\\examples\\example1.bin", "rb");

if (fpRead == NULL)
{
printf (" ERROR MESSAGE! Binary file could not be opened!\n\n\n\n");

}else
{
printf (" Binary file opened!\n\n\n\n");

B. Do all the reading.

The input file that we are opening for reading must already exist.

fread(&read, sizeof(read[0]), sizeof(read)/sizeof(read[0]), fpRead);

C. Close the file.

The syntax for closing a file is as follows:

printf(" %s character string array was read from the binary file.\n\n\n\n", read);

}

int returncodeRead;

returncodeRead = fclose (fpRead);

if (returncodeRead == 0)
{
printf(" Binary file closed!\n\n\n\n");

}else
{
printf(" ERROR MESSAGE! Binary file did not close!\n\n\n\n");

}

• V. C FILE INPUT AND OUTPUT EXAMPLE PROGRAM SOURCE CODE

//***********************************
//C FILE INPUT AND OUTPUT TUTORIAL
//***********************************

#include<conio.h>
//contains function prototypes
#include<stdio.h>
//standard I/O header file
#include<string.h>
//string handling
#include<windows.h>
// keybd_event()

void ShowTime(void);

void AltEnter(void);

void DateTime(void);

void menu(void);

//**********************************

int main(int argc, char *argv[])
{
ShowTime();

menu();

return EXIT_SUCCESS;
}

//**********************************

void ShowTime(void)
{
AltEnter();

system("COLOR 1F");

return;
}

void AltEnter(void)
{
keybd_event(VK_MENU,
0x38,
0,
0);
keybd_event(VK_RETURN,
0x1c,
0,
0);

keybd_event(VK_RETURN,
0x1c,
KEYEVENTF_KEYUP,
0);

keybd_event(VK_MENU,
0x38,
KEYEVENTF_KEYUP,
0);

return;
}

void DateTime(void)
{
printf("\n");

printf("\n");

printf("\n");

printf(" ");

printf(__DATE__);

printf(" ");

printf(__TIME__);

printf("\n");

printf("\n");

return;
}

void menu(void)
{
system("CLS");

DateTime();

printf("\n\n C FILE INPUT AND OUTPUT TUTORIAL \n\n\n\n");

printf(" 0 EXIT\n\n");

printf(" 1 Write a character string array to a binary file\n\n");

printf(" and then read that character string array from the same binary file.\n\n\n");

printf("\n\n Please type your menu selection; for example, 0 to EXIT.\n\n ");

char menuSelection;

menuSelection = getch();

switch(menuSelection)
{
case '0':
break;

case '1':
system("CLS");

DateTime();

printf("\n\n C FILE INPUT AND OUTPUT TUTORIAL \n\n\n\n");

char write[10]="ELEPHANTS";

char read[10];

for (int i=0; i++; i<=10)
{
read[i]='\n';

}

//write to binary file

FILE *fp;
fp=fopen("j:\\examples\\example1.bin", "wb");

if (fp == NULL)
{
printf (" ERROR MESSAGE! Binary file could not be opened!\n\n\n\n");

}else
{
printf(" Binary file opened!\n\n\n\n");

fwrite(&write, sizeof(write[0]), sizeof(write)/sizeof(write[0]), fp);

printf(" %s character string array was written to the binary file.\n\n\n\n", write);

}

int returncode;

returncode = fclose (fp);

if (returncode == 0)
{
printf (" Binary file closed!\n\n\n\n");

}else
{
printf (" ERROR MESSAGE! Binary file did not close!\n\n\n\n");

}

//read from binary file

FILE *fpRead;
fpRead=fopen("j:\\examples\\example1.bin", "rb");

if (fpRead == NULL)
{
printf (" ERROR MESSAGE! Binary file could not be opened!\n\n\n\n");

}else
{
printf (" Binary file opened!\n\n\n\n");

fread(&read, sizeof(read[0]), sizeof(read)/sizeof(read[0]), fpRead);

printf(" %s character string array was read from the binary file.\n\n\n\n", read);

}

int returncodeRead;

returncodeRead = fclose (fpRead);

if (returncodeRead == 0)
{
printf(" Binary file closed!\n\n\n\n");

}else
{
printf(" ERROR MESSAGE! Binary file did not close!\n\n\n\n");
}

printf("\n\n Type any key to continue.\n\n ");

char screenOpen;

screenOpen = getch();
//keeps screen open until a key is pressed

menu();

break;
}
}

• VI. C FILE INPUT AND OUTPUT REFERENCES

The C Programming Language by Brian Kernighan and Dennis Ritchie (Englewood Cliffs, N.J.: Prentice-Hall, 1978).

C++: The Complete Reference, Fourth Edition by Herbert Schildt (Berkeley, California: McGraw-Hill/Osborne, 2003).

YOU HAVE LEARNED:
1. C input and output vocabulary.
2. How to write to a binary file.
3. How to read from a binary file.

Elcric Otto Circle

--> --> -->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"

C SINGLE LINKED LIST

noreply@blogger.com (Ron Tinnel) — Thu, 22 Sep 2011 21:28:00 -0400

REVISED: Sunday, March 15, 2015

CONTENTS
• I. C SINGLE LINKED LIST INTRODUCTION
• II. REVIEW OF C SINGLE LINKED LIST BASICS
• III. REVIEW OF RELEVANT C SINGLE LINKED LIST PROGRAMMING CONCEPTS
• IV. ANALYSIS OF C SINGLE LINKED LIST EXAMPLE PROGRAM
• V. C SINGLE LINKED LIST EXAMPLE PROGRAM SOURCE CODE
• VI. C SINGLE LINKED LIST REFERENCES

YOU WILL LEARN:
1. The C Single Linked List.
2. The C Pointers.
3. The C strut.

I. C SINGLE LINKED LIST INTRODUCTION

Welcome to the “C Single Linked List Tutorial.”

The C code shown in the tutorial was written using the Microsoft Visual C++ Express Edition Integrated Development Environment (IDE) and the “C99 subset.”

A linked list is a chain of structures of the same type. Each link of the chain is a node with a member with a pointer to the next node in the chain and member[s] of different types containing relevant information. Therefore, pointers are a key to understanding and programming linked lists. If you have problems understanding linked lists, brush up on pointers.

II. REVIEW OF C SINGLE LINKED LIST BASICS

The single linked list is one of the most common data structures used in C. It is called a single linked list because it only points to the next node, and not the next node and the previous node; etc. Each record of a single linked list is called an element or node. Each node in the single linked list is a struct and contains fields called members which contain data plus a pointer to the next node.

The information in a single linked list can only be accessed sequentially and not randomly. To read the hundredth node of a single linked list, you must first read each of the preceding 99 nodes.

A single linked list normally consists of a root node, allocated on the stack, and one or more nodes, allocated on the heap by calling malloc.

Each node has two parts:

A. A Data Member

The data member[s] containing the information you want stored in the single linked list.

B. A Link Member

The link member to the next node. Setting the link member to NULL indicates the end of the linked list.

III. REVIEW OF RELEVANT C SINGLE LINKED LIST PROGRAMMING CONCEPTS

A. Call By Value

C is a ''call by value'' language, which means a called function is only given a copy of its arguments, not their addresses.

B. Memory Address

A pointer is a memory address.

C. Always Initialize Pointers

If a pointer is not initialized it will point to a random memory location; therefore, always initialize pointers.

D. Assignments

An assignment to a pointer variable changes the address in the variable, not the value at that address.

E. Pointer Variable

“Pointer variable” means “variable of a pointer type”.

F. Multiple Indirection

“Pointers to pointers” is called multiple indirection.

G. Constants

A pointer is a constant.

H. Function Addresses

C functions have addresses; therefore, pointers can point to C functions.

I. Passing Function Pointers

Function pointers can be passed as parameters in function calls.

J. Return Value of a Function

A function pointer can be the return value of a function.

K. Declarations

Keep every declaration on its own line.

IV. ANALYSIS OF C SINGLE LINKED LIST EXAMPLE PROGRAM

A. TYPEDEF

A typedef is used to define the compound variable type object named model as type node; for example:

//typedef renames
//struct type model to node.
typedef struct model
//model is the structure tag.
{
int nodeOrder;
//Sequential order of book in the bible.

char *nodeName;
//Name of book in the bible.

struct model *nextNode;
//Nested structure,
//recursive structure pointer,
//link to next node.

}node;

As shown above, the compound variable type object named node has the following three members:

struct node
• Int bookOrder
• char *bookName
• struct *nextNode

node is the model, the template used by the program to declare all structures needed by the single linked list program.

B. MENU SWITCH CASE 0

The program exits.

C. MENU SWITCH CASE 1

The program creates an empty single linked list structure named head of type node.

//Declares head a structure pointer
//to an empty single linked list
//structure of type node.
node *head = NULL;

The compound variable type object named head has the following three members:

struct head
• Int bookOrder
• char *bookName
• struct *nextNode

At this point the program has an empty single linked list named head stored in memory.

D. *addNode() POINTER FUNCTION

1. *addNode() Function Pointer Function Call.

The program executes an addNode() function call.

//Calls function addNode(), and passes
//arguments, including address of head,
//to function addNode().
addNode(1, "Genesis", &head);

2. *addNode() Function

Notice that the arguments in the *addNode() function call are the same number, type, and sequence as their corresponding parameters in the *addNode function definition.

addNode() function call parameters
• int o
• char n
• struct pointerToNode

The *addNode function processes the function call:

//** pointer to pointer means
//the first pointer contains the address
//of the second pointer,
//which points to the struct variable
//object name head,
//the start of the single linked list.
node *addNode(int o, char *n, node **pointerToNode)
{

3. temp node Definition

In the example program, the struct temp is embedded inside of the function addNode(). The addNode function creates a new node named temp.

//Declares temp a structure
//pointer to type node.
node *temp;

The addNode function creates the following single linked list structure named temp of type node.

struct temp
• int bookOrder
• char *bookName
• struct *nextNode

The struct temp is used as a struct to hold a new node while the addNode() function uses malloc to allocate the new node memory and a memory address. The addNode() function assigns the memory address to the struct compound variable type object named temp.

//Declares and initializes the temp node
//by reserving a memory address
//for the new node.
temp = malloc(sizeof(node));

The temp node is assigned a pointer to NULL.

//temp node, nextNode member,
//is assigned a pointer to NULL.
temp->nextNode = *pointerToNode;

temp->nodeOrder = o;
temp->nodeName = n;

The memory address of the new temp node is copied to the head node, nextNode member. Now the head node points to the new temp node and the new temp node, nextNode member, points to NULL.

//Assignes the memory address
//of the new temp node to the head node.
*pointerToNode = temp;
//Now the head node
//points to the new temp node.
//And, the new temp node points to NULL.

Finally, the function addNode() returns the memory address pointed to by the head node. This provides any subsequent addNode() function calls with the new memory address for the head of the linked list.

//Returns new pointer to head.
return *pointerToNode;

}

E. REMAINING FUNCTION CALLS

The remaining function calls are processed in the same manner; however, instead of using NULL, use the new pointer to head:

addNode(2, "Exodus", &head);

addNode(3, "Leviticus", &head);

addNode(4, "Numbers", &head);

addNode(5, "Deuteronomy", &head);

V. C SINGLE LINKED LIST EXAMPLE PROGRAM SOURCE CODE

//***********************************
//C Single Linked List Tutorial
//***********************************
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<windows.h>

//Function prototypes.
void altEnter(void);

void dateTime(void);

void menu(void);

void showTime(void);

//typedef renames
//struct type model to node.
//model is the structure tag.
typedef struct model
{
int nodeOrder;
//Sequential order of a book in the bible.

char *nodeName;
//Name of book in the bible.

struct model *nextNode;
//Nested structure,
//recursive structure pointer,
//link to next node.

}node;

//** pointer to pointer means
//the first pointer contains the address
//of the second pointer,
//which points to the struct
//compound variable
//type head, the start of the
//single linked list.
node *addNode(int o, char *n, node **pointerToNode)
{
//Declares temp a pointer to a structure
//of type node.
node *temp;

//Declares and initializes the temp node by
//reserving a memory address
//for the new node.
temp = malloc(sizeof(node));

//The temp node, nextNode member,
//is assigned a pointer to NULL.
temp->nextNode = *pointerToNode;

temp->nodeOrder = o;

temp->nodeName = n;

//Assignes the memory address
//of the new temp node to the head node.
*pointerToNode = temp;

//Now the head node points to
//the new temp node.
//And the new temp node points to NULL.

//Returns new pointer to head.
return *pointerToNode;
}

//**********************************

int main(int argc, char *argv[])
{
showTime();

dateTime();

menu();

return 0;
}

//**********************************

void showTime(void)
{
altEnter();

system("COLOR 1F");

return;
}

void altEnter(void)
{
keybd_event(VK_MENU,
0x38,
0,
0);

keybd_event(VK_RETURN,
0x1c,
0,
0);

keybd_event(VK_RETURN,
0x1c,
KEYEVENTF_KEYUP,
0);

keybd_event(VK_MENU,
0x38,
KEYEVENTF_KEYUP,
0);
return;
}

void dateTime(void)
{
printf("\n");

printf("\n");

printf("\n");

printf(" ");

printf(__DATE__);

printf(" ");

printf(__TIME__);

printf("\n");

printf("\n");

return;
}

void menu(void)
{
system("CLS");

dateTime();

printf("\n\n C SINGLE LINKED LIST TUTORIAL\n\n\n\n");

printf(" 0 EXIT\n\n");

printf(" 1 Screen print UNSORTED output from linked list example program.\n\n");

printf("\n\n Please type your menu selection; for example, 0 to EXIT.\n\n ");

char menuSelection;

menuSelection = getch();

switch(menuSelection)
{
case '0':
{

}
break;

case '1':
{
system("CLS");

dateTime();

printf("\n\n C LINKED LIST STRUCTURE\n\n\n\n");

printf(" THE SINGLE LINKED LIST STRUCTURE NAMED HEAD OF TYPE NODE IS SHOWN BELOW:\n\n\n\n");

printf(" # NAME POINTER\n\n");

printf(" head->nodeOrder head->nodeName head->nextNode\n\n\n");

//Declares head a pointer
//to a structure of type node.
node *head = NULL;

//Calls function addNode(),
//and passes arguments, including
//address of head, to function addNode().
addNode(1, "Genesis", &head);

addNode(2, "Exodus", &head);

addNode(3, "Leviticus", &head);
addNode(4, "Numbers", &head);
addNode(5, "Deuteronomy", &head);

//While head is not NULL.
while(head)
{
printf(" %-17d %-17s %-17p\n\n", head->nodeOrder, head->nodeName, head->nextNode);

head = head->nextNode;
}

printf("\n\n Type any key to continue.\n\n ");

//Keeps screen open
//until a key is pressed.
char screenOpen;

screenOpen = getch();

menu();
}
break;
}
}

VI. C SINGLE LINKED LIST REFERENCES

The C Programming Language by Brian Kernighan and Dennis Ritchie (Englewood Cliffs, N.J.: Prentice-Hall, 1978).

C++: The Complete Reference, Fourth Edition by Herbert Schildt (Berkeley, California: McGraw-Hill/Osborne, 2003).

YOU HAVE LEARNED:

1. The C Single Linked List.
2. The C Pointers.
3. The C strut.

Elcric Otto Circle

--> --> -->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"

C HEAD END LINKED LIST

noreply@blogger.com (Ron Tinnel) — Thu, 22 Sep 2011 21:05:00 -0400

REVISED: Sunday, March 15, 2015

CONTENTS
• I. C "HEAD END" LINKED LIST INTRODUCTION
• II. C "HEAD END" LINKED LIST VOCABULARY
• III. C LINKED LISTS
• IV. C “HEAD END”LINKED LISTS
• V. C "HEAD END" LINKED LIST EXAMPLE PROGRAM SOURCE CODE
• VI. C "HEAD END" LINKED LIST REFERENCES

YOU WILL LEARN:
1. Linked list vocabulary.
2. How to create a “head end” linked list.

I. C "HEAD END" LINKED LIST INTRODUCTION

Welcome to the “C Head End Linked List Tutorial.”

The C code shown in this tutorial was written using the Microsoft Visual C++ Express Edition Integrated Development Environment (IDE) and the “C99 subset.”

II. C "HEAD END" LINKED LIST VOCABULARY

A. What are C’s dynamic allocation functions?

A linked list is a dynamic structure that grows or shrinks based on the needs of the program. Therefore, a linked list uses the dynamic allocation function malloc() to obtain memory and the dynamic allocation function free() to free memory while the program is running.

B. What is a linked list?

Each record of a linked list contains a field with a link to the next record in the list.

C. What is a node?

The records of a linked list are called elements or nodes.

D. What is a list handle?

The first node of a list is its head, which is often called the address, pointer, or handle of the list because it provides entry to the whole list.

III. C LINKED LISTS

Each record of a linked list contains data fields and a field with a link to the next record in the list. Each record of a linked list is called an element or node. The head of a list is its first node, which is often called the address, pointer, or handle of the list because it provides entry to the whole list.

When a structure is a member of another structure it is called a nested structure. The following code, from the example program, shows the nested structure holding the pointer link to the next node.

typedef struct Bible
{
char *bookName;

int bookOrder;

struct Bible *nextBook;
//the pointer link to the next node

}Book;

IV. C "HEAD END" LINKED LIST

A push function can be used to add nodes to the “head end” of a linked list; this inserts nodes at the beginning of the linked list. The order of records in a “head end” list, end up in the reverse order in which they are added.

The following program code, shows the push function for the “head end” linked list example.

//push function for
//the “head end” linked list

Book *addBook(Book **pointerToBook, char *n, int o)
//** pointer to pointer to the head
{
Book *grace;
//create a temporary node

grace = malloc(sizeof(Book));
//allocate space for node

grace->bookName = n;

grace->bookOrder = o;

grace->nextBook = *pointerToBook;
//pointer to the head

*pointerToBook = grace;
//pointer to the head

return *pointerToBook;
//pointer to the head
}

The following example program code, shows how NULL is used to tell the program it has reached the last node in the linked list.

Book *Genesis = NULL;
//last node in list is an empty linked list

The following example program code, shows how calls are made to the push function for the “head end” linked list.

addBook(&Genesis, "Genesis", 1);

addBook(&Genesis, "Exodus", 2);

addBook(&Genesis, "Leviticus", 3);

addBook(&Genesis, "Numbers", 4);

addBook(&Genesis, "Deuteronomy", 5);

The following example program code, shows how to print a linked list to the screen.

printf(" FIRST FIVE BOOKS OF THE BIBLE\n\n");

while(Genesis)
//while Genesis is not NULL
{
printf(" %d %s\n\n", Genesis->bookOrder, Genesis->bookName);

Genesis = Genesis->nextBook;
}

V. C "HEAD END" LINKED LIST EXAMPLE PROGRAM SOURCE CODE

//***********************************
//C "HEAD END" LINKED LIST
//***********************************
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<windows.h>

void AltEnter(void);

void DateTime(void);

void menu(void);

void ShowTime(void);

typedef struct Bible
{
char *bookName;

int bookOrder;

struct Bible *nextBook;
//the pointer link to the next node

}Book;

//push function for the
//“head end” linked list

Book *addBook(Book **pointerToBook, char *n, int o)
//** pointer to pointer to the head
{
Book *grace;
//create a temporary node

grace = malloc(sizeof(Book));
//allocate space for node

grace->bookName = n;

grace->bookOrder = o;

grace->nextBook = *pointerToBook;
//pointer to the head

*pointerToBook = grace;
//pointer to the head

return *pointerToBook;
//pointer to the head
}

//**********************************

int main(int argc, char *argv[])
{
ShowTime();

DateTime();

menu();

return 0;
}

//**********************************

void ShowTime(void)
{
AltEnter();

system("COLOR 1F");

return;
}

void AltEnter(void)
{
keybd_event(VK_MENU,
0x38,
0,
0);

keybd_event(VK_RETURN,
0x1c,
0,
0);

keybd_event(VK_RETURN,
0x1c,
KEYEVENTF_KEYUP,
0);

keybd_event(VK_MENU,
0x38,
KEYEVENTF_KEYUP,
0);

return;
}

void DateTime(void)
{
printf("\n");

printf("\n");

printf("\n");

printf(" ");

printf(__DATE__);

printf(" ");

printf(__TIME__);

printf("\n");

printf("\n");

return;
}

void menu(void)
{
system("CLS");

DateTime();

printf("\n\n C HEAD END LINKED LIST TUTORIAL\n\n\n\n");

printf(" 0 EXIT\n\n");

printf(" 1 Execute the linked list example program.\n\n\n");

printf("\n\n Please type your menu selection; for example, 0 to EXIT.\n\n ");

char menuSelection;

menuSelection = getch();

switch(menuSelection)
{
case '0':
break;

case '1':
system("CLS");

DateTime();

printf("\n\n C HEAD END LINKED LIST TUTORIAL\n\n\n\n");

Book *Genesis = NULL;
//last node in list is empty linked list

addBook(&Genesis, "Genesis", 1);

addBook(&Genesis, "Exodus", 2);

addBook(&Genesis, "Leviticus", 3);
addBook(&Genesis, "Numbers", 4);
addBook(&Genesis, "Deuteronomy", 5);

printf(" FIRST FIVE BOOKS OF THE BIBLE\n\n");

while(Genesis)
//while Genesis is not NULL
{
printf(" %d %s\n\n", Genesis->bookOrder, Genesis->bookName);

Genesis = Genesis->nextBook;
}

printf("\n\n Type any key to continue.\n\n ");

char screenOpen;

screenOpen = getch();
//keeps screen open until a key is pressed

menu();

break;
}
}

VI. C "HEAD END" LINKED LIST REFERENCES

The C Programming Language by Brian Kernighan and Dennis Ritchie (Englewood Cliffs, N.J.: Prentice-Hall, 1978).

C++: The Complete Reference, Fourth Edition by Herbert Schildt (Berkeley, California: McGraw-Hill/Osborne, 2003).

YOU HAVE LEARNED:
1. Linked list vocabulary.
2. How to create a “head end” linked list.

Elcric Otto Circle

-->

-->

-->

How to Link to My Home Page

It will appear on your website as:
"Link to ELCRIC OTTO CIRCLE's Home Page"