RSS

Error in c++ program

Please support our C++ advertiser: Programming Forums

Thread Tools Display Modes

Views: 1990 | Replies: 6

•

Join Date: Oct 2004

Posts: 3

Reputation: Midnight Skulke is an unknown quantity at this point

Rep Power: 0

Solved Threads: 0

Midnight Skulke Midnight Skulke is offline

Offline

Newbie Poster

Error in c++ program

Oct 24th, 2004

I have design two program and both have errors on it. the first is supposed to handle queue on integer, double, string and date. I have done for integer and double. When I compile it there was error on it. If you can just help me debug it and i will complete the string and date myself. i have to submit this by Thursday. below is the code for it:

Help with Code Tags

(Toggle Plain Text)

//listnd.h
//ListNode template definition
#ifndef LISTND_H
#define LISTND_H

template< class NODETYPE > class List;	//forward declaration

template<class NODETYPE>
class ListNode {
	friend class List< NODETYPE >;	//make List a friend
	public:
		ListNode( const NODETYPE & );	//constructor
		NODETYPE getData() const;	//return data in the node
	private:
		NODETYPE data;	//data
		ListNode< NODETYPE > *nextPtr;	//next node in the list
};

//Constructor
template<class NODETYPE>
ListNode< NODETYPE >::ListNode( const NODETYPE &info )
: data( info ), nextPtr( 0 ) { }

//Return a copy of the data in the node
template< class NODETYPE >
NODETYPE ListNode< NODETYPE >::getData() const { return data; }

#endif
//-------------------------------------------------------------------------

#ifndef LIST_H
#define LIST_H

#include <iostream>
#include <cassert>
#include "listnd.h"

using std::cout;

template< class NODETYPE >
class List {
	public:
		List();	//constructor
		~List();	//destructor
		void insertAtFront( const NODETYPE & );
		void insertAtBack( const NODETYPE & );
		bool removeFromFront( NODETYPE & );
		bool removeFromBack( NODETYPE & );
		bool isEmpty() const;
		void print() const;
	private:
		ListNode< NODETYPE > *firstPtr;	//pointer to first node
		ListNode< NODETYPE > *lastPtr;	//pointer to last node

		//Utility function to allocate a new node
		ListNode< NODETYPE > *getNewNode( const NODETYPE & );
};

//Default constructor
template< class NODETYPE >
List< NODETYPE >::List() : firstPtr( 0 ), lastPtr( 0 ) { }
//Destructor
template< class NODETYPE >
List< NODETYPE >::~List()
{
	if( !isEmpty() ) {	//List is not empty
		cout << "Destroying nodes...\n";

		ListNode< NODETYPE > *currentPtr = firstPtr, *tempPtr;

		while ( currentPtr != 0 ) {	//delete remaining nodes
			tempPtr = currentPtr;
			cout << tempPtr->data << '\n';
			currentPtr = currentPtr->nextPtr;
			delete tempPtr;
		}
	}

	cout << "All nodes destroyed\n\n";
}

//Insert a node at the front of the list
template< class NODETYPE >
void List< NODETYPE>::insertAtFront( const NODETYPE &value )
{
	ListNode< NODETYPE > *newPtr = getNewNode( value );

	if ( isEmpty() )	//List is empty
		firstPtr = lastPtr = newPtr;
	else {	//List is not empty
		newPtr->nextPtr = firstPtr;
		firstPtr = newPtr;
	}
}

//Insert a node at the back of the list
template< class NODETYPE >
void List< NODETYPE >::insertAtBack( const NODETYPE &value )
{
	ListNode< NODETYPE > *newPtr = getNewNode( value );

	if (isEmpty() )	//List is empty
		firstPtr = lastPtr = newPtr;
	else {	//List is not empty
		lastPtr->nextPtr = newPtr;
		lastPtr = newPtr;
	}
}

//Delete a node from the front of the list
template< class NODETYPE >
bool List< NODETYPE >::removeFromFront( NODETYPE &value )
{
	if ( isEmpty() )	//List is empty
		return return;	//delete unsuccessful
	else {
		ListNode< NODETYPE > *tempPtr = firstPtr;

		if ( firstPtr == lastPtr )
			firstPtr = lastPtr = 0;
		else
			firstPtr = firstPtr->nextPtr;

		value = tempPtr->data;	//data being removed
		delete tempPtr;
		return;	//delete successful
	}
}

//Delete a node from the back of the list
template< class NODETYPE >
bool List< NODETYPE >::removeFromBack( NODETYPE &value )
{
	if ( isEmpty() )
		return return;	//delete succesful
	else {
		ListNode< NODETYPE > *tempPtr = lastPtr;

		if ( firstPtr == lastPtr )
			firstPtr = LastPtr = 0;
		else {
			ListNode< NODETYPE > *currentPtr = firstPtr;

			while ( currentPtr->nextPtr != lastPtr )
				currentPtr = currentPtr->nextPtr;

			lastPtr = currentPtr;
			currentPtr->nextPtr = 0;
		}
		
			value = tempPtr->data;
			delete tempPtr;
			return return;	//delete succesful
	}
}

//Is the List empty
template< class NODETYPE >
bool List< NODETYPE >::isEmpty() const
{ return firstPtr ==0; }

//return a pointer to a newly allocated node
template < class NODETYPE >
ListNode< NODETYPE > *List< NODETYPE >::getNewNode( 
										const NODETYPE &value )
{
ListNode< NODETYPE > *ptr = 
   new ListNode< NODETYPE >( value );
assert( ptr != 0 );
return ptr;
}

//Display the contents of the List
template< class NODETYPE >
void List< NODETYPE >::print() const
{
    if ( isEmpty() ) {
		cout << "The list is empty\n\n";
		return;
	}

	ListNode< NODETYPE > *currentPtr = firstPtr;

	cout << "The list is: ";

	while ( currentPtr != 0 ) {
		cout << currentPtr->data << ' ';
		currentPtr = currentPtr->nextPtr;
	}

	cout << "\n\n";

}

#endif
//-------------------------------------------------------------------------


#ifndef QUEUE_H
#define QUEUE_H

#include "list.h"

template< class QUEUETYPE >
class Queue: private List< QUEUETYPE > {
	public:
		void enqueue( const QUEUETYPE &d ) { insertAtBack( d ); }
		bool dequeue( QUEUETYPE &d )
		{ return removeFromFront( d ); }
		bool isQueueEmpty() const { return isEmpty(); }
		void printQueue() const { print(); }
};

#endif
//-------------------------------------------------------------------------


#include <iostream>
#include "queue.h"

using std::endl;

int main()
{
	Queue< int > intQueue;
	int dequeueInteger, i;
	cout << "processing an integer Queue" << endl;

	for ( i = 0; i < 4; i++ ) {
		intQueue.enqueue( i );
		intQueue.printQueue();
	}

	while ( !intQueue.isQueueEmpty() ) {
		intQueue.dequeue( dequeueInteger );
		cout << dequeueInteger << " dequeued" << endl;
		intQueue.printQueue();
	}

	Queue< double > doubleQueue;
	double val = 1.1, dequeueDouble;

	cout << "processing a double Queue" << endl;

	for ( i = 0; i < 4; i++ ) {
		doubleQueue.enqueue( val );
		doubleQueue.printQueue();
		val += 1.1;
	}

	while ( !doubleQueue.isQueueEmpty() ) {
		doubleQueue.dequeue( dequeueDouble );
		cout << dequeueDouble << " dequeued" << endl;
		doubleQueue.printQueue();
	}

	return 0;
}


The second problem is a program that is supposed to do a quicksort on a set of array type double and later do a bsearch.  I actually modified the actual program into a class file.  I'm actually weak at class and i hope you can help me. Below is the code:

#include <iostream.h>
#include <algorithm>

//class quicksort

class qsort
{
public:
	int compare(const void*, const void*);
	//qsort (list, 10, sizeof(int), compare);	//error
public:
	int list;
	int element;

};

//class bsearch

class bsearch
{
public:
	int compare(const void*, const void*);
	
public:
	double list;
	int element;
	double key;

};

int main()
{

	double list[10] = {9.2,5.1,2.6,8.5,1.7,7.1,3.2,6.3,4.6,0.1};
	double key = 3;

	//display unsorted list

	for (int element = 0; element <= 9; element++)
	{
		cout << list[element] << " ";
	}

	cout << endl;
	qsort (list, 10, sizeof(int), compare);	//error

	//display sorted list

	for (element = 0; element <= 9; element++)
	{
		cout << list[element] << " ";
	}

	//displays whether the number in the array or not

	/*if (bsearch(&key,list,10,sizeof(int),compare))	//error
	{
		cout<<key<<" is in the array"<<endl;	//number in array
	}
	else
	{
		cout << key <<" is NOT in the array2" <<endl;	//number not in array
	}*/

	return 0;

}

int compare1(const void* a_PTR, const void* b_PTR)
{
	return *((int*)a_PTR) - *((int*)b_PTR);
}

//listnd.h
//ListNode template definition
#ifndef LISTND_H
#define LISTND_H

template< class NODETYPE > class List;	//forward declaration

template<class NODETYPE>
class ListNode {
	friend class List< NODETYPE >;	//make List a friend
	public:
		ListNode( const NODETYPE & );	//constructor
		NODETYPE getData() const;	//return data in the node
	private:
		NODETYPE data;	//data
		ListNode< NODETYPE > *nextPtr;	//next node in the list
};

//Constructor
template<class NODETYPE>
ListNode< NODETYPE >::ListNode( const NODETYPE &info )
: data( info ), nextPtr( 0 ) { }

//Return a copy of the data in the node
template< class NODETYPE >
NODETYPE ListNode< NODETYPE >::getData() const { return data; }

#endif
//-------------------------------------------------------------------------

#ifndef LIST_H
#define LIST_H

#include <iostream>
#include <cassert>
#include "listnd.h"

using std::cout;

template< class NODETYPE >
class List {
	public:
		List();	//constructor
		~List();	//destructor
		void insertAtFront( const NODETYPE & );
		void insertAtBack( const NODETYPE & );
		bool removeFromFront( NODETYPE & );
		bool removeFromBack( NODETYPE & );
		bool isEmpty() const;
		void print() const;
	private:
		ListNode< NODETYPE > *firstPtr;	//pointer to first node
		ListNode< NODETYPE > *lastPtr;	//pointer to last node

		//Utility function to allocate a new node
		ListNode< NODETYPE > *getNewNode( const NODETYPE & );
};

//Default constructor
template< class NODETYPE >
List< NODETYPE >::List() : firstPtr( 0 ), lastPtr( 0 ) { }
//Destructor
template< class NODETYPE >
List< NODETYPE >::~List()
{
	if( !isEmpty() ) {	//List is not empty
		cout << "Destroying nodes...\n";

		ListNode< NODETYPE > *currentPtr = firstPtr, *tempPtr;

		while ( currentPtr != 0 ) {	//delete remaining nodes
			tempPtr = currentPtr;
			cout << tempPtr->data << '\n';
			currentPtr = currentPtr->nextPtr;
			delete tempPtr;
		}
	}

	cout << "All nodes destroyed\n\n";
}

//Insert a node at the front of the list
template< class NODETYPE >
void List< NODETYPE>::insertAtFront( const NODETYPE &value )
{
	ListNode< NODETYPE > *newPtr = getNewNode( value );

	if ( isEmpty() )	//List is empty
		firstPtr = lastPtr = newPtr;
	else {	//List is not empty
		newPtr->nextPtr = firstPtr;
		firstPtr = newPtr;
	}
}

//Insert a node at the back of the list
template< class NODETYPE >
void List< NODETYPE >::insertAtBack( const NODETYPE &value )
{
	ListNode< NODETYPE > *newPtr = getNewNode( value );

	if (isEmpty() )	//List is empty
		firstPtr = lastPtr = newPtr;
	else {	//List is not empty
		lastPtr->nextPtr = newPtr;
		lastPtr = newPtr;
	}
}

//Delete a node from the front of the list
template< class NODETYPE >
bool List< NODETYPE >::removeFromFront( NODETYPE &value )
{
	if ( isEmpty() )	//List is empty
		return return;	//delete unsuccessful
	else {
		ListNode< NODETYPE > *tempPtr = firstPtr;

		if ( firstPtr == lastPtr )
			firstPtr = lastPtr = 0;
		else
			firstPtr = firstPtr->nextPtr;

		value = tempPtr->data;	//data being removed
		delete tempPtr;
		return;	//delete successful
	}
}

//Delete a node from the back of the list
template< class NODETYPE >
bool List< NODETYPE >::removeFromBack( NODETYPE &value )
{
	if ( isEmpty() )
		return return;	//delete succesful
	else {
		ListNode< NODETYPE > *tempPtr = lastPtr;

		if ( firstPtr == lastPtr )
			firstPtr = LastPtr = 0;
		else {
			ListNode< NODETYPE > *currentPtr = firstPtr;

			while ( currentPtr->nextPtr != lastPtr )
				currentPtr = currentPtr->nextPtr;

			lastPtr = currentPtr;
			currentPtr->nextPtr = 0;
		}
		
			value = tempPtr->data;
			delete tempPtr;
			return return;	//delete succesful
	}
}

//Is the List empty
template< class NODETYPE >
bool List< NODETYPE >::isEmpty() const
{ return firstPtr ==0; }

//return a pointer to a newly allocated node
template < class NODETYPE >
ListNode< NODETYPE > *List< NODETYPE >::getNewNode( 
										const NODETYPE &value )
{
ListNode< NODETYPE > *ptr = 
   new ListNode< NODETYPE >( value );
assert( ptr != 0 );
return ptr;
}

//Display the contents of the List
template< class NODETYPE >
void List< NODETYPE >::print() const
{
    if ( isEmpty() ) {
		cout << "The list is empty\n\n";
		return;
	}

	ListNode< NODETYPE > *currentPtr = firstPtr;

	cout << "The list is: ";

	while ( currentPtr != 0 ) {
		cout << currentPtr->data << ' ';
		currentPtr = currentPtr->nextPtr;
	}

	cout << "\n\n";

}

#endif
//-------------------------------------------------------------------------


#ifndef QUEUE_H
#define QUEUE_H

#include "list.h"

template< class QUEUETYPE >
class Queue: private List< QUEUETYPE > {
	public:
		void enqueue( const QUEUETYPE &d ) { insertAtBack( d ); }
		bool dequeue( QUEUETYPE &d )
		{ return removeFromFront( d ); }
		bool isQueueEmpty() const { return isEmpty(); }
		void printQueue() const { print(); }
};

#endif
//-------------------------------------------------------------------------


#include <iostream>
#include "queue.h"

using std::endl;

int main()
{
	Queue< int > intQueue;
	int dequeueInteger, i;
	cout << "processing an integer Queue" << endl;

	for ( i = 0; i < 4; i++ ) {
		intQueue.enqueue( i );
		intQueue.printQueue();
	}

	while ( !intQueue.isQueueEmpty() ) {
		intQueue.dequeue( dequeueInteger );
		cout << dequeueInteger << " dequeued" << endl;
		intQueue.printQueue();
	}

	Queue< double > doubleQueue;
	double val = 1.1, dequeueDouble;

	cout << "processing a double Queue" << endl;

	for ( i = 0; i < 4; i++ ) {
		doubleQueue.enqueue( val );
		doubleQueue.printQueue();
		val += 1.1;
	}

	while ( !doubleQueue.isQueueEmpty() ) {
		doubleQueue.dequeue( dequeueDouble );
		cout << dequeueDouble << " dequeued" << endl;
		doubleQueue.printQueue();
	}

	return 0;
}


The second problem is a program that is supposed to do a quicksort on a set of array type double and later do a bsearch.  I actually modified the actual program into a class file.  I'm actually weak at class and i hope you can help me. Below is the code:

#include <iostream.h>
#include <algorithm>

//class quicksort

class qsort
{
public:
	int compare(const void*, const void*);
	//qsort (list, 10, sizeof(int), compare);	//error
public:
	int list;
	int element;

};

//class bsearch

class bsearch
{
public:
	int compare(const void*, const void*);
	
public:
	double list;
	int element;
	double key;

};

int main()
{

	double list[10] = {9.2,5.1,2.6,8.5,1.7,7.1,3.2,6.3,4.6,0.1};
	double key = 3;

	//display unsorted list

	for (int element = 0; element <= 9; element++)
	{
		cout << list[element] << " ";
	}

	cout << endl;
	qsort (list, 10, sizeof(int), compare);	//error

	//display sorted list

	for (element = 0; element <= 9; element++)
	{
		cout << list[element] << " ";
	}

	//displays whether the number in the array or not

	/*if (bsearch(&key,list,10,sizeof(int),compare))	//error
	{
		cout<<key<<" is in the array"<<endl;	//number in array
	}
	else
	{
		cout << key <<" is NOT in the array2" <<endl;	//number not in array
	}*/

	return 0;

}

int compare1(const void* a_PTR, const void* b_PTR)
{
	return *((int*)a_PTR) - *((int*)b_PTR);
}

Thank you for your help.

Last edited by alc6379 : Oct 26th, 2004 at 12:17 pm.

•

Join Date: Sep 2004

Posts: 6,585

Reputation: Narue has much to be proud of

Rep Power: 31

Solved Threads: 501

Narue

Offline

Expert Meanie

Re: Error in c++ program. urgent

Oct 24th, 2004

>If you can just help me debug it
I'll help, but I'm not going to do it for you. Debugging is what the majority of programming is, so if I did it for you then you would learn nothing. As it is, you didn't specify what the error was in the first program, and I have better things to do than figure out what you think is wrong with it then tell you so that you can claim m4d debugging sk1llz. :rolleyes:

>qsort (list, 10, sizeof(int), compare); //error
You can't call a function in a class definition.

>if (bsearch(&key,list,10,sizeof(int),compare)) //error
Is the error "Unrecognized function" or something similar? Tell us what the errors are! And include <cstdlib> because that's where qsort and bsearch are declared.

I'm here to prove you wrong.

•

Join Date: Oct 2004

Posts: 3

Reputation: Midnight Skulke is an unknown quantity at this point

Rep Power: 0

Solved Threads: 0

Midnight Skulke Midnight Skulke is offline

Offline

Newbie Poster

Re: Error in c++ program. urgent

Oct 25th, 2004

For the first problem that is about queues. I have debug it and when I compile the program there is no error or warning but when i build it it says 3 errors. Below is the modified code and the errors
Code:

Help with Code Tags

(Toggle Plain Text)

//listnd.h
//ListNode template definition

#ifndef LISTND_H
#define LISTND_H

template< class NODETYPE > class List;	//  forward declaration

template<class NODETYPE>
class ListNode {
	friend class List< NODETYPE >;	//  make List a friend
	public:
		ListNode( const NODETYPE & );	//  constructor
		NODETYPE getData() const;	//  return data in the node
	private:
		NODETYPE data;	//  data
		ListNode< NODETYPE > *nextPtr;	//  next node in the list
};

//  Constructor
template<class NODETYPE>
ListNode< NODETYPE >::ListNode( const NODETYPE &info )
: data( info ), nextPtr( 0 ) { }

//  Return a copy of the data in the node
template< class NODETYPE >
NODETYPE ListNode< NODETYPE >::getData() const { return data; }

#endif

//  list.h
//  Template List class definition

#ifndef LIST_H
#define LIST_H

#include <iostream>
#include <cassert>
#include "listnd.h"

using std::cout;

template< class NODETYPE >
class List {
public:
	List();	//  constructor
	~List();	//  destructor
	void insertAtFront( const NODETYPE & );
	void insertAtBack( const NODETYPE & );
	bool removeFromFront( NODETYPE & );
	bool removeFromBack ( NODETYPE & );
	bool isEmpty() const;
	void print() const;
private:
	ListNode< NODETYPE > *firstPtr;	//  pointer to first node
	ListNode< NODETYPE > *lastPtr;	//  pointer to last node

	//  Utility function to allocate a new node
	ListNode< NODETYPE > *getNewNode( const NODETYPE & );
};

//  Default constructor
template< class NODETYPE >
List< NODETYPE >::List() : firstPtr( 0 ), lastPtr( 0 ) { }

//  Destructor
template< class NODETYPE >
List< NODETYPE >::~List()
{
	if ( !isEmpty() ) {	//  List is not empty
		cout << "Destroying nodes...\n";

		ListNode< NODETYPE > *currentPtr = firstPtr, *tempPtr;

		while ( currentPtr != 0 ) {	//  delete remaining nodes
			tempPtr = currentPtr;
			cout << tempPtr->data << '\n';
			currentPtr = currentPtr->nextPtr;
			delete tempPtr;
		}
	}

	cout << "All nodes destroyed\n\n";
}

//  Insert a node at the front of the list
template< class NODETYPE >
void List< NODETYPE >::insertAtFront( const NODETYPE &value )
{
	ListNode< NODETYPE > *newPtr = getNewNode( value );

	if ( isEmpty() )	//  List is empty
		firstPtr = lastPtr = newPtr;
	else {
		newPtr->nextPtr = firstPtr;
		firstPtr = newPtr;
	}
}

//  Insert a node at the back of the list
template< class NODETYPE >
void List< NODETYPE >::insertAtBack( const NODETYPE &value )
{
	ListNode< NODETYPE > *newPtr = getNewNode( value );

	if ( isEmpty() )	//  List is empty
		firstPtr = lastPtr = newPtr;
	else {
		lastPtr->nextPtr = newPtr;
		lastPtr = newPtr;
	}
}

//  Delete a node from the front of the list
template< class NODETYPE >
bool List< NODETYPE >::removeFromBack( NODETYPE &value )
{
	if ( isEmpty() )
		return return;	//  delete unsuccessful
	else {
		ListNode< NODETYPE > *tempPtr = lastPtr;

		if ( firstPtr == lastPtr )
			firstPtr = lastPtr = 0;
		else {
			ListNode< NODETYPE > *currentPtr = firstPtr;

			while ( currentPtr->nextPtr != lastPtr )
				currentPtr = currentPtr->nextPtr;

			lastPtr = currentPtr;
			currentPtr->nextPtr = 0;
		}

		value = tempPtr->data;
		delete tempPtr;
		return return;	//  delete successful
	}
}

//  Is the List empty?
template< class NODETYPE >
bool List< NODETYPE >::isEmpty() const
{ return firstPtr == 0; }

//  return a pointer to a newly allocated node
template< class NODETYPE >
ListNode< NODETYPE > *List< NODETYPE >::getNewNode( const NODETYPE &value )
{
	ListNode< NODETYPE > *ptr = new ListNode< NODETYPE >( value );
	assert( ptr != 0 );
	return ptr;
}

//  Display the contents of the List
template< class NODETYPE >
void List< NODETYPE >::print() const
{
	if ( isEmpty() ) {
		cout << "The list si empty\n\n";
		return;
	}

	ListNode< NODETYPE > *currentPtr = firstPtr;

	cout << "The list is: ";

	while ( currentPtr != 0 ) {
		cout << currentPtr->data << ' ';
		currentPtr = currentPtr->nextPtr;
	}

	cout << "\n\n";
}

#endif

//  queue.h
//  Queue class template definition
//	Derived from class List
#ifndef QUEUE_H
#define QUEUE_H

#include "list.h"

template< class QUEUETYPE >
class Queue: private List< QUEUETYPE > {
	public:
		void enqueue( const QUEUETYPE &d ) { insertAtBack( d ); }
		bool dequeue( QUEUETYPE &d )
		{  return removeFromFront( d ); }
		bool isQueueEmpty() const { return isEmpty(); }
		void printQueue() const { print(); }
};

#endif


#include <iostream>
#include "queue.h"

using std::endl;

int main()
{
	Queue< int > intQueue;
	int dequeueInteger, i;
	cout << "processing an integer Queue" << endl;

	for ( i = 0; i < 4; i++ ) {
		intQueue.enqueue( i );
		intQueue.printQueue();
	}

	while ( !intQueue.isQueueEmpty() ) {
		intQueue.dequeue( dequeueInteger );
		cout << dequeueInteger << " dequeued" << endl;
		intQueue.printQueue();
	}

	Queue< double > doubleQueue;
	double val = 1.1, dequeueDouble;

	cout << "processing a double Queue" << endl;

	for ( i = 0; i < 4; i++ ) {
		doubleQueue.enqueue( val );
		doubleQueue.printQueue();
		val += 1.1;
	}

	while ( !doubleQueue.isQueueEmpty() ) {
		doubleQueue.dequeue( dequeueDouble );
		cout << dequeueDouble << " dequeued" << endl;
		doubleQueue.printQueue();
	}

	return 0;
}

//listnd.h
//ListNode template definition

#ifndef LISTND_H
#define LISTND_H

template< class NODETYPE > class List;	//  forward declaration

template<class NODETYPE>
class ListNode {
	friend class List< NODETYPE >;	//  make List a friend
	public:
		ListNode( const NODETYPE & );	//  constructor
		NODETYPE getData() const;	//  return data in the node
	private:
		NODETYPE data;	//  data
		ListNode< NODETYPE > *nextPtr;	//  next node in the list
};

//  Constructor
template<class NODETYPE>
ListNode< NODETYPE >::ListNode( const NODETYPE &info )
: data( info ), nextPtr( 0 ) { }

//  Return a copy of the data in the node
template< class NODETYPE >
NODETYPE ListNode< NODETYPE >::getData() const { return data; }

#endif

//  list.h
//  Template List class definition

#ifndef LIST_H
#define LIST_H

#include <iostream>
#include <cassert>
#include "listnd.h"

using std::cout;

template< class NODETYPE >
class List {
public:
	List();	//  constructor
	~List();	//  destructor
	void insertAtFront( const NODETYPE & );
	void insertAtBack( const NODETYPE & );
	bool removeFromFront( NODETYPE & );
	bool removeFromBack ( NODETYPE & );
	bool isEmpty() const;
	void print() const;
private:
	ListNode< NODETYPE > *firstPtr;	//  pointer to first node
	ListNode< NODETYPE > *lastPtr;	//  pointer to last node

	//  Utility function to allocate a new node
	ListNode< NODETYPE > *getNewNode( const NODETYPE & );
};

//  Default constructor
template< class NODETYPE >
List< NODETYPE >::List() : firstPtr( 0 ), lastPtr( 0 ) { }

//  Destructor
template< class NODETYPE >
List< NODETYPE >::~List()
{
	if ( !isEmpty() ) {	//  List is not empty
		cout << "Destroying nodes...\n";

		ListNode< NODETYPE > *currentPtr = firstPtr, *tempPtr;

		while ( currentPtr != 0 ) {	//  delete remaining nodes
			tempPtr = currentPtr;
			cout << tempPtr->data << '\n';
			currentPtr = currentPtr->nextPtr;
			delete tempPtr;
		}
	}

	cout << "All nodes destroyed\n\n";
}

//  Insert a node at the front of the list
template< class NODETYPE >
void List< NODETYPE >::insertAtFront( const NODETYPE &value )
{
	ListNode< NODETYPE > *newPtr = getNewNode( value );

	if ( isEmpty() )	//  List is empty
		firstPtr = lastPtr = newPtr;
	else {
		newPtr->nextPtr = firstPtr;
		firstPtr = newPtr;
	}
}

//  Insert a node at the back of the list
template< class NODETYPE >
void List< NODETYPE >::insertAtBack( const NODETYPE &value )
{
	ListNode< NODETYPE > *newPtr = getNewNode( value );

	if ( isEmpty() )	//  List is empty
		firstPtr = lastPtr = newPtr;
	else {
		lastPtr->nextPtr = newPtr;
		lastPtr = newPtr;
	}
}

//  Delete a node from the front of the list
template< class NODETYPE >
bool List< NODETYPE >::removeFromBack( NODETYPE &value )
{
	if ( isEmpty() )
		return return;	//  delete unsuccessful
	else {
		ListNode< NODETYPE > *tempPtr = lastPtr;

		if ( firstPtr == lastPtr )
			firstPtr = lastPtr = 0;
		else {
			ListNode< NODETYPE > *currentPtr = firstPtr;

			while ( currentPtr->nextPtr != lastPtr )
				currentPtr = currentPtr->nextPtr;

			lastPtr = currentPtr;
			currentPtr->nextPtr = 0;
		}

		value = tempPtr->data;
		delete tempPtr;
		return return;	//  delete successful
	}
}

//  Is the List empty?
template< class NODETYPE >
bool List< NODETYPE >::isEmpty() const
{ return firstPtr == 0; }

//  return a pointer to a newly allocated node
template< class NODETYPE >
ListNode< NODETYPE > *List< NODETYPE >::getNewNode( const NODETYPE &value )
{
	ListNode< NODETYPE > *ptr = new ListNode< NODETYPE >( value );
	assert( ptr != 0 );
	return ptr;
}

//  Display the contents of the List
template< class NODETYPE >
void List< NODETYPE >::print() const
{
	if ( isEmpty() ) {
		cout << "The list si empty\n\n";
		return;
	}

	ListNode< NODETYPE > *currentPtr = firstPtr;

	cout << "The list is: ";

	while ( currentPtr != 0 ) {
		cout << currentPtr->data << ' ';
		currentPtr = currentPtr->nextPtr;
	}

	cout << "\n\n";
}

#endif

//  queue.h
//  Queue class template definition
//	Derived from class List
#ifndef QUEUE_H
#define QUEUE_H

#include "list.h"

template< class QUEUETYPE >
class Queue: private List< QUEUETYPE > {
	public:
		void enqueue( const QUEUETYPE &d ) { insertAtBack( d ); }
		bool dequeue( QUEUETYPE &d )
		{  return removeFromFront( d ); }
		bool isQueueEmpty() const { return isEmpty(); }
		void printQueue() const { print(); }
};

#endif


#include <iostream>
#include "queue.h"

using std::endl;

int main()
{
	Queue< int > intQueue;
	int dequeueInteger, i;
	cout << "processing an integer Queue" << endl;

	for ( i = 0; i < 4; i++ ) {
		intQueue.enqueue( i );
		intQueue.printQueue();
	}

	while ( !intQueue.isQueueEmpty() ) {
		intQueue.dequeue( dequeueInteger );
		cout << dequeueInteger << " dequeued" << endl;
		intQueue.printQueue();
	}

	Queue< double > doubleQueue;
	double val = 1.1, dequeueDouble;

	cout << "processing a double Queue" << endl;

	for ( i = 0; i < 4; i++ ) {
		doubleQueue.enqueue( val );
		doubleQueue.printQueue();
		val += 1.1;
	}

	while ( !doubleQueue.isQueueEmpty() ) {
		doubleQueue.dequeue( dequeueDouble );
		cout << dequeueDouble << " dequeued" << endl;
		doubleQueue.printQueue();
	}

	return 0;
}

Error:

1. T2.OBJ : error LNK2001: unresolved external symbol "public: bool __thiscall List<int>::removeFromFront(int &)" (?removeFromFront@?$List@H@@QAE_NAAH@Z)

2. T2.OBJ : error LNK2001: unresolved external symbol "public: bool __thiscall List<double>::removeFromFront(double &)" (?removeFromFront@?$List@N@@QAE_NAAN@Z)

3. Debug/T2.exe : fatal error LNK1120: 2 unresolved externals

Honestly speaking i don't have a clue what this means. I tried going through the whole program again and again. Checking through to see what the problem and i can't find it. ( note: T2 is the name of the program. T2.cpp ). Anyone can explain to me on how to handle this?

:mad:

Last edited by alc6379 : Oct 26th, 2004 at 12:17 pm.

•

Join Date: Sep 2004

Posts: 6,585

Reputation: Narue has much to be proud of

Rep Power: 31

Solved Threads: 501

Narue

Offline

Expert Meanie

Re: Error in c++ program. urgent

Oct 26th, 2004

>Honestly speaking i don't have a clue what this means.
It means you didn't define removeFromFront for List. You declared the member function, but because it was never defined, the linker complains when it tries to find it.

I'm here to prove you wrong.

•

Join Date: Dec 2003

Location: Nashville, TN

Posts: 2,336

Reputation: alc6379 has a spectacular aura about

Rep Power: 12

Solved Threads: 102

alc6379

Offline

Cookie... That's it

Re: Error in c++ program

Oct 26th, 2004

Midnight Skulke:

Just a couple of FYIs when posting on the forums here:

Firstly, I removed the word "urgent" from your thread title. You post is no more urgent than anyone else's here, and it's rude to assume that it is, just because you have a deadline.

Second, we should enforce this for everyone, but it's especially important when you're posting such long code snippets. Please embed your code in Vbulletin code tags. It's just like HTML; just take your code, and put a [ code] tag at the beginning, and a [ /code] tag at the end. (Remove the space after each [ in the tag-- that's the only way I could get the forum to display the tags.

Alex Cavnar, aka alc6379

•

Join Date: Oct 2004

Posts: 3

Reputation: Midnight Skulke is an unknown quantity at this point

Rep Power: 0

Solved Threads: 0

Midnight Skulke Midnight Skulke is offline

Offline

Newbie Poster

Re: Error in c++ program

Oct 27th, 2004

Hey thanks for the tips. The second problem is the quicksort and bsearch problem. I tried to declare but i'm not sure how to do it. I tried but everytime I run it, it keep saying undeclared idetifier. So can anyone tell me how to solve this:
[ code]
#include <iostream.h>
#include <algorithm>
#include <stdlib.h>

//class quicksort

class qsort
{
public:
int compare(const void*, const void*);

public:
int list;
int element;
//int compare2;
};

//class bsearch

class bsearch
{
public:
int compare(const void*, const void*);

public:
int list;
int element;
int key;

};

int main()
{

int list[10] = {9,5,2,8,1,7,3,6,4,0};
int key = 3;

//display unsorted list

for (int element = 0; element <= 9; element++)
{
cout << list[element] << " ";
}

cout << endl;

qsort (list, 10, sizeof(int), compare1); //error

//display sorted list

for (element = 0; element <= 9; element++)
{
cout << list[element] << " ";
}

//displays whether the number in the array or not

if (bsearch(&key,list,10,sizeof(int), compare2)) //error
{
cout<<key<<" is in the array"<<endl; //number in array
}
else
{
cout << key <<" is NOT in the array2" <<endl; //number not in array
}

return 0;

}

int compare3(const void* a_PTR, const void* b_PTR)
{
return *((int*)a_PTR) - *((int*)b_PTR);
}[ /code]

As you can see the code above, where the remark error is it says compare1 and compare2 undeclare identifier. I tried identifying at private and public as int compare1 and int compare2 but it still gives this error. can you give me a example along explanation Sorry but i'm really weak in C++.

•

Join Date: Sep 2004

Posts: 6,585

Reputation: Narue has much to be proud of

Rep Power: 31

Solved Threads: 501

Narue

Offline

Expert Meanie

Re: Error in c++ program

Oct 27th, 2004

>I tried to declare but i'm not sure how to do it.
They're already declared in <cstdlib>. If you include the header then you can use the functions, there's no need to try reusing standard names as user defined class names.

I'm here to prove you wrong.