C++ RSS C++ RSS

Linked list implementation of a queue help

Please support our C++ advertiser: Intel Parallel Studio Home
Reply

•
•
Join Date: Sep 2008
Posts: 31
Reputation: JustLearning is an unknown quantity at this point 
Solved Threads: 0
JustLearning JustLearning is offline Offline
Light Poster

Linked list implementation of a queue help

 
0
  #1
Oct 23rd, 2008
When I try to compile and run this file I get a segmentation fault when the size function is called so I must not have it set up right.
The size function returns the number of stored chars in the queue.
So I am thinking that the size function in my implementation file is not set up correctly.
Keep in mind that I am not finished I am having some other erors as well but when I get this one resolved I will start working on those.


Header file provided by instructor
c++ Syntax (Toggle Plain Text) 
  1. #ifndef TEMPLATEQ_H
  2.  
  3. #define TEMPLATEQ_H
  4.  
  5. #include <iostream>
  6. #include <new>
  7. #include <cstddef>
  8.  
  9. using namespace std;
  10.  
  11. class FullTemplateQ								// Exception class
  12. {};  
  13.  
  14.  
  15. class EmptyTemplateQ								// Exception class
  16. {};  
  17.  
  18.  
  19. template<class SomeType>	   				// Node template class
  20. struct QueueNode
  21. {
  22.   SomeType  data;									// Data stored in queue node
  23.  
  24.   QueueNode<SomeType>*  nextPtr;				// Pointer to next queue node
  25. };
  26.  
  27.  
  28. template<class SomeType>	   				// Circular queue template class
  29. class TemplateQ
  30. {
  31.   private:
  32.     QueueNode<SomeType>*  rearPtr;			// Pointer to rear of queue
  33.  
  34. 	QueueNode<SomeType>*  frontPtr;			// Pointer to front of queue
  35.  
  36.     void PrintNext(QueueNode<SomeType>* tempPtr) const; // Print trailing items
  37.  
  38.   public:
  39. 	TemplateQ();									// Default constructor
  40.  
  41. 	~TemplateQ();									// Destructor deallocates every node
  42.  
  43. 	void Enqueue(SomeType newData);			// Adds newdata node to rear of queue
  44.  
  45. 	SomeType Dequeue();							// Removes data node from front of queue,
  46.                                           // returning the stored data
  47.  
  48. 	bool IsFull() const;							// Returns true if queue is full, 
  49.                                           // false otherwise
  50.  
  51. 	bool IsEmpty() const;						// Returns true if queue is empty, 
  52.                                           // false otherwise
  53.  
  54. 	int Size() const;								// Returns the number of items in queue
  55.  
  56.     void ForwardPrint() const;             // Prints queue, front to rear
  57.  
  58.     void ReversePrint() const;             // Prints queue, rear to front
  59. };
  60.  
  61. #include "templateq.cpp"					// Very Important!!  Do not delete!!
  62.  
  63. #endif

my implementation file
The size function starts on line 58.
c++ Syntax (Toggle Plain Text) 
  1. #include <new>
  2. #include <cstddef>
  3. #include <iostream>
  4. //There is no need for #include "templateq.h" since the header file has #include "templateq.cpp" at the end of it.
  5. using namespace std;
  6.  
  7. template<class SomeType>
  8. TemplateQ<SomeType>::TemplateQ()
  9. {
  10. 	frontPtr = NULL;
  11. 	rearPtr = NULL;
  12. }
  13.  
  14. template<class SomeType>
  15. void TemplateQ<SomeType>::Enqueue(SomeType newData)
  16. {
  17. 	if (IsFull())
  18. 		throw FullTemplateQ();
  19. 	else if(IsEmpty())
  20. 	{
  21. 		QueueNode<SomeType>* nextQueueLocation;
  22.  
  23. 		nextQueueLocation = new QueueNode<SomeType>;
  24. 		nextQueueLocation->data = newData;
  25. 		nextQueueLocation->nextPtr = NULL;
  26. 		if(rearPtr == NULL)
  27. 			frontPtr = nextQueueLocation;
  28. 		else
  29. 			rearPtr->nextPtr = nextQueueLocation;
  30. 		rearPtr = nextQueueLocation;
  31. 	}
  32. }
  33.  
  34. template<class SomeType>
  35. bool TemplateQ<SomeType>::IsFull()const
  36. {
  37. 	QueueNode<SomeType>* tempPtr;
  38.  
  39. 	try
  40. 	{
  41. 		tempPtr = new QueueNode<SomeType>;
  42. 		delete tempPtr;
  43. 		return false;
  44. 	}
  45. 	catch (std::bad_alloc)
  46. 	{
  47. 		return true;
  48. 	}
  49. }
  50.  
  51. template<class SomeType>
  52. bool TemplateQ<SomeType>::IsEmpty()const
  53. {
  54. 	return (frontPtr == NULL);
  55. }
  56.  
  57. template<class SomeType>
  58. int TemplateQ<SomeType>::Size() const
  59. {
  60. 	int numberOfChars = 0;
  61. 	QueueNode<SomeType>* countPtr;
  62.  
  63.  
  64. 	if(IsEmpty())
  65. 		return 0;
  66.  
  67. 	while(countPtr != frontPtr)
  68. 	{
  69. 		countPtr = rearPtr->nextPtr;
  70. 		countPtr = countPtr->nextPtr;
  71. 		numberOfChars ++;
  72. 	}
  73. 	return numberOfChars;
  74. }
  75.  
  76. template<class SomeType>
  77. void TemplateQ<SomeType>::ForwardPrint()const
  78. {
  79. 	QueueNode<SomeType>* countPtr;
  80. 	if(IsEmpty())
  81. 		throw EmptyTemplateQ();
  82. 	else
  83. 	{
  84. 		countPtr = frontPtr;
  85. 		while(countPtr != rearPtr)
  86. 		{
  87. 			countPtr = countPtr->data;
  88. 			cout << countPtr->data << " ";
  89. 			countPtr = countPtr->nextPtr;
  90. 		}
  91. 		cout << endl;
  92. 	}
  93. }
  94.  
  95. template<class SomeType>
  96. void TemplateQ<SomeType>::ReversePrint()const
  97. {}
  98.  
  99. template<class SomeType>
  100. SomeType TemplateQ<SomeType>::Dequeue()
  101. {
  102. 	QueueNode<SomeType>* dequeuePtr;
  103. 	if(IsEmpty())
  104. 		throw EmptyTemplateQ();
  105. 	else
  106. 	{
  107. 		dequeuePtr = frontPtr;
  108. 		//dequeuePtr = frontPtr->data;
  109. 		frontPtr = frontPtr->nextPtr;
  110. 		if(frontPtr == NULL)
  111. 			rearPtr = NULL;
  112.  
  113. 	}
  114. 	return dequeuePtr->data;
  115. 	delete dequeuePtr;
  116. }
  117.  
  118. template<class SomeType>
  119. TemplateQ<SomeType>::~TemplateQ()
  120. {
  121. 	QueueNode<SomeType>* tempPtr;
  122.  
  123. 	while (frontPtr != NULL)
  124. 	{
  125. 		tempPtr = frontPtr;
  126. 		frontPtr = frontPtr->nextPtr;
  127. 		delete tempPtr;
  128. 	}
  129. 	rearPtr = NULL;
  130. }

my test driver
c++ Syntax (Toggle Plain Text) 
  1. #include "templateq.h"
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <fstream>
  5. #include <string>
  6. #include <cmath>
  7. #include <cstddef>
  8. #include <new>
  9.  
  10. int main(int argc, char * const argv[])
  11. {
  12. 	char command, letter;
  13. 	TemplateQ<char> queue;
  14. 	ifstream inputs;
  15. 	if (argc !=2)
  16. 	{
  17. 		cout << "Usage:\n program06 <inputfile>\n";
  18. 		return 1;
  19. 	}
  20.  
  21. 	inputs.open(argv[1]);
  22.  
  23. 	if(!inputs)
  24. 	{
  25. 		cout << "Unable to open file" << endl;
  26. 		return 1;
  27. 	}
  28.  
  29. 	inputs >> command;
  30.  
  31. 	if(command != 'c')
  32. 	{
  33. 		cout << "Invalid File Format - missing 'c'\nTerminating program now..." << endl;
  34. 		return 1;
  35. 	}
  36.  
  37. 	while(!inputs.eof())
  38. 	{
  39. 		switch(command)
  40. 		{
  41.  
  42. 			case 'c':
  43. 			{
  44. 				cout << "Constructor()" << endl;
  45. 				break;
  46. 			}
  47. 			case '+':
  48. 			{	
  49. 				try
  50. 				{
  51. 					inputs >> letter;
  52. 					//cout << letter << endl;
  53. 					cout << "Enqueue('";
  54. 					queue.Enqueue(letter);
  55. 					cout << letter << "')"<< endl;
  56. 				}
  57. 				catch(FullTemplateQ)
  58. 				{
  59. 					cout << "Failed Full Queue" << endl;
  60. 				}
  61. 				break;
  62. 			}
  63. 			case '-':
  64. 			{
  65. 				try
  66. 				{
  67. 					cout << "Dequeue() -- ";
  68. 					queue.Dequeue();
  69. 					cout << queue.Dequeue() << endl;
  70. 				}
  71. 				catch(EmptyTemplateQ)
  72. 				{
  73. 					cout << "Failed Empty Queue" << endl;
  74. 				}
  75. 				break;
  76. 			}
  77. 			case 'p':
  78. 			{
  79. 				cout << "case p" << endl;
  80. 				break;
  81. 			}
  82. 			case 'r':
  83. 			{
  84. 				cout << "case r" << endl;
  85. 				break;
  86. 			}
  87. 			case 's':
  88. 			{
  89. 				cout << "Size () -- " << queue.Size() << endl;
  90. 				break;
  91. 			}
  92. 			case 'd':
  93. 			{
  94. 				queue.~TemplateQ();
  95. 				cout << "Destructor ()" << endl;
  96. 				break;
  97. 			}
  98. 			default:
  99. 			{
  100. 				cout << "Command not recognized" << endl;
  101. 			}
  102.  
  103. 		}
  104. 		inputs >> command;
  105. 	}
  106.  
  107.  
  108. 	return 0;
  109. }
this is my output to the terminal window
C++ Syntax (Toggle Plain Text) 
  1. -bash-3.2$ ./program06 p06input1.txt
  2. Constructor()
  3. Size () -- 0
  4. Enqueue('a')
  5. Enqueue('b')
  6. Enqueue('c')
  7. Enqueue('d')
  8. Enqueue('e')
  9. Enqueue('f')
  10. case p
  11. case r
  12. Segmentation fault

At that segmentation fault is where the size function is supposed to print out the number of stored chars. Can someone tell me what I am doing wrong?
Reply With Quote Quick reply to this message  
•
•
Join Date: Jun 2008
Posts: 973
Reputation: Alex Edwards is a jewel in the rough Alex Edwards is a jewel in the rough Alex Edwards is a jewel in the rough Alex Edwards is a jewel in the rough 
Solved Threads: 107
Alex Edwards's Avatar
Alex Edwards Alex Edwards is offline Offline
Posting Shark

Re: Linked list implementation of a queue help

 
0
  #2
Oct 23rd, 2008
c++ Syntax (Toggle Plain Text) 
  1. template<class SomeType>
  2. void TemplateQ<SomeType>::Enqueue(SomeType newData)
  3. {
  4. 	if (IsFull())
  5. 		throw FullTemplateQ();
  6. 	else if(IsEmpty())
  7. 	{
  8. 		QueueNode<SomeType>* nextQueueLocation;
  9.  
  10. 		nextQueueLocation = new QueueNode<SomeType>;
  11. 		nextQueueLocation->data = newData;
  12. 		nextQueueLocation->nextPtr = NULL;
  13. 		if(rearPtr == NULL)
  14. 			frontPtr = nextQueueLocation;
  15. 		else
  16. 			rearPtr->nextPtr = nextQueueLocation;
  17. 		rearPtr = nextQueueLocation;
  18. 	}
  19. }

I'm not quite sure how you want your implementation of a queue to work but...

You only Enque if the list is either empty or full, so after the first Enque the list is no longer empty and unless you're working in a very small heap, or some exception occurs, the IsFull method will return false, so successive calls to Enque will simply do nothing.

One value is stored in your queue and when you call Size I suppose the segmentation fault is caused because you're attempting to indirectly call rearPtr->next when rearPtr points to NULL and the address that its pointing to doesn't belong to your program so an exception occurs and it shuts down.

You need to add another case in your Enque so that when you call it, it can add an element even if its not empty or not full.

Also it might help to code more defensively to prevent a segmentation fault from occurring.

Edit: This statement is confusing--

c++ Syntax (Toggle Plain Text) 
  1. 	while(countPtr != frontPtr)
  2. 	{
  3. 		countPtr = rearPtr->nextPtr; // why is this needed if you're going to reassign countPtr?
  4. 		countPtr = countPtr->nextPtr;
  5. 		numberOfChars ++;
  6. 	}
  7. 	return numberOfChars;
Last edited by Alex Edwards; Oct 23rd, 2008 at 1:00 am.
Reply With Quote Quick reply to this message  
•
•
Join Date: Sep 2008
Posts: 31
Reputation: JustLearning is an unknown quantity at this point 
Solved Threads: 0
JustLearning JustLearning is offline Offline
Light Poster

Re: Linked list implementation of a queue help

 
0
  #3
Oct 23rd, 2008
•
•
•
•
Originally Posted by Alex Edwards View Post
c++ Syntax (Toggle Plain Text) 
  1. template<class SomeType>
  2. void TemplateQ<SomeType>::Enqueue(SomeType newData)
  3. {
  4. 	if (IsFull())
  5. 		throw FullTemplateQ();
  6. 	else if(IsEmpty())
  7. 	{
  8. 		QueueNode<SomeType>* nextQueueLocation;
  9.  
  10. 		nextQueueLocation = new QueueNode<SomeType>;
  11. 		nextQueueLocation->data = newData;
  12. 		nextQueueLocation->nextPtr = NULL;
  13. 		if(rearPtr == NULL)
  14. 			frontPtr = nextQueueLocation;
  15. 		else
  16. 			rearPtr->nextPtr = nextQueueLocation;
  17. 		rearPtr = nextQueueLocation;
  18. 	}
  19. }


Edit: This statement is confusing--

c++ Syntax (Toggle Plain Text) 
  1. 	while(countPtr != frontPtr)
  2. 	{
  3. 		countPtr = rearPtr->nextPtr; // why is this needed if you're going to reassign countPtr?
  4. 		countPtr = countPtr->nextPtr;
  5. 		numberOfChars ++;
  6. 	}
  7. 	return numberOfChars;
Ok I changed this part
c++ Syntax (Toggle Plain Text) 
  1. template<class SomeType>
  2. void TemplateQ<SomeType>::Enqueue(SomeType newData)
  3. {
  4. 	if (IsFull())
  5. 		throw FullTemplateQ();
  6. 	else
  7. 	{
  8. 		QueueNode<SomeType>* nextQueueLocation;
  9.  
  10. 		nextQueueLocation = new QueueNode<SomeType>;
  11. 		nextQueueLocation->data = newData;
  12. 		nextQueueLocation->nextPtr = NULL;
  13. 		if(rearPtr == NULL)
  14. 			frontPtr = nextQueueLocation;
  15. 		else
  16. 			rearPtr->nextPtr = nextQueueLocation;
  17. 		rearPtr = nextQueueLocation;
  18. 	}
  19. }

The other part I was trying to walk through the list counting each node as I went.
I tried to comment out that line of code but compile it and run it but I get the same error.
What am I doing wrong?
Last edited by JustLearning; Oct 23rd, 2008 at 2:06 am.
Reply With Quote Quick reply to this message  
•
•
Join Date: Jun 2008
Posts: 973
Reputation: Alex Edwards is a jewel in the rough Alex Edwards is a jewel in the rough Alex Edwards is a jewel in the rough Alex Edwards is a jewel in the rough 
Solved Threads: 107
Alex Edwards's Avatar
Alex Edwards Alex Edwards is offline Offline
Posting Shark

Re: Linked list implementation of a queue help

 
0
  #4
Oct 23rd, 2008
I ran the program (unchanged from the original) in MS Visual C++ 2008 and I got a run-time error where countPtr is being used when it hasn't been initialized.

Try initializing it to null and see if that removes your run-time warning. I'll keep investigating with debug on to see what else I can sift out.

Edit: Ok now I see why you are assigning countPtr to be rearPtr then assigning countPtr to be countPtr->nextPtr

It's because you want to give countPtr a valid address before calling countPtr->rearPtr.
Last edited by Alex Edwards; Oct 23rd, 2008 at 2:45 am.
Reply With Quote Quick reply to this message  
•
•
Join Date: Jun 2008
Posts: 973
Reputation: Alex Edwards is a jewel in the rough Alex Edwards is a jewel in the rough Alex Edwards is a jewel in the rough Alex Edwards is a jewel in the rough 
Solved Threads: 107
Alex Edwards's Avatar
Alex Edwards Alex Edwards is offline Offline
Posting Shark

Re: Linked list implementation of a queue help

 
0
  #5
Oct 23rd, 2008
Ok, I got the Size function working.

I changed the code a bit, after reading through your logic some.

The problem was in Size, where you attempted to initialize countPtr to be the rear and compare it to the front.

You're traversing from the low end of the list and further towards lower parts without ascending upwards, so the loop is infinite and will never reach frontPtr.


Here are the changes I made--

c++ Syntax (Toggle Plain Text) 
  1.  
  2. #ifndef TEMPLATEQ_H
  3.  
  4. #define TEMPLATEQ_H
  5.  
  6. #include <iostream>
  7. #include <new>
  8. #include <cstddef>
  9.  
  10. using namespace std;
  11.  
  12. class FullTemplateQ								// Exception class
  13. {};  
  14.  
  15.  
  16. class EmptyTemplateQ								// Exception class
  17. {};  
  18.  
  19.  
  20. template<class SomeType>	   				// Node template class
  21. struct QueueNode
  22. {
  23.   SomeType  data;									// Data stored in queue node
  24.  
  25.   QueueNode<SomeType>*  nextPtr;				// Pointer to next queue node
  26. };
  27.  
  28.  
  29. template<class SomeType>	   				// Circular queue template class
  30. class TemplateQ
  31. {
  32.   private:
  33.     QueueNode<SomeType>*  rearPtr;			// Pointer to rear of queue
  34.  
  35. 	QueueNode<SomeType>*  frontPtr;			// Pointer to front of queue
  36.  
  37.     void PrintNext(QueueNode<SomeType>* tempPtr) const; // Print trailing items
  38.  
  39.   public:
  40. 	TemplateQ();									// Default constructor
  41.  
  42. 	~TemplateQ();									// Destructor deallocates every node
  43.  
  44. 	void Enqueue(SomeType newData);			// Adds newdata node to rear of queue
  45.  
  46. 	SomeType Dequeue();							// Removes data node from front of queue,
  47.                                           // returning the stored data
  48.  
  49. 	bool IsFull() const;							// Returns true if queue is full, 
  50.                                           // false otherwise
  51.  
  52. 	bool IsEmpty() const;						// Returns true if queue is empty, 
  53.                                           // false otherwise
  54.  
  55. 	int Size() const;								// Returns the number of items in queue
  56.  
  57.     void ForwardPrint() const;             // Prints queue, front to rear
  58.  
  59.     void ReversePrint() const;             // Prints queue, rear to front
  60. };
  61.  
  62. #include "templateq.cpp"					// Very Important!!  Do not delete!!
  63.  
  64. #endif

c++ Syntax (Toggle Plain Text) 
  1.  
  2. #ifdef TEMPLATEQ_H
  3.  
  4.  
  5. #include <new>
  6. #include <cstddef>
  7. #include <iostream>
  8. //There is no need for #include "templateq.h" since the header file has #include "templateq.cpp" at the end of it.
  9. using namespace std;
  10.  
  11. template<class SomeType>
  12. TemplateQ<SomeType>::TemplateQ()
  13. {
  14. 	frontPtr = NULL;
  15. 	rearPtr = NULL;
  16. }
  17.  
  18. template<class SomeType>
  19. void TemplateQ<SomeType>::Enqueue(SomeType newData)
  20. {
  21. 	if (IsFull())
  22. 		throw FullTemplateQ();
  23. 	else
  24. 	{
  25. 		QueueNode<SomeType>* nextQueueLocation = NULL;
  26.  
  27. 		nextQueueLocation = new QueueNode<SomeType>;
  28. 		nextQueueLocation->data = newData;
  29. 		nextQueueLocation->nextPtr = NULL;
  30. 		if(rearPtr == NULL)
  31. 			frontPtr = nextQueueLocation;
  32. 		else
  33. 			rearPtr->nextPtr = nextQueueLocation;
  34. 		rearPtr = nextQueueLocation;
  35. 	}
  36. }
  37.  
  38. template<class SomeType>
  39. bool TemplateQ<SomeType>::IsFull()const
  40. {
  41. 	QueueNode<SomeType>* tempPtr = NULL;
  42.  
  43. 	try
  44. 	{
  45. 		tempPtr = new QueueNode<SomeType>;
  46. 		delete tempPtr;
  47. 		return false;
  48. 	}
  49. 	catch (std::bad_alloc)
  50. 	{
  51. 		return true;
  52. 	}
  53. }
  54.  
  55. template<class SomeType>
  56. bool TemplateQ<SomeType>::IsEmpty()const
  57. {
  58. 	return (frontPtr == NULL);
  59. }
  60.  
  61. template<class SomeType>
  62. int TemplateQ<SomeType>::Size() const
  63. {
  64. 	int numberOfChars = 0;
  65. 	QueueNode<SomeType>* countPtr = frontPtr;
  66.  
  67.  
  68. 	if(IsEmpty())
  69. 		return 0;
  70.  
  71. 	while(countPtr != NULL)
  72. 	{
  73. 		//countPtr = rearPtr->nextPtr;
  74. 		countPtr = countPtr->nextPtr;
  75. 		numberOfChars ++;
  76. 	}
  77. 	return numberOfChars;
  78. }
  79.  
  80. template<class SomeType>
  81. void TemplateQ<SomeType>::ForwardPrint()const
  82. {
  83. 	QueueNode<SomeType>* countPtr = NULL;
  84. 	if(IsEmpty())
  85. 		throw EmptyTemplateQ();
  86. 	else
  87. 	{
  88. 		countPtr = frontPtr;
  89. 		while(countPtr != rearPtr)
  90. 		{
  91. 			countPtr = countPtr->data;
  92. 			cout << countPtr->data << " ";
  93. 			countPtr = countPtr->nextPtr;
  94. 		}
  95. 		cout << endl;
  96. 	}
  97. }
  98.  
  99. template<class SomeType>
  100. void TemplateQ<SomeType>::ReversePrint()const
  101. {}
  102.  
  103. template<class SomeType>
  104. SomeType TemplateQ<SomeType>::Dequeue()
  105. {
  106. 	QueueNode<SomeType>* dequeuePtr = NULL;
  107. 	if(IsEmpty())
  108. 		throw EmptyTemplateQ();
  109. 	else
  110. 	{
  111. 		dequeuePtr = frontPtr;
  112. 		//dequeuePtr = frontPtr->data;
  113. 		frontPtr = frontPtr->nextPtr;
  114. 		if(frontPtr == NULL)
  115. 			rearPtr = NULL;
  116.  
  117. 	}
  118. 	return dequeuePtr->data;
  119. 	delete dequeuePtr;
  120. }
  121.  
  122. template<class SomeType>
  123. TemplateQ<SomeType>::~TemplateQ()
  124. {
  125. 	QueueNode<SomeType>* tempPtr = NULL;
  126.  
  127. 	while (frontPtr != NULL)
  128. 	{
  129. 		tempPtr = frontPtr;
  130. 		frontPtr = frontPtr->nextPtr;
  131. 		delete tempPtr;
  132. 	}
  133. 	rearPtr = NULL;
  134. }
  135.  
  136. #endif

c++ Syntax (Toggle Plain Text) 
  1.  
  2. #include "templateq.h"
  3. #include <iostream>
  4. #include <iomanip>
  5. #include <fstream>
  6. #include <string>
  7. #include <cmath>
  8. #include <cstddef>
  9. #include <new>
  10.  
  11. int main(int argc, char * const argv[])
  12. {
  13.  
  14. 	char command, letter;
  15. 	TemplateQ<char> queue;
  16. 	ifstream inputs;
  17. 	//if (argc !=2)
  18. 	//{
  19. 		cout << "Usage:\n program06 <inputfile>\n";
  20. 	//	return 1;
  21. 	//}
  22.  
  23. 	//inputs.open(argv[1]);
  24. 	inputs.open("C:/MyFile.txt");
  25.  
  26. 	if(!inputs)
  27. 	{
  28. 		cout << "Unable to open file" << endl;
  29. 		return 1;
  30. 	}
  31.  
  32. 	inputs >> command;
  33.  
  34. //	if(command != 'c')
  35. //	{
  36. //		cout << "Invalid File Format - missing 'c'\nTerminating program now..." << endl;
  37. 	//	return 1;
  38. //	}
  39.  
  40. 	while(!inputs.eof())
  41. 	{
  42. 		switch(command)
  43. 		{
  44.  
  45. 			case 'c':
  46. 			{
  47. 				cout << "Constructor()" << endl;
  48. 				break;
  49. 			}
  50. 			case '+':
  51. 			{	
  52. 				try
  53. 				{
  54. 					inputs >> letter;
  55. 					//cout << letter << endl;
  56. 					cout << "Enqueue('";
  57. 					queue.Enqueue(letter);
  58. 					cout << letter << "')"<< endl;
  59. 				}
  60. 				catch(FullTemplateQ)
  61. 				{
  62. 					cout << "Failed Full Queue" << endl;
  63. 				}
  64. 				break;
  65. 			}
  66. 			case '-':
  67. 			{
  68. 				try
  69. 				{
  70. 					cout << "Dequeue() -- ";
  71. 					queue.Dequeue();
  72. 					cout << queue.Dequeue() << endl;
  73. 				}
  74. 				catch(EmptyTemplateQ)
  75. 				{
  76. 					cout << "Failed Empty Queue" << endl;
  77. 				}
  78. 				break;
  79. 			}
  80. 			case 'p':
  81. 			{
  82. 				cout << "case p" << endl;
  83. 				break;
  84. 			}
  85. 			case 'r':
  86. 			{
  87. 				cout << "case r" << endl;
  88. 				break;
  89. 			}
  90. 			case 's':
  91. 			{
  92. 				cout << "Size () -- " << queue.Size() << endl;
  93. 				break;
  94. 			}
  95. 			case 'd':
  96. 			{
  97. 				queue.~TemplateQ();
  98. 				cout << "Destructor ()" << endl;
  99. 				break;
  100. 			}
  101. 			default:
  102. 			{
  103. 				cout << "Command not recognized" << endl;
  104. 			}
  105.  
  106. 		}
  107. 		inputs >> command;
  108. 	}
  109.  
  110. 	cin.ignore();
  111. 	cin.get();
  112. 	return 0;
  113. }


The file I used ("C:/MyFile.txt")--
c
s
+
a
+
b
+
c
+
d
+
e
+
f
p
r
s

Instead of initializing countPtr in size to point to rear, I made it point to the front and simply traverse down the queue.
Last edited by Alex Edwards; Oct 23rd, 2008 at 3:11 am.
Reply With Quote Quick reply to this message  
•
•
Join Date: Sep 2008
Posts: 31
Reputation: JustLearning is an unknown quantity at this point 
Solved Threads: 0
JustLearning JustLearning is offline Offline
Light Poster

Re: Linked list implementation of a queue help

 
0
  #6
Oct 23rd, 2008
I found the problem
I should have just set countPtr = frontPtr outside the while loop.
I did the same thing you did.
Last edited by JustLearning; Oct 23rd, 2008 at 3:22 am.
Reply With Quote Quick reply to this message  
Reply

Quick Reply to Thread
This thread is more than three months old.
Perhaps start a new thread instead?
•
•
•
•
•
•
•
•
Message:
•
•
•
•



Similar Threads
Other Threads in the C++ Forum
Thread Tools Search this Thread



api array arrays beginner binary bitmap c++ c/c++ calculator char class classes code compile compiler console conversion convert count data database delete desktop developer directshow dll download dynamic encryption error file forms fstream function functions game generator getline givemetehcodez google graph gui homeworkhelper iamthwee ifstream input int integer java lib linkedlist linker linux loop looping loops map math matrix memory multiple news node number output parameter pointer problem program programming project proxy python random read recursion recursive return string strings struct temperature template templates test text text-file tree unix url variable vector video visualstudio win32 windows winsock word wordfrequency wxwidgets
About Us | Contact Us | Advertise | DaniWeb | Acceptable Use Policy | RSS Feed

©2003 - 2009 DaniWeb® LLC