943,891 Members | Top Members by Rank

Software Development > C++ > Linked list implementation of a queue help
Ad:
  • C++ Discussion Thread
  • Unsolved
  • Views: 856
  • C++ RSS
Permalink
Oct 23rd, 2008
0

Linked list implementation of a queue help

Expand Post »
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?
Similar Threads
Reputation Points: 10
Solved Threads: 0
Light Poster
JustLearning is offline Offline
31 posts
since Sep 2008
Permalink
Oct 23rd, 2008
0

Re: Linked list implementation of a queue help

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.
Reputation Points: 392
Solved Threads: 108
Posting Shark
Alex Edwards is offline Offline
971 posts
since Jun 2008
Permalink
Oct 23rd, 2008
0

Re: Linked list implementation of a queue help

Click to Expand / Collapse  Quote originally posted by Alex Edwards ...
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.
Reputation Points: 10
Solved Threads: 0
Light Poster
JustLearning is offline Offline
31 posts
since Sep 2008
Permalink
Oct 23rd, 2008
0

Re: Linked list implementation of a queue help

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.
Reputation Points: 392
Solved Threads: 108
Posting Shark
Alex Edwards is offline Offline
971 posts
since Jun 2008
Permalink
Oct 23rd, 2008
0

Re: Linked list implementation of a queue help

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.
Reputation Points: 392
Solved Threads: 108
Posting Shark
Alex Edwards is offline Offline
971 posts
since Jun 2008
Permalink
Oct 23rd, 2008
0

Re: Linked list implementation of a queue help

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.
Reputation Points: 10
Solved Threads: 0
Light Poster
JustLearning is offline Offline
31 posts
since Sep 2008

This thread is more than three months old

No one has posted to this discussion for at least three months. Please let old threads die and do not reply to them unless you feel you have something new and valuable to contribute that absolutely must be added to make the discussion complete. Otherwise, please start a new thread in this forum instead.
Message:
Previous Thread in C++ Forum Timeline: priority_queue help
Next Thread in C++ Forum Timeline: c++ and winapi how to display text using directx





About Us | Contact Us | Advertise | Acceptable Use Policy
Forum Index | Build Custom RSS Feed


Follow us on Twitter


© 2011 DaniWeb® LLC