Struct – My Programming Notes

Tag Archives: Struct

C++ || Snippet – Singly Linked List Custom Template Queue Sample Code

July 14, 2012 admin No comments

This page will consist of sample code for a custom singly linked list template queue. This implementation differs from the previously highlighted doubly linked list in that this version uses a single node to store its data rather than using two separate nodes (front and rear).

Looking for sample code for a stack? Click here.

REQUIRED KNOWLEDGE FOR THIS SNIPPET

Structs Classes Template Classes - What Are They?'' Queue - What is it? FIFO - First In First Out #include < queue> Linked Lists - How To Use

This template class is a custom duplication of the Standard Template Library (STL) queue class. Whether you like building your own data structures, you simply do not like to use any inbuilt functions, opting to build everything yourself, or your homework requires you make your own data structure, this sample code is really useful. I feel its beneficial building functions such as this, that way you better understand the behind the scene processes.





		
		
			#include 'SingleQueue.h'
			
C++
			
			// ============================================================================
//    Author: K Perkins
//    Date:   Jul 14, 2012
//    Taken From: http://programmingnotes.org/
//    File:  SingleQueue.h
//    Description: This is a class which implements various functions
//          demonstrating the use of a queue. 
// ============================================================================
#include <iostream>

template <class ItemType>
class SingleQueue
{
public:
	SingleQueue();
		/*   Function: Constructor initializes queue 
			Precondition: None
			Postcondition: Defines private variables */
	bool IsEmpty();
		/*   Function: Determines whether queue is empty
			Precondition: Queue has been created
			Postcondition: The function = true if the queue is empty and the
							 function = false if queue is not empty */
	bool  IsFull();
		/*   Function: Determines whether queue is full
			Precondition: Queue has been created
			Postcondition: The function = true if the queue is full and the
							 function = false if queue is not full */
	void EnQueue(ItemType item);
		/*   Function: Adds new item to the back of the queue
			Precondition:  Queue has been created and is not full
			Postcondition: Item is in the queue */
	ItemType DeQueue();
		/*   Function: Returns and then deletes the first item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The first item in the queue has been removed and the queue
								order is maintained */
	ItemType Front();
		/*   Function: Returns (but does not delete) the first item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The first item in the queue has been returned and the queue
								order is maintained */
	ItemType Rear();
		/*   Function: Returns (but does not delete) the last item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The last item in the queue has been returned and the queue
								order is maintained */
	int Size();
          /*   Function: Return the current size of the queue
               Precondition: Queue has been initialized
               Postcondition: The size of the queue is returned */ 
	void MakeEmpty();
		/*   Function: Initializes queue to an empty state 
			Precondition: Queue has been created
			Postcondition: Queue no longer exists */
	~SingleQueue();
		/*   Function: Removes the queue 
			Precondition: Queue has been declared
			Postcondition: Queue no longer exists */
private:		
	struct  NodeType	
	{			
		ItemType currentItem;		
		NodeType* next;	
	};
	NodeType* head;	// front of queue 
	int size;
};

//=========================  Implementation  ================================//

template<class ItemType>
SingleQueue<ItemType>::SingleQueue()
{
	head = NULL;
	size = 0;
}/* end of SingleQueue */

template<class ItemType>
bool SingleQueue<ItemType>::IsEmpty()
{
	return (head == NULL);
}/* end of IsEmpty */

template<class ItemType>
bool SingleQueue<ItemType>::IsFull()
{
	try
	{
		NodeType* location = new NodeType;
		delete location;
		return false;
	}
	catch(std::bad_alloc&)
	{
		return true;
	}
}/* end of IsFull */

template<class ItemType>
void SingleQueue<ItemType>::EnQueue(ItemType newItem)
{
	if(IsFull())
	{
		std::cout<<"nQUEUE FULLn";
	}
	else
	{
		NodeType* newNode = new NodeType;  // adds new node
		newNode-> currentItem = newItem;
		newNode-> next = NULL;
	
		if(IsEmpty())
		{
			head = newNode;
		}
		else
		{
			NodeType* tempPtr = head;
			while(tempPtr-> next != NULL)
			{
				tempPtr = tempPtr-> next;
			}
			tempPtr-> next = newNode;
		}
		++size;
	}
}/* end of EnQueue */

template<class ItemType>
ItemType SingleQueue<ItemType>::DeQueue() 
{
    if(IsEmpty())
    {
        std::cout<<"nQUEUE EMPTYn";
    }
    else
    {
        NodeType* tempPtr = head;  // temporary pointer
		
        ItemType item = head-> currentItem;
        head = head-> next;
        delete tempPtr;
        --size;
        return item;
    }	
}/* end of DeQueue */

template<class ItemType>
ItemType SingleQueue<ItemType>::Front() 
{
    if(IsEmpty())
    {
        std::cout<<"nQUEUE EMPTYn";
    }
    else
    {	
        ItemType item = head-> currentItem;
        return item;
    }	
}/* end of Front */

template<class ItemType>
ItemType SingleQueue<ItemType>::Rear() 
{
    if(IsEmpty())
    {
        std::cout<<"nQUEUE EMPTYn";
    }
    else
    {
        NodeType* tempPtr = head;  // temporary pointer

        while(tempPtr->next != NULL)
        {
                tempPtr = tempPtr-> next;
        }
        ItemType item = tempPtr-> currentItem;
        return item;
    }	
}/* end of Rear */

template<class ItemType>
int SingleQueue<ItemType>::Size()
{
    if(IsEmpty())
    {
        std::cout<<"nQUEUE EMPTYn";
    }
    return size;
}/* end of Size */

template<class ItemType>
void SingleQueue<ItemType>::MakeEmpty()
{
    if(!IsEmpty())
    {
        std::cout << "Destroying nodes ...n";
        while(!IsEmpty())
        {
            NodeType* tempPtr = head;
            //std::cout << tempPtr-> currentItem << 'n';
            head = head-> next;
            delete tempPtr;
        }
        size = 0;
    }
}/* end of MakeEmpty */

template<class ItemType>
SingleQueue<ItemType>::~SingleQueue() 
{
	MakeEmpty();
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
				
						// ============================================================================
//    Author: K Perkins
//    Date:   Jul 14, 2012
//    Taken From: http://programmingnotes.org/
//    File:  SingleQueue.h
//    Description: This is a class which implements various functions
//          demonstrating the use of a queue. 
// ============================================================================
#include <iostream>
 
template <class ItemType>
class SingleQueue
{
public:
	SingleQueue();
		/*   Function: Constructor initializes queue 
			Precondition: None
			Postcondition: Defines private variables */
	bool IsEmpty();
		/*   Function: Determines whether queue is empty
			Precondition: Queue has been created
			Postcondition: The function = true if the queue is empty and the
							 function = false if queue is not empty */
	bool  IsFull();
		/*   Function: Determines whether queue is full
			Precondition: Queue has been created
			Postcondition: The function = true if the queue is full and the
							 function = false if queue is not full */
	void EnQueue(ItemType item);
		/*   Function: Adds new item to the back of the queue
			Precondition:  Queue has been created and is not full
			Postcondition: Item is in the queue */
	ItemType DeQueue();
		/*   Function: Returns and then deletes the first item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The first item in the queue has been removed and the queue
								order is maintained */
	ItemType Front();
		/*   Function: Returns (but does not delete) the first item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The first item in the queue has been returned and the queue
								order is maintained */
	ItemType Rear();
		/*   Function: Returns (but does not delete) the last item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The last item in the queue has been returned and the queue
								order is maintained */
	int Size();
          /*   Function: Return the current size of the queue
               Precondition: Queue has been initialized
               Postcondition: The size of the queue is returned */ 
	void MakeEmpty();
		/*   Function: Initializes queue to an empty state 
			Precondition: Queue has been created
			Postcondition: Queue no longer exists */
	~SingleQueue();
		/*   Function: Removes the queue 
			Precondition: Queue has been declared
			Postcondition: Queue no longer exists */
private:		
	struct  NodeType	
	{			
		ItemType currentItem;		
		NodeType* next;	
	};
	NodeType* head;	// front of queue 
	int size;
};
 
//=========================  Implementation  ================================//
 
template<class ItemType>
SingleQueue<ItemType>::SingleQueue()
{
	head = NULL;
	size = 0;
}/* end of SingleQueue */
 
template<class ItemType>
bool SingleQueue<ItemType>::IsEmpty()
{
	return (head == NULL);
}/* end of IsEmpty */
 
template<class ItemType>
bool SingleQueue<ItemType>::IsFull()
{
	try
	{
		NodeType* location = new NodeType;
		delete location;
		return false;
	}
	catch(std::bad_alloc&)
	{
		return true;
	}
}/* end of IsFull */
 
template<class ItemType>
void SingleQueue<ItemType>::EnQueue(ItemType newItem)
{
	if(IsFull())
	{
		std::cout<<"nQUEUE FULLn";
	}
	else
	{
		NodeType* newNode = new NodeType;  // adds new node
		newNode-> currentItem = newItem;
		newNode-> next = NULL;
	
		if(IsEmpty())
		{
			head = newNode;
		}
		else
		{
			NodeType* tempPtr = head;
			while(tempPtr-> next != NULL)
			{
				tempPtr = tempPtr-> next;
			}
			tempPtr-> next = newNode;
		}
		++size;
	}
}/* end of EnQueue */
 
template<class ItemType>
ItemType SingleQueue<ItemType>::DeQueue() 
{
    if(IsEmpty())
    {
        std::cout<<"nQUEUE EMPTYn";
    }
    else
    {
        NodeType* tempPtr = head;  // temporary pointer
		
        ItemType item = head-> currentItem;
        head = head-> next;
        delete tempPtr;
        --size;
        return item;
    }	
}/* end of DeQueue */
 
template<class ItemType>
ItemType SingleQueue<ItemType>::Front() 
{
    if(IsEmpty())
    {
        std::cout<<"nQUEUE EMPTYn";
    }
    else
    {	
        ItemType item = head-> currentItem;
        return item;
    }	
}/* end of Front */
 
template<class ItemType>
ItemType SingleQueue<ItemType>::Rear() 
{
    if(IsEmpty())
    {
        std::cout<<"nQUEUE EMPTYn";
    }
    else
    {
        NodeType* tempPtr = head;  // temporary pointer
 
        while(tempPtr->next != NULL)
        {
                tempPtr = tempPtr-> next;
        }
        ItemType item = tempPtr-> currentItem;
        return item;
    }	
}/* end of Rear */
 
template<class ItemType>
int SingleQueue<ItemType>::Size()
{
    if(IsEmpty())
    {
        std::cout<<"nQUEUE EMPTYn";
    }
    return size;
}/* end of Size */
 
template<class ItemType>
void SingleQueue<ItemType>::MakeEmpty()
{
    if(!IsEmpty())
    {
        std::cout << "Destroying nodes ...n";
        while(!IsEmpty())
        {
            NodeType* tempPtr = head;
            //std::cout << tempPtr-> currentItem << 'n';
            head = head-> next;
            delete tempPtr;
        }
        size = 0;
    }
}/* end of MakeEmpty */
 
template<class ItemType>
SingleQueue<ItemType>::~SingleQueue() 
{
	MakeEmpty();
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

===== DEMONSTRATION HOW TO USE =====

Use of the above template class is the same as its STL counterpart. Here is a sample program demonstrating its use.





		
		
			How To Use #include 'SingleQueue.h'
			
C++
			
			#include <iostream>
#include "SingleQueue.h"
using namespace std;

int main()
{
	// declare variables
	SingleQueue<char> charQueue;
	SingleQueue<int> intQueue;
	SingleQueue<double> doubleQueue;
	
	// ------ Char Example ------//
	char charArry[]="My Programming Notes Is A Big Help!";
	int counter=0;	
	while(charArry[counter]!='\0')
	{
		charQueue.EnQueue(charArry[counter]);
		++counter;
	}
	cout<<"charQueue has "<<charQueue.Size()<<" items in it "
		<<"and contains the text:n";
	while(!charQueue.IsEmpty())
	{
		cout<<charQueue.DeQueue();
	}
	cout<<endl;
	
	// ------ Int Example ------//
	int intArry[]={1,22,309,461,-92,66,7,8,1987,9,27,12};
	counter=0;
	while(counter < sizeof(intArry)/sizeof(intArry[0]))
	{
		intQueue.EnQueue(intArry[counter]);
		++counter;
	}
	cout<<"nintQueue has "<<intQueue.Size()<<" items in it.n"
		<<"The sum of the numbers in the queue is: ";
	counter=0;
	while(!intQueue.IsEmpty())
	{
		counter-=intQueue.DeQueue();
	}
	cout<<counter<<endl;
	
	// ------ Double Example ------//
	double doubleArry[]={31.62,2.8,43.9,4.4,19.87,6.23,7.787,68.99,9.6,3.540,12.04};
	double sum=0;
	counter=0;
	while(counter < sizeof(doubleArry)/sizeof(doubleArry[0]))
	{
		doubleQueue.EnQueue(doubleArry[counter]);
		++counter;
	}
	cout<<"ndoubleQueue has "<<doubleQueue.Size()<<" items in it.n"
		<<"The sum of the numbers in the queue is: ";
	while(!doubleQueue.IsEmpty())
	{
		sum+=doubleQueue.DeQueue();
	}
	cout<<sum<<endl;

	return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
				
						#include <iostream>
#include "SingleQueue.h"
using namespace std;
 
int main()
{
	// declare variables
	SingleQueue<char> charQueue;
	SingleQueue<int> intQueue;
	SingleQueue<double> doubleQueue;
	
	// ------ Char Example ------//
	char charArry[]="My Programming Notes Is A Big Help!";
	int counter=0;	
	while(charArry[counter]!='\0')
	{
		charQueue.EnQueue(charArry[counter]);
		++counter;
	}
	cout<<"charQueue has "<<charQueue.Size()<<" items in it "
		<<"and contains the text:n";
	while(!charQueue.IsEmpty())
	{
		cout<<charQueue.DeQueue();
	}
	cout<<endl;
	
	// ------ Int Example ------//
	int intArry[]={1,22,309,461,-92,66,7,8,1987,9,27,12};
	counter=0;
	while(counter < sizeof(intArry)/sizeof(intArry[0]))
	{
		intQueue.EnQueue(intArry[counter]);
		++counter;
	}
	cout<<"nintQueue has "<<intQueue.Size()<<" items in it.n"
		<<"The sum of the numbers in the queue is: ";
	counter=0;
	while(!intQueue.IsEmpty())
	{
		counter-=intQueue.DeQueue();
	}
	cout<<counter<<endl;
	
	// ------ Double Example ------//
	double doubleArry[]={31.62,2.8,43.9,4.4,19.87,6.23,7.787,68.99,9.6,3.540,12.04};
	double sum=0;
	counter=0;
	while(counter < sizeof(doubleArry)/sizeof(doubleArry[0]))
	{
		doubleQueue.EnQueue(doubleArry[counter]);
		++counter;
	}
	cout<<"ndoubleQueue has "<<doubleQueue.Size()<<" items in it.n"
		<<"The sum of the numbers in the queue is: ";
	while(!doubleQueue.IsEmpty())
	{
		sum+=doubleQueue.DeQueue();
	}
	cout<<sum<<endl;
 
	return 0;
}// http://programmingnotes.org/

Once compiled, you should get this as your output

charQueue has 35 items in it and contains the text: My Programming Notes Is A Big Help!
intQueue has 12 items in it. The sum of the numbers in the queue is: -2817
doubleQueue has 11 items in it. The sum of the numbers in the queue is: 210.777 Press any key to continue . . .

C++ || Snippet – Doubly Linked List Custom Template Queue Sample Code

May 20, 2012 admin No comments

This page will consist of sample code for a custom doubly linked list template queue. This implementation is considered a doubly linked list because it uses two nodes to store data in the queue – a ‘front’ and a ‘rear’ node. This is not a circular linked list, nor does it link forwards and/or backwards.

Looking for sample code for a stack? Click here.

REQUIRED KNOWLEDGE FOR THIS SNIPPET

Structs Classes Template Classes - What Are They? Queue - What is it? FIFO - First In First Out #include < queue> Linked Lists - How To Use





		
		
			#include 'DoubleQueue.h'
			
C++
			
			// ============================================================================
//    Author: K Perkins
//    Date:   May 20, 2012
//    Taken From: http://programmingnotes.org/
//    File:  DoubleQueue.h
//    Description: This is a class which implements various functions
//          demonstrating the use of a queue. 
// ============================================================================
#include <iostream>

template <class ItemType>
class DoubleQueue
{
public:
	DoubleQueue();
		/*   Function: Constructor initializes queue 
			Precondition: None
			Postcondition: Defines private variables */
	bool IsEmpty();
		/*   Function: Determines whether queue is empty
			Precondition: Queue has been created
			Postcondition: The function = true if the queue is empty and the
							 function = false if queue is not empty */
	bool  IsFull();
		/*   Function: Determines whether queue is full
			Precondition: Queue has been created
			Postcondition: The function = true if the queue is full and the
							 function = false if queue is not full */
	void EnQueue(ItemType item);
		/*   Function: Adds new item to the back of the queue
			Precondition:  Queue has been created and is not full
			Postcondition: Item is in the queue */
	ItemType DeQueue();
		/*   Function: Returns and then deletes the first item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The first item in the queue has been removed and the queue
								order is maintained */
	ItemType Front();
		/*   Function: Returns (but does not delete) the first item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The first item in the queue has been returned and the queue
								order is maintained */
	ItemType Rear();
		/*   Function: Returns (but does not delete) the last item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The last item in the queue has been returned and the queue
								order is maintained */
	int Size();
          /*   Function: Return the current size of the queue
               Precondition: Queue has been initialized
               Postcondition: The size of the queue is returned */ 
	void MakeEmpty();
		/*   Function: Initializes queue to an empty state 
			Precondition: Queue has been created
			Postcondition: Queue no longer exists */
	~DoubleQueue();
		/*   Function: Removes the queue 
			Precondition: Queue has been declared
			Postcondition: Queue no longer exists */
private:
	struct  NodeType
	{
		ItemType currentItem;
		NodeType* next;
	};
	NodeType* front;	// front of queue 
	NodeType* rear;		// back of queue
	int size;
};

//=========================  Implementation  ================================//

template<class ItemType>
DoubleQueue<ItemType>::DoubleQueue()
{
	front = NULL;
	rear = NULL;
	size = 0;
}/* end of DoubleQueue */

template<class ItemType>
bool DoubleQueue<ItemType>::IsEmpty()
{
	return (front == NULL);
}/* end of IsEmpty */

template<class ItemType>
bool DoubleQueue<ItemType>::IsFull()
{	
	try
	{
		NodeType* location = new NodeType;
		delete location;
		return false;
	}
	catch(std::bad_alloc&)
	{
		return true;
	}
}/* end of IsFull */

template<class ItemType>
void DoubleQueue<ItemType>::EnQueue(ItemType newItem)
{
	if(IsFull())
	{
		std::cout<<"nQUEUE FULLn";
	}
	else
	{
		NodeType* newNode = new NodeType; // adds new node
		newNode-> currentItem = newItem;
		newNode-> next = NULL;
	
		if(rear == NULL)
		{
			front = newNode;
		}
		else
		{
			rear-> next = newNode;			
		}
		rear = newNode;
		++size;
	}
}/* end of EnQueue */

template<class ItemType>
ItemType DoubleQueue<ItemType>::DeQueue() 
{
	if(IsEmpty())
	{
		std::cout<<"nQUEUE EMPTYn";
	}
	else
	{
		NodeType* tempPtr = front; // temporary pointer
		
		ItemType item = front-> currentItem;
		front = front-> next;

		if(front == NULL)
		{
			rear = NULL;
		}
		delete tempPtr;
		--size;
		return item;
	}	
}/* end of DeQueue */

template<class ItemType>
ItemType DoubleQueue<ItemType>::Front() 
{
	if(IsEmpty())
	{
		std::cout<<"nQUEUE EMPTYn";
	}
	else
	{
		return front-> currentItem;
	}	
}/* end of Front */

template<class ItemType>
ItemType DoubleQueue<ItemType>::Rear() 
{
	if(IsEmpty())
	{
		std::cout<<"nQUEUE EMPTYn";
	}
	else
	{		
		return rear-> currentItem;
	}	
}/* end of Rear */

template<class ItemType>
int DoubleQueue<ItemType>::Size()
{
	if(IsEmpty())
	{
		std::cout<<"nQUEUE EMPTYn";
	}
	return size;
}/* end of Size */

template<class ItemType>
void DoubleQueue<ItemType>::MakeEmpty()
{
	if(!IsEmpty())
	{
		std::cout << "Destroying nodes ...n";
		while(!IsEmpty())
		{
			NodeType* tempPtr = front;
			//std::cout << tempPtr-> currentItem << 'n';
			front = front-> next;
			delete tempPtr;
		}
		rear = NULL;
		size = 0;
	}
}/* end of MakeEmpty */

template<class ItemType>
DoubleQueue<ItemType>::~DoubleQueue() 
{
	MakeEmpty();
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
				
						// ============================================================================
//    Author: K Perkins
//    Date:   May 20, 2012
//    Taken From: http://programmingnotes.org/
//    File:  DoubleQueue.h
//    Description: This is a class which implements various functions
//          demonstrating the use of a queue. 
// ============================================================================
#include <iostream>
 
template <class ItemType>
class DoubleQueue
{
public:
	DoubleQueue();
		/*   Function: Constructor initializes queue 
			Precondition: None
			Postcondition: Defines private variables */
	bool IsEmpty();
		/*   Function: Determines whether queue is empty
			Precondition: Queue has been created
			Postcondition: The function = true if the queue is empty and the
							 function = false if queue is not empty */
	bool  IsFull();
		/*   Function: Determines whether queue is full
			Precondition: Queue has been created
			Postcondition: The function = true if the queue is full and the
							 function = false if queue is not full */
	void EnQueue(ItemType item);
		/*   Function: Adds new item to the back of the queue
			Precondition:  Queue has been created and is not full
			Postcondition: Item is in the queue */
	ItemType DeQueue();
		/*   Function: Returns and then deletes the first item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The first item in the queue has been removed and the queue
								order is maintained */
	ItemType Front();
		/*   Function: Returns (but does not delete) the first item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The first item in the queue has been returned and the queue
								order is maintained */
	ItemType Rear();
		/*   Function: Returns (but does not delete) the last item in the queue
			Precondition:  Queue has been created and is not empty
			Postcondition: The last item in the queue has been returned and the queue
								order is maintained */
	int Size();
          /*   Function: Return the current size of the queue
               Precondition: Queue has been initialized
               Postcondition: The size of the queue is returned */ 
	void MakeEmpty();
		/*   Function: Initializes queue to an empty state 
			Precondition: Queue has been created
			Postcondition: Queue no longer exists */
	~DoubleQueue();
		/*   Function: Removes the queue 
			Precondition: Queue has been declared
			Postcondition: Queue no longer exists */
private:
	struct  NodeType
	{
		ItemType currentItem;
		NodeType* next;
	};
	NodeType* front;	// front of queue 
	NodeType* rear;		// back of queue
	int size;
};
 
//=========================  Implementation  ================================//
 
template<class ItemType>
DoubleQueue<ItemType>::DoubleQueue()
{
	front = NULL;
	rear = NULL;
	size = 0;
}/* end of DoubleQueue */
 
template<class ItemType>
bool DoubleQueue<ItemType>::IsEmpty()
{
	return (front == NULL);
}/* end of IsEmpty */
 
template<class ItemType>
bool DoubleQueue<ItemType>::IsFull()
{	
	try
	{
		NodeType* location = new NodeType;
		delete location;
		return false;
	}
	catch(std::bad_alloc&)
	{
		return true;
	}
}/* end of IsFull */
 
template<class ItemType>
void DoubleQueue<ItemType>::EnQueue(ItemType newItem)
{
	if(IsFull())
	{
		std::cout<<"nQUEUE FULLn";
	}
	else
	{
		NodeType* newNode = new NodeType; // adds new node
		newNode-> currentItem = newItem;
		newNode-> next = NULL;
	
		if(rear == NULL)
		{
			front = newNode;
		}
		else
		{
			rear-> next = newNode;			
		}
		rear = newNode;
		++size;
	}
}/* end of EnQueue */
 
template<class ItemType>
ItemType DoubleQueue<ItemType>::DeQueue() 
{
	if(IsEmpty())
	{
		std::cout<<"nQUEUE EMPTYn";
	}
	else
	{
		NodeType* tempPtr = front; // temporary pointer
		
		ItemType item = front-> currentItem;
		front = front-> next;
 
		if(front == NULL)
		{
			rear = NULL;
		}
		delete tempPtr;
		--size;
		return item;
	}	
}/* end of DeQueue */
 
template<class ItemType>
ItemType DoubleQueue<ItemType>::Front() 
{
	if(IsEmpty())
	{
		std::cout<<"nQUEUE EMPTYn";
	}
	else
	{
		return front-> currentItem;
	}	
}/* end of Front */
 
template<class ItemType>
ItemType DoubleQueue<ItemType>::Rear() 
{
	if(IsEmpty())
	{
		std::cout<<"nQUEUE EMPTYn";
	}
	else
	{		
		return rear-> currentItem;
	}	
}/* end of Rear */
 
template<class ItemType>
int DoubleQueue<ItemType>::Size()
{
	if(IsEmpty())
	{
		std::cout<<"nQUEUE EMPTYn";
	}
	return size;
}/* end of Size */
 
template<class ItemType>
void DoubleQueue<ItemType>::MakeEmpty()
{
	if(!IsEmpty())
	{
		std::cout << "Destroying nodes ...n";
		while(!IsEmpty())
		{
			NodeType* tempPtr = front;
			//std::cout << tempPtr-> currentItem << 'n';
			front = front-> next;
			delete tempPtr;
		}
		rear = NULL;
		size = 0;
	}
}/* end of MakeEmpty */
 
template<class ItemType>
DoubleQueue<ItemType>::~DoubleQueue() 
{
	MakeEmpty();
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

===== DEMONSTRATION HOW TO USE =====

Use of the above template class is the same as its STL counterpart. Here is a sample program demonstrating its use.





		
		
			How To Use #include 'DoubleQueue.h'
			
C++
			
			#include <iostream>
#include "DoubleQueue.h"
using namespace std;

int main()
{
	// declare variables
	DoubleQueue<char> charQueue;
	DoubleQueue<int> intQueue;
	DoubleQueue<float> floatQueue;
	
	// ------ Char Example ------//
	char charArry[]="My Programming Notes Helped Me Succeed!";
	int counter=0;	
	while(charArry[counter]!='\0')
	{
		charQueue.EnQueue(charArry[counter]);
		++counter;
	}
	cout<<"charQueue has "<<charQueue.Size()<<" items in it "
		<<"and contains the text:n";
	while(!charQueue.IsEmpty())
	{
		cout<<charQueue.DeQueue();
	}
	cout<<endl;
	
	// ------ Int Example ------//
	int intArry[]={1,22,3,46,5,66,7,8,1987};
	counter=0;
	while(counter<9)
	{
		intQueue.EnQueue(intArry[counter]);
		++counter;
	}
	cout<<"nintQueue has "<<intQueue.Size()<<" items in it.n"
		<<"The sum of the numbers in the queue is: ";
	counter=0;
	while(!intQueue.IsEmpty())
	{
		counter-=intQueue.DeQueue();
	}
	cout<<counter<<endl;
	
	// ------ Float Example ------//
	float floatArry[]={41.6,2.8,43.9,4.4,19.87,6.23,7.787,68.99,9.6,81.540};
	float sum=0;
	counter=0;
	while(counter<10)
	{
		floatQueue.EnQueue(floatArry[counter]);
		++counter;
	}
	cout<<"nfloatQueue has "<<floatQueue.Size()<<" items in it.n"
		<<"The sum of the numbers in the queue is: ";
	while(!floatQueue.IsEmpty())
	{
		sum-=floatQueue.DeQueue();
	}
	cout<<sum<<endl;

	return 0;
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
				
						#include <iostream>
#include "DoubleQueue.h"
using namespace std;
 
int main()
{
	// declare variables
	DoubleQueue<char> charQueue;
	DoubleQueue<int> intQueue;
	DoubleQueue<float> floatQueue;
	
	// ------ Char Example ------//
	char charArry[]="My Programming Notes Helped Me Succeed!";
	int counter=0;	
	while(charArry[counter]!='\0')
	{
		charQueue.EnQueue(charArry[counter]);
		++counter;
	}
	cout<<"charQueue has "<<charQueue.Size()<<" items in it "
		<<"and contains the text:n";
	while(!charQueue.IsEmpty())
	{
		cout<<charQueue.DeQueue();
	}
	cout<<endl;
	
	// ------ Int Example ------//
	int intArry[]={1,22,3,46,5,66,7,8,1987};
	counter=0;
	while(counter<9)
	{
		intQueue.EnQueue(intArry[counter]);
		++counter;
	}
	cout<<"nintQueue has "<<intQueue.Size()<<" items in it.n"
		<<"The sum of the numbers in the queue is: ";
	counter=0;
	while(!intQueue.IsEmpty())
	{
		counter-=intQueue.DeQueue();
	}
	cout<<counter<<endl;
	
	// ------ Float Example ------//
	float floatArry[]={41.6,2.8,43.9,4.4,19.87,6.23,7.787,68.99,9.6,81.540};
	float sum=0;
	counter=0;
	while(counter<10)
	{
		floatQueue.EnQueue(floatArry[counter]);
		++counter;
	}
	cout<<"nfloatQueue has "<<floatQueue.Size()<<" items in it.n"
		<<"The sum of the numbers in the queue is: ";
	while(!floatQueue.IsEmpty())
	{
		sum-=floatQueue.DeQueue();
	}
	cout<<sum<<endl;
 
	return 0;
}// http://programmingnotes.org/

Once compiled, you should get this as your output

charQueue has 39 items in it and contains the text: My Programming Notes Helped Me Succeed!
intQueue has 9 items in it. The sum of the numbers in the queue is: -2145
floatQueue has 10 items in it. The sum of the numbers in the queue is: -286.717

C++ || Snippet – Linked List Custom Template Stack Sample Code

April 09, 2012 admin No comments

This page will consist of sample code for a custom linked list template stack. This page differs from the previously highlighted array based template stack in that this version uses a singly linked list to store data rather than using an array.

Looking for sample code for a queue? Click here.

REQUIRED KNOWLEDGE FOR THIS SNIPPET

Structs Classes Template Classes - What Are They? Stacks LIFO - What Is It? #include < stack> Linked Lists - How To Use

This template class is a custom duplication of the Standard Template Library (STL) stack class. Whether you like building your own data structures, you simply do not like to use any inbuilt functions, opting to build everything yourself, or your homework requires you make your own data structure, this sample code is really useful. I feel its beneficial building functions such as this, that way you better understand the behind the scene processes.





		
		
			#include 'ClassStackListType.h'
			
C++
			
			// ============================================================================
//    Author: K Perkins
//    Date:   Apr 9, 2012
//    Taken From: http://programmingnotes.org/
//    File:  ClassStackListType.h
//    Description: This is a class which implements various functions
//          demonstrating the use of a stack. 
// ============================================================================
#include <iostream>         

template <class ItemType>
class StackListType
{
public:
    StackListType();
          /*   Function: constructor initializes class variables 
               Precondition: none
               Postcondition: defines private variables */
    bool IsEmpty();
          /*   Function: Determines whether the stack is empty
               Precondition: Stack has been initialized
               Postcondition: Function value = (stack is empty) */
    bool IsFull();
          /*   Function: Determines whether the stack is full
               Precondition: Stack has been initialized
               Postcondition: Function value = (stack is full) */
    int Size();
          /*   Function: Return the current size of the stack
               Precondition: Stack has been initialized
               Postcondition: If (stack is full) exception FullStack is thrown
                                   else newItem is at the top of the stack */
    void MakeEmpty();
          /*   Function: Empties the stack
               Precondition: Stack has been initialized
               Postcondition: Stack is empty */
    void Push(ItemType newItem);
          /*   Function: Adds newItem to the top of the stack
               Precondition: Stack has been initialized
               Postcondition: If (stack is full) exception FullStack is thrown
                                   else newItem is at the top of the stack */
    ItemType Pop();
          /*   Function: Returns & then removes top item from the stack
               Precondition: Stack has been initialized
               Postcondition: If (stack is empty) exception EmptyStack is thrown
                                   else top element has been removed from the stack */
    ItemType Top();
          /*   Function: Returns the top item from the stack
               Precondition: Stack has been initialized
               Postcondition: If (stack is empty) exception EmptyStack is thrown
                                   else top element has been removed from the stack */
    ~StackListType();
          /*   Function: destructor deallocates class variables 
               Precondition: none
               Postcondition: deallocates private variables */

private:
    struct NodeType
    {
          ItemType currentItem;  // Variable which hold all the incoming currentItem
          NodeType* next; // Creates a pointer that points to the next node in the list.
    };
    int size;          // Indicates the size of the stack	
    ItemType junk;
    NodeType* headPtr; // Creates a head pointer that will point to the begining of the list.
};

//=========================  Implementation  ================================//

template<class ItemType>
StackListType<ItemType>::StackListType()
{
    size = 0;
    headPtr = NULL;
}//     End of StackListType

template<class ItemType>
bool StackListType<ItemType>::IsEmpty()
{
    return (headPtr == NULL);
}//     End of IsEmpty

template<class ItemType>
bool StackListType<ItemType>::IsFull()
{    
    try
    {
        NodeType* tempPtr = new NodeType;
        delete tempPtr;
        return false;
    }
    catch(std::bad_alloc&)
    {
        return true;
    }
}//     End of IsFull

template<class ItemType>
int StackListType<ItemType>::Size()
{
    if(IsEmpty())
    {
        std::cout<<"nSTACK EMPTYn";
    }
    return size;
}//     End of Size

template<class ItemType>
void StackListType<ItemType>::MakeEmpty()
{
    size = 0;    
	
    if (!IsEmpty())
	{
        std::cout << "Destroying nodes ...n";

		while (!IsEmpty())
		{
			NodeType* tempPtr = headPtr;
			//std::cout << tempPtr-> currentItem << 'n';
			headPtr = headPtr-> next;
			delete tempPtr;
		}
	}     
}//     End of MakeEmpty

template<class ItemType>
void StackListType<ItemType>::Push(ItemType newItem)
{
    if(IsFull())
    {
        std::cout<<"nSTACK FULLn";
        return;
    }
    NodeType* tempPtr = new NodeType;
    tempPtr-> currentItem = newItem;
    tempPtr-> next = headPtr;
    headPtr = tempPtr;
    ++size;
}//     End of Push

template<class ItemType>
ItemType StackListType<ItemType>::Pop()
{
    if(IsEmpty())
    {
        std::cout<<"nSTACK EMPTYn";
        return junk;
    }
    else
    {  
        ItemType data = headPtr-> currentItem;  
        NodeType* tempPtr = headPtr;
        headPtr = headPtr-> next;
        delete tempPtr;
        --size;
        return data;
    }
}//     End of Pop

template<class ItemType>
ItemType StackListType<ItemType>::Top()
{
    if(IsEmpty())
    {
        std::cout<<"nSTACK EMPTYn";
        return junk;
    }
    else
    { 
        return headPtr-> currentItem;
    }
}//     End of Top

template<class ItemType>
StackListType<ItemType>::~StackListType()
{
    MakeEmpty();   
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
				
						// ============================================================================
//    Author: K Perkins
//    Date:   Apr 9, 2012
//    Taken From: http://programmingnotes.org/
//    File:  ClassStackListType.h
//    Description: This is a class which implements various functions
//          demonstrating the use of a stack. 
// ============================================================================
#include <iostream>         
 
template <class ItemType>
class StackListType
{
public:
    StackListType();
          /*   Function: constructor initializes class variables 
               Precondition: none
               Postcondition: defines private variables */
    bool IsEmpty();
          /*   Function: Determines whether the stack is empty
               Precondition: Stack has been initialized
               Postcondition: Function value = (stack is empty) */
    bool IsFull();
          /*   Function: Determines whether the stack is full
               Precondition: Stack has been initialized
               Postcondition: Function value = (stack is full) */
    int Size();
          /*   Function: Return the current size of the stack
               Precondition: Stack has been initialized
               Postcondition: If (stack is full) exception FullStack is thrown
                                   else newItem is at the top of the stack */
    void MakeEmpty();
          /*   Function: Empties the stack
               Precondition: Stack has been initialized
               Postcondition: Stack is empty */
    void Push(ItemType newItem);
          /*   Function: Adds newItem to the top of the stack
               Precondition: Stack has been initialized
               Postcondition: If (stack is full) exception FullStack is thrown
                                   else newItem is at the top of the stack */
    ItemType Pop();
          /*   Function: Returns & then removes top item from the stack
               Precondition: Stack has been initialized
               Postcondition: If (stack is empty) exception EmptyStack is thrown
                                   else top element has been removed from the stack */
    ItemType Top();
          /*   Function: Returns the top item from the stack
               Precondition: Stack has been initialized
               Postcondition: If (stack is empty) exception EmptyStack is thrown
                                   else top element has been removed from the stack */
    ~StackListType();
          /*   Function: destructor deallocates class variables 
               Precondition: none
               Postcondition: deallocates private variables */
 
private:
    struct NodeType
    {
          ItemType currentItem;  // Variable which hold all the incoming currentItem
          NodeType* next; // Creates a pointer that points to the next node in the list.
    };
    int size;          // Indicates the size of the stack	
    ItemType junk;
    NodeType* headPtr; // Creates a head pointer that will point to the begining of the list.
};
 
//=========================  Implementation  ================================//
 
template<class ItemType>
StackListType<ItemType>::StackListType()
{
    size = 0;
    headPtr = NULL;
}//     End of StackListType
 
template<class ItemType>
bool StackListType<ItemType>::IsEmpty()
{
    return (headPtr == NULL);
}//     End of IsEmpty
 
template<class ItemType>
bool StackListType<ItemType>::IsFull()
{    
    try
    {
        NodeType* tempPtr = new NodeType;
        delete tempPtr;
        return false;
    }
    catch(std::bad_alloc&)
    {
        return true;
    }
}//     End of IsFull
 
template<class ItemType>
int StackListType<ItemType>::Size()
{
    if(IsEmpty())
    {
        std::cout<<"nSTACK EMPTYn";
    }
    return size;
}//     End of Size
 
template<class ItemType>
void StackListType<ItemType>::MakeEmpty()
{
    size = 0;    
	
    if (!IsEmpty())
	{
        std::cout << "Destroying nodes ...n";
 
		while (!IsEmpty())
		{
			NodeType* tempPtr = headPtr;
			//std::cout << tempPtr-> currentItem << 'n';
			headPtr = headPtr-> next;
			delete tempPtr;
		}
	}     
}//     End of MakeEmpty
 
template<class ItemType>
void StackListType<ItemType>::Push(ItemType newItem)
{
    if(IsFull())
    {
        std::cout<<"nSTACK FULLn";
        return;
    }
    NodeType* tempPtr = new NodeType;
    tempPtr-> currentItem = newItem;
    tempPtr-> next = headPtr;
    headPtr = tempPtr;
    ++size;
}//     End of Push
 
template<class ItemType>
ItemType StackListType<ItemType>::Pop()
{
    if(IsEmpty())
    {
        std::cout<<"nSTACK EMPTYn";
        return junk;
    }
    else
    {  
        ItemType data = headPtr-> currentItem;  
        NodeType* tempPtr = headPtr;
        headPtr = headPtr-> next;
        delete tempPtr;
        --size;
        return data;
    }
}//     End of Pop
 
template<class ItemType>
ItemType StackListType<ItemType>::Top()
{
    if(IsEmpty())
    {
        std::cout<<"nSTACK EMPTYn";
        return junk;
    }
    else
    { 
        return headPtr-> currentItem;
    }
}//     End of Top
 
template<class ItemType>
StackListType<ItemType>::~StackListType()
{
    MakeEmpty();   
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

===== DEMONSTRATION HOW TO USE =====

Use of the above template class is the same as its STL counterpart. Here is a sample program demonstrating its use.





		
		
			How To Use #include 'ClassStackListType.h'
			
C++
			
			#include <iostream>
#include "ClassStackListType.h"
using namespace std;

int  main()
{    // declare variables
     StackListType<char> charStack;
     StackListType<int> intStack;
     StackListType<float> floatStack;
     
     // ------ Char Example ------//
     char charArry[]="My Programming Notes Is Awesome";
     int counter=0;
     while(charArry[counter]!='\0')
     {
          charStack.Push(charArry[counter]);
          ++counter;
     }
     cout<<"charStack has "<<charStack.Size()<<" items in itn"
     <<"and contains the text ""<<charArry<<"" backwards:n";
     while(!charStack.IsEmpty())
     {
          cout<<charStack.Pop();
     }
     cout<<endl;     
     
     // ------ Int Example ------//
     int intArry[]={1,22,3,46,5,66,7,8,1987};
     counter=0;
     while(counter<9)
     {
          intStack.Push(intArry[counter]);
          ++counter;
     }
     cout<<"nintStack has "<<intStack.Size()<<" items in it.n"
     <<"The sum of the numbers in the stack is: ";
     counter=0;
     while(!intStack.IsEmpty())
     {
          counter+=intStack.Pop();
     }
     cout<<counter<<endl;
     
     // ------ Float Example ------//
     float floatArry[]={41.6,2.8,43.9,4.4,19.87,6.23,7.787,68.99,9.6,81.540};
     float sum=0;
     counter=0;
     while(counter<10)
     {
          floatStack.Push(floatArry[counter]);
          ++counter;
     }
     cout<<"nfloatStack has "<<floatStack.Size()<<" items in it.n"
     <<"The sum of the numbers in the stack is: ";
     while(!floatStack.IsEmpty())
     {
          sum+=floatStack.Pop();
     }
     cout<<sum<<endl;     
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
				
						#include <iostream>
#include "ClassStackListType.h"
using namespace std;
 
int  main()
{    // declare variables
     StackListType<char> charStack;
     StackListType<int> intStack;
     StackListType<float> floatStack;
     
     // ------ Char Example ------//
     char charArry[]="My Programming Notes Is Awesome";
     int counter=0;
     while(charArry[counter]!='\0')
     {
          charStack.Push(charArry[counter]);
          ++counter;
     }
     cout<<"charStack has "<<charStack.Size()<<" items in itn"
     <<"and contains the text ""<<charArry<<"" backwards:n";
     while(!charStack.IsEmpty())
     {
          cout<<charStack.Pop();
     }
     cout<<endl;     
     
     // ------ Int Example ------//
     int intArry[]={1,22,3,46,5,66,7,8,1987};
     counter=0;
     while(counter<9)
     {
          intStack.Push(intArry[counter]);
          ++counter;
     }
     cout<<"nintStack has "<<intStack.Size()<<" items in it.n"
     <<"The sum of the numbers in the stack is: ";
     counter=0;
     while(!intStack.IsEmpty())
     {
          counter+=intStack.Pop();
     }
     cout<<counter<<endl;
     
     // ------ Float Example ------//
     float floatArry[]={41.6,2.8,43.9,4.4,19.87,6.23,7.787,68.99,9.6,81.540};
     float sum=0;
     counter=0;
     while(counter<10)
     {
          floatStack.Push(floatArry[counter]);
          ++counter;
     }
     cout<<"nfloatStack has "<<floatStack.Size()<<" items in it.n"
     <<"The sum of the numbers in the stack is: ";
     while(!floatStack.IsEmpty())
     {
          sum+=floatStack.Pop();
     }
     cout<<sum<<endl;     
}// http://programmingnotes.org/

Once compiled, you should get this as your output

charStack has 31 items in it and contains the text "My Programming Notes Is Awesome" backwards: emosewA sI setoN gnimmargorP yM
intStack has 9 items in it. The sum of the numbers in the stack is: 2145
floatStack has 10 items in it. The sum of the numbers in the stack is: 286.717

C++ || Struct – Add One Day To Today’s Date Using A Struct

January 18, 2012 admin No comments

This program displays more practice using the structure data type, and is very similar to another program which was previously discussed here.

REQUIRED KNOWLEDGE FOR THIS PROGRAM

Functions Passing a Value By Reference Integer Arrays Structures Constant Variables Boolean Expressions

This program utilizes a struct, which is very similar to the class concept. This program first prompts the user to enter the current date in mm/dd/yyyy format. Upon obtaining the date from the user, the program then uses a struct implementation to simply add one day to the date which was entered by the user. If the day that was entered into the program by the user falls on the end of the month, the program will”roll over” the incremented date into the next month. If the user enters 12/31/2012, the program will “roll over” the incremented date into the next calendar year.

NOTE: On some compilers, you may have to add #include < cstdlib> in order for the code to compile.





		
		
			Whats Today's Date?
			
C++
			
			#include <iostream> 
using namespace std;

// struct declaration
struct Date
{
	int month;
	int day;
	int year;
};

// constants which do not change
// specifies the max values for each variable
const int MAX_DAYS = 31;
const int MAX_MONTHS = 12; 

// function prototypes
bool IsDateValid(Date dateVal);
void CalcNextDay(Date &dateVal);

int main()
{
	// initialize the structure: month, day, year
	Date dateVal = {1,18,2012};
	char backSlash = '/'; // this is a 'placeholder' variable
	
	// obtain information from user
	cout << "Please enter today's date in mm/dd/yyyy format: ";
	cin >> dateVal.month >> backSlash >> dateVal.day >> backSlash >> dateVal.year;
	
	// Checks to see if user entered valid data
	if (IsDateValid(dateVal) == false)
	{
		cout << "Invalid input...nProgram exiting...." << endl;
		exit(EXIT_FAILURE);
	} 
	
	// function declaration which calculates the next day
	CalcNextDay(dateVal);

	// display updated data to user
	cout << "The next day is " << dateVal.month << "/" << dateVal.day << "/" << dateVal.year <<endl; 
	
	return 0;
}// end of main

	// this function checks to see if the user inputted valid data
bool IsDateValid(Date dateVal)
{
     // checks to see if user inputted data falls between the specified
     // const variables as declared above
     if ((dateVal.day >= 1 && dateVal.day <= MAX_DAYS)
          &&(dateVal.month >= 1 && dateVal.month <= MAX_MONTHS))
     {
          return true;
     }
     else
     {
          return false;
     }
}// end of IsDateValid 

	// this calculates the next day & updates values via reference
void CalcNextDay(Date &dateVal)
{
	// int array which holds the max date each month has
	// from January to December
	int maxDays[12]={31,28,31,30,31,30,31,31,30,31,30,31};
	
	// bool which lets the program know if the month the
	// user entered is a max month for the specific month
	// the user inputted
	bool maxDay = false;
	
	// checks to see if user inputted day is a max date from the 
	// above array for the currently selected month which 
	// was entered by the user
	if(dateVal.day == maxDays[dateVal.month-1])
	{
		dateVal.day = 1;
		++dateVal.month;
		maxDay = true;
	}

	// checks to see if user inputted a valid date
	// for the currently selected month
	else if (dateVal.day > maxDays[dateVal.month-1])
	{
		cout << "Invalid day input - There is no such date for the selected month.nProgram exiting...." << endl;
		exit(EXIT_FAILURE);
	} 

	// if user didnt enter a max date, and the date is valid, increment the day
	else
	{
		++dateVal.day;
	}

	// if the date is 12/31/yyyy
	// increment to the next year
	if ((dateVal.month > 12)  && maxDay == true)
	{
		dateVal.month = 1;
		++dateVal.year;
	}
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
				
						#include <iostream> 
using namespace std;
 
// struct declaration
struct Date
{
	int month;
	int day;
	int year;
};
 
// constants which do not change
// specifies the max values for each variable
const int MAX_DAYS = 31;
const int MAX_MONTHS = 12; 
 
// function prototypes
bool IsDateValid(Date dateVal);
void CalcNextDay(Date &dateVal);
 
int main()
{
	// initialize the structure: month, day, year
	Date dateVal = {1,18,2012};
	char backSlash = '/'; // this is a 'placeholder' variable
	
	// obtain information from user
	cout << "Please enter today's date in mm/dd/yyyy format: ";
	cin >> dateVal.month >> backSlash >> dateVal.day >> backSlash >> dateVal.year;
	
	// Checks to see if user entered valid data
	if (IsDateValid(dateVal) == false)
	{
		cout << "Invalid input...nProgram exiting...." << endl;
		exit(EXIT_FAILURE);
	} 
	
	// function declaration which calculates the next day
	CalcNextDay(dateVal);
 
	// display updated data to user
	cout << "The next day is " << dateVal.month << "/" << dateVal.day << "/" << dateVal.year <<endl; 
	
	return 0;
}// end of main
 
	// this function checks to see if the user inputted valid data
bool IsDateValid(Date dateVal)
{
     // checks to see if user inputted data falls between the specified
     // const variables as declared above
     if ((dateVal.day >= 1 && dateVal.day <= MAX_DAYS)
          &&(dateVal.month >= 1 && dateVal.month <= MAX_MONTHS))
     {
          return true;
     }
     else
     {
          return false;
     }
}// end of IsDateValid 
 
	// this calculates the next day & updates values via reference
void CalcNextDay(Date &dateVal)
{
	// int array which holds the max date each month has
	// from January to December
	int maxDays[12]={31,28,31,30,31,30,31,31,30,31,30,31};
	
	// bool which lets the program know if the month the
	// user entered is a max month for the specific month
	// the user inputted
	bool maxDay = false;
	
	// checks to see if user inputted day is a max date from the 
	// above array for the currently selected month which 
	// was entered by the user
	if(dateVal.day == maxDays[dateVal.month-1])
	{
		dateVal.day = 1;
		++dateVal.month;
		maxDay = true;
	}
 
	// checks to see if user inputted a valid date
	// for the currently selected month
	else if (dateVal.day > maxDays[dateVal.month-1])
	{
		cout << "Invalid day input - There is no such date for the selected month.nProgram exiting...." << endl;
		exit(EXIT_FAILURE);
	} 
 
	// if user didnt enter a max date, and the date is valid, increment the day
	else
	{
		++dateVal.day;
	}
 
	// if the date is 12/31/yyyy
	// increment to the next year
	if ((dateVal.month > 12)  && maxDay == true)
	{
		dateVal.month = 1;
		++dateVal.year;
	}
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Once compiled, you should get this as your output:
Note: The code was compiled 6 separate times to display the different outputs its able to produce

Please enter today's date in mm/dd/yyyy format: 1/18/2012 The next day is 1/19/2012 -------------------------------------------------------------------
Please enter today's date in mm/dd/yyyy format: 7/31/2012 The next day is 8/1/2012 ------------------------------------------------------------------- Please enter today's date in mm/dd/yyyy format: 2/28/2012 The next day is 3/1/2012 ------------------------------------------------------------------- Please enter today's date in mm/dd/yyyy format: 13/5/2012 Invalid input... Program exiting.... ------------------------------------------------------------------- Please enter today's date in mm/dd/yyyy format: 2/31/2012 Invalid day input - There is no such date for the selected month. Program exiting.... -------------------------------------------------------------------
Please enter today's date in mm/dd/yyyy format: 12/31/2012 The next day is 1/1/2013

C++ || Struct – Add One Second To The Clock Using A Struct

January 08, 2012 admin No comments

Here is another actual homework assignment which was presented in an intro to programming class. This program utilizes a struct, which is very similar to the class concept. For this assignment, the class was asked to make a program which prompted the user to enter a time in HH:MM:SS (Hours:Minutes:Seconds) format. Upon obtaining the time from the user, our class was asked to use a struct implementation which was to simply add one second to the time that was entered by the user. Seems easy enough, though I initially had afew problems when starting the program.

This page will be very brief in its breakdown of the program’s code, as it is already heavily commented. The code is basically unchanged from the code which was turned in for grading.

REQUIRED KNOWLEDGE FOR THIS PROGRAM

Functions Passing a Value By Reference Structures Constant Variables Boolean Expressions Setw

NOTE: On some compilers, you may have to add #include < cstdlib> in order for the code to compile.





		
		
			AddOneSecond.cpp
			
C++
			
			// ============================================================================
// File: AddOneSecond.cpp
// ============================================================================
// Description:
// This program prompts the user for the input time, then adds
// one second to the time -- if any of the time structure fields need to 
// "rollover" (e.g., the hours, minutes or seconds need to be reset to zero), 
// this function will handle that. Finally, the incremented time will be 
// displayed to stdout.
// ============================================================================
#include <iostream>
#include <iomanip>
using namespace std;

// structure declaration
struct Time
{
	int hours;
	int min;
	int sec;
};

// defined constants which do not change
// specifies the max values for each variable
const   int MAX_HOURS = 23;
const   int MAX_MINS = 59;
const   int MAX_SECS = 59;

// function prototypes
bool  IsTimeValid(Time  timeParam);
void  AddOneSecond(Time  &timeParam);
void  DisplayTime(Time  timeParam);

// ==== main ==================================================================
//
// ============================================================================
int main()
{
	Time userTime = {0,0,0}; // Initialize struct members: hrs, min, sec to 0
	char colon = ':';
	
	cout << "Please enter the time in HH:MM:SS format: ";
	cin >> userTime.hours >> colon >> userTime.min >> colon >> userTime.sec;

	// Checks to see if user entered correct data
	if (IsTimeValid(userTime) == false)
	{
       cout << "Invalid input...n" << endl;
       exit(EXIT_FAILURE);
	}

	cout << "nThe incremented time is ";
    AddOneSecond(userTime);
    DisplayTime(userTime);

	return 0;
}	// end of main

// ==== IsTimeValid ===========================================================
//
// This function will validate that the time structure contains legitimate 
// values. If this function determines that the time values are invalid, it 
// will display an error message to stdout.
// 
// Input:
//      limit [IN]  -- The users time input 
//			
// Output:
//      The Time structure as an argument to the AddOneSecond function
//
// ============================================================================
bool  IsTimeValid(Time  timeParam)
{
	// checks to see if user inputted data falls between the specified
	// const variables as declared above
	if ((timeParam.hours >= 0 && timeParam.hours <= MAX_HOURS)
		&&(timeParam.min >= 0 && timeParam.min <= MAX_MINS)
		&&(timeParam.sec >= 0 && timeParam.sec <= MAX_SECS))
	{
		return true;
	}
	else
	{
		return false;
	}
}	// end of IsTimeValid

// ==== AddOneSecond ==========================================================
//
// This function will add one second to the time
// 
// Input:
//      limit [IN]  -- The users time input 
//			
// Output:
//      The incremented time will be displayed to stdout by calling the 
//      DisplayTime function
//
// ============================================================================
void  AddOneSecond(Time  &timeParam)
{
	// this is just a simple bool which checks to see if
	// the program should increment the max hrs in the
	// 1st or 2nd if statements, which are located below
	bool incrementHrsInFirstIf = false;

	// this is just a simple bool which checks to see if
	// the program should increment the max mins in the
	// 2nd or 3rd if statements, which are located below
	bool incrementMinInSecondIf = false;

	// ========== if statement #1 - hrs ==========
	// checks to see if user selected hrs is equal to MAX
	// if it is, reset time back to 0
	if (timeParam.hours == MAX_HOURS && timeParam.min == MAX_MINS)
	{
		timeParam.hours = 0;
		incrementHrsInFirstIf = true;
	}

	// ========== if statement #2 - min ==========
	// checks to see if user selected mins is equal to MAX
	// if it is, reset time back to 0
	if (timeParam.min == MAX_MINS)
	{
		timeParam.min = 0;

		// if mins == 59, we need to increment the hrs by 1
		if(incrementHrsInFirstIf == false)
		{
			++timeParam.hours; 
		}

		incrementMinInSecondIf = true;
	}

	// ========== if statement #3 - Secs ==========
	// checks to see if user selected sec is equal to MAX
	// if it is, reset time back to 0
	if (timeParam.sec == MAX_SECS)
	{
		timeParam.sec = 0;

		// if secs == 59, we need to increment the mins by 1
		if(incrementMinInSecondIf == false)
		{
			++timeParam.min;
		}
	}
	else  // if time is not at max, increment by 1
	{
		++timeParam.sec;
	}
}	// end of AddOneSecond

// ==== DisplayTime ===========================================================
//
// This function will display the user's time
//
// Input:
//      limit [IN]  -- The users time input 
//
// Output:
//      The incremented time will be displayed 
//
// ============================================================================
void    DisplayTime(Time  timeParam)
{
	cout.fill('0');
	cout << setw(2) << timeParam.hours << ":"
		 << setw(2) << timeParam.min << ":"
		 << setw(2) << timeParam.sec 
		 << endl;
}   // http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
				
						// ============================================================================
// File: AddOneSecond.cpp
// ============================================================================
// Description:
// This program prompts the user for the input time, then adds
// one second to the time -- if any of the time structure fields need to 
// "rollover" (e.g., the hours, minutes or seconds need to be reset to zero), 
// this function will handle that. Finally, the incremented time will be 
// displayed to stdout.
// ============================================================================
#include <iostream>
#include <iomanip>
using namespace std;
 
// structure declaration
struct Time
{
	int hours;
	int min;
	int sec;
};
 
// defined constants which do not change
// specifies the max values for each variable
const   int MAX_HOURS = 23;
const   int MAX_MINS = 59;
const   int MAX_SECS = 59;
 
// function prototypes
bool  IsTimeValid(Time  timeParam);
void  AddOneSecond(Time  &timeParam);
void  DisplayTime(Time  timeParam);
 
// ==== main ==================================================================
//
// ============================================================================
int main()
{
	Time userTime = {0,0,0}; // Initialize struct members: hrs, min, sec to 0
	char colon = ':';
	
	cout << "Please enter the time in HH:MM:SS format: ";
	cin >> userTime.hours >> colon >> userTime.min >> colon >> userTime.sec;
 
	// Checks to see if user entered correct data
	if (IsTimeValid(userTime) == false)
	{
       cout << "Invalid input...n" << endl;
       exit(EXIT_FAILURE);
	}
 
	cout << "nThe incremented time is ";
    AddOneSecond(userTime);
    DisplayTime(userTime);
 
	return 0;
}	// end of main
 
// ==== IsTimeValid ===========================================================
//
// This function will validate that the time structure contains legitimate 
// values. If this function determines that the time values are invalid, it 
// will display an error message to stdout.
// 
// Input:
//      limit [IN]  -- The users time input 
//			
// Output:
//      The Time structure as an argument to the AddOneSecond function
//
// ============================================================================
bool  IsTimeValid(Time  timeParam)
{
	// checks to see if user inputted data falls between the specified
	// const variables as declared above
	if ((timeParam.hours >= 0 && timeParam.hours <= MAX_HOURS)
		&&(timeParam.min >= 0 && timeParam.min <= MAX_MINS)
		&&(timeParam.sec >= 0 && timeParam.sec <= MAX_SECS))
	{
		return true;
	}
	else
	{
		return false;
	}
}	// end of IsTimeValid
 
// ==== AddOneSecond ==========================================================
//
// This function will add one second to the time
// 
// Input:
//      limit [IN]  -- The users time input 
//			
// Output:
//      The incremented time will be displayed to stdout by calling the 
//      DisplayTime function
//
// ============================================================================
void  AddOneSecond(Time  &timeParam)
{
	// this is just a simple bool which checks to see if
	// the program should increment the max hrs in the
	// 1st or 2nd if statements, which are located below
	bool incrementHrsInFirstIf = false;
 
	// this is just a simple bool which checks to see if
	// the program should increment the max mins in the
	// 2nd or 3rd if statements, which are located below
	bool incrementMinInSecondIf = false;
 
	// ========== if statement #1 - hrs ==========
	// checks to see if user selected hrs is equal to MAX
	// if it is, reset time back to 0
	if (timeParam.hours == MAX_HOURS && timeParam.min == MAX_MINS)
	{
		timeParam.hours = 0;
		incrementHrsInFirstIf = true;
	}
 
	// ========== if statement #2 - min ==========
	// checks to see if user selected mins is equal to MAX
	// if it is, reset time back to 0
	if (timeParam.min == MAX_MINS)
	{
		timeParam.min = 0;
 
		// if mins == 59, we need to increment the hrs by 1
		if(incrementHrsInFirstIf == false)
		{
			++timeParam.hours; 
		}
 
		incrementMinInSecondIf = true;
	}
 
	// ========== if statement #3 - Secs ==========
	// checks to see if user selected sec is equal to MAX
	// if it is, reset time back to 0
	if (timeParam.sec == MAX_SECS)
	{
		timeParam.sec = 0;
 
		// if secs == 59, we need to increment the mins by 1
		if(incrementMinInSecondIf == false)
		{
			++timeParam.min;
		}
	}
	else  // if time is not at max, increment by 1
	{
		++timeParam.sec;
	}
}	// end of AddOneSecond
 
// ==== DisplayTime ===========================================================
//
// This function will display the user's time
//
// Input:
//      limit [IN]  -- The users time input 
//
// Output:
//      The incremented time will be displayed 
//
// ============================================================================
void    DisplayTime(Time  timeParam)
{
	cout.fill('0');
	cout << setw(2) << timeParam.hours << ":"
		 << setw(2) << timeParam.min << ":"
		 << setw(2) << timeParam.sec 
		 << endl;
}   // http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

STRUCT
The structure declaration is placed above the main function, as noted on lines 16-21, containing the 3 variables (Hrs, min, sec) which are defined within the program. Line 39 displays how to access those variables from the main function, having the variable “Time userTime” as the means of access. Note, line 43, the variables can utilize cin for input.

CONST
Lines 25-27 declare the constant variables, which hold the maximum allowable time the clock is able to display. The function IsTimeValid (line 72) checks to see if user defined input is within the maximum allowable limit or not.

FILL
The program will automatically display 2 numbers for hours,mins,sec even if the user only inputted one number, as noted on lines 169-172. This is basically the same as the setfill function.

Once compiling the above code, you should receive this as your output
Note: The code was compiled five separate times to display the different outputs its able to produce

==== SAMPLE RUN #1 ==== Please enter the time in HH:MM:SS format: 0:0:25 The incremented time is 00:00:26
==== SAMPLE RUN #2 ==== Please enter the time in HH:MM:SS format: 23:58:59 The incremented time is 23:59:00 ==== SAMPLE RUN #3 ==== Please enter the time in HH:MM:SS format: 23:59:59 The incremented time is 00:00:00 ==== SAMPLE RUN #4 ==== Please enter the time in HH:MM:SS format: : : The incremented time is 00:00:01
==== SAMPLE RUN #5 ==== Please enter the time in HH:MM:SS format: 76:09:67 Invalid input...

Tag Archives: Struct

C++ || Snippet – Singly Linked List Custom Template Queue Sample Code

C++ || Snippet – Doubly Linked List Custom Template Queue Sample Code

C++ || Snippet – Linked List Custom Template Stack Sample Code

C++ || Struct – Add One Day To Today’s Date Using A Struct

C++ || Struct – Add One Second To The Clock Using A Struct

Search

Compile Your Code Now

Translate Page

Popular Pages

Recent

Archives

Categories