template stack

hello , i am new in c++ and i 'm strive to write a simple template stack to learn templates and stacks ...

i 'm using visual studio C++ express 2008 to write it . the compiler doesn't give me any error but when i run the the program i get an expression _block_type_is_valid phead- nblockuse .

this is my source code

PS : sorry for my bad english . and thanks for your help . if you see any other problem plz tell it :)

--------------------------------------

 
// -----------------------------this is the test.cpp-------------
#include<iostream>
#include"DStack.cpp"
using namespace std;

 
void main()
{
	int n ,i ,item ;
DStack<int> inter;
cin >> n;
for( i=0; i< n; i++ )
{
cin >> item;
inter.Push(item);
}
}

//--------------Dstack.h--------------------------

//------------------------------------------
#ifndef D_DSTACK_H
#define	D_DSTACK_H
//----------------------------------------
template< class T>
class DStack
{
	protected:
		class DStackNode
		{
		public:
			// This is the strucure of a node.
		T Item;
		DStackNode *Next;

        DStackNode()
		{
			Next = NULL;
		}
		DStackNode(const T &TheItem)
		{
			Item = TheItem;
			Next = NULL;
        }
		DStackNode(const T &TheItem, const DStackNode *NextNode)
		{
			Item = TheItem;
			Next = NextNode;
		}
		};
DStackNode *StackTop;
void Deallocate();

private:
  

public:
	DStack(); //  This  Is Our Constructor
	DStack(const DStack<T> &AStack);// ThisIsOurCopyConstructor
    ~DStack(); //This  Is Our Destructor
    
	//FunctionOfDStack
	
	bool IsEmpty()const { return( StackTop == 0 ); }
	void Push(const T &x);
	bool Pop(T *TopItem); 
	T Pop( T &x);
    bool Top( T *TopItem); 
    T& Top() const;

    DStack<T> operator=(const DStack<T> &S);
	int  StackCounter();
};
#endif

//------------------------------Dstack.cpp---------------------


//----------------------------------
#include<iostream>
#include"Dstack.h"
using namespace std;
//----------------------------------

//--------SODeallocation------------
template<class T >
void DStack<T>::Deallocate()
{
DStackNode *ThisPtr, *NextPtr;

	//Positioning ThisPtr @ Top 
	ThisPtr= StackTop;
while( ThisPtr != 0 )
{
	NextPtr=ThisPtr->Next;
	delete ThisPtr;
	ThisPtr = NextPtr ; 
}
}

//---------EODeallocation-------------

//---------SOCunstractor-------------
template<class T>
DStack<T>::DStack()
{  
	StackTop=0; // initialize 
}
//---------EOCunstractor--------------


//---------SOCopyConstractor----------
template<class T>
DStack<T>::DStack(const DStack<T> &AStack) 
{
StackNode *Clone ,*Original;
Original = AStack.Top;
if (Original == NULL) {
		TopNode = NULL;
	} else {		
		TopNode = Clone = new StackNode(Original ->Item);
		while (Original ->Next != NULL){
			Original = Original->Next;
			Clone ->Next = new StackNode(Original ->Item);
			Clone = Clone ->Next ;
		}
	}
}
//----------EOCopyConstrator-------------


//----------SODestructor----------------
template< class T >
DStack<T>::~DStack()
{
  Deallocate();
}

//------------EODestructor----------------


//------------SOPushFunction--------------
template< class T >
void DStack<T>::Push(const T &x )
{
DStackNode *NewNode, *Temp;
NewNode = new DStackNode;
NewNode->Item = x;
if (IsEmpty())
 {
	StackTop = NewNode;
	NewNode->Next = 0;

} else {
	NewNode->Next = StackTop;
	Temp = NewNode;
	delete StackTop;
	StackTop = Temp;

 }
}
//-----------EOPushFunction----------------------



//--------------SOBoolPop---------------
template<class T>
bool  DStack< T >::Pop(T *TopItem) 
{
	DStackNode *ptr = NULL;
	if(!StackTop)
	{ 
     	 return false;
	} else {
      ptr = StackTop;
	  StackTop = StackTop->Next;
	  TopItem = ptr->Item;
	  delete ptr;
	  return true;
	}
	  
}
//------------EOBoolPop------------------


//-----------SOPopFunction--------------
template< class T>
T DStack< T >::Pop( T &x )
{  DStackNode *Temp;

if ( IsEmpty())
{
	cout<<"the stack is empty"<<endl<<endl;
} else {
		 x = StackTop->Item;
      Temp = StackTop->Next;
      delete StackTop;
      StackTop = Temp;
}
}
//-----------EOPopFunction---------------

//----------SOTopFunction( *TopItem)------------------------
bool DStack< T >::Top(T *TopItem)
{
 DStackNode *ptr = NULL;
 if(!StackTop)
 {
	 return false;
 } else {
      
	 return true ;
 }
}

//----------EOTopFunction( *TopItem)----------------------
//---------SOItemTopExtraction( T TOP)------
template< class T>
T& DStack< T >::Top() const
{  

if ( IsEmpty())
  {
    cout<<"the stack is empty"<<endl<<endl;

  } else {
    
	return StackTop; 
  }
}
//--------------EOItemTopExtraction(T TOP)---------------------------------




//------------SOoverLoad = -------------------------------------------------
/*
template<class T>
DStack<T>::operator =(const DStack<T> &X)
{
DStackNode  *Original,*NewTop ,*NewCopy, X_Node;
X_Node = X.Top;
if(X_Node == NULL){
	NewTop = NULL;
} else {
	NewTop = new DStackNode(X_Node->Item);
	NewCopy = NewTop;
	while( Original->Next != NULL;){
		Original = Original->Next;
		NewCopy->Next = new DStackNode(Original->Item);
		NewCopy = NewCopy->Item;
	}
}
while(!IsEmpty()){
	//pop();
}

//StackTop=NewTop;

}

//------------EOoverLoad = -----------------------------------------
*/

//---------SOStackCounsterFunction----------------------------------------------
template< class T>
int DStack<T>::StackCounter()
{
 int Counter=0;
 DStackNode *ThisPtr, *NextPtr;

 while( ThisPtr != 0 )
		{
		NextPtr=ThisPtr->Next;
		Counter++;
		ThisPtr = Next ; 
		}

 return Counter;
}
//---------EOStackCounterFunction-------------------------------------

thanks for your time :)

Last edited on

guestgulkan (2942)

This doesn't look right

template< class T >
void DStack<T>::Push(const T &x )
{
DStackNode *NewNode, *Temp;
NewNode = new DStackNode;
NewNode->Item = x;
if (IsEmpty())
 {
	StackTop = NewNode;
	NewNode->Next = 0;

} else { //Running it through in my mind - This bit does not seem right
	NewNode->Next = StackTop;
	Temp = NewNode;
	delete StackTop;
	StackTop = Temp;

 }
}

humanfly (5)

thanks guestgulkan i think tha the correct is

template< class T >
void DStack<T>::Push(const T &x )
{
DStackNode *NewNode, *Temp;

NewNode = new DStackNode;
NewNode->Item = x;

if (IsEmpty())
 {
	StackTop = NewNode;
	NewNode->Next = 0;

} else { 
	 
     NewNode->Next = StackTop;
      StackTop = NewNode;


 }
}

but i still i 'm getting the expression _block_type_is_valid phead- nblockuse

Last edited on

guestgulkan (2942)

I never got further than that - as I came across that problem straight away.

guestgulkan (2942)

There are a number of errors in the code you posted which will take some time to go through.

humanfly (5)

could you plz tell me where you see these errors , so i can try to correct them as the above :) .
thanks for your time you spend .

klkvgupta (4)

Donot seperate the template code into cpp and header file. Compilers are not mature enough to handle that. I tried your example using gcc compiler. I could run the program to successfull completion:
#include<iostream>
#include "DStack.h"
using namespace std;

int main()
{
int n ,i ,item ;
DStack<int> inter;
cin >> n;
for( i=0; i< n; i++ )
{
cin >> item;
inter.Push(item);
}
return 0;
}
//--------------Dstack.h--------------------------

//------------------------------------------
#ifndef D_DSTACK_H
#define D_DSTACK_H

using namespace std;
//----------------------------------------
template< class T>
class DStack
{
protected:
class DStackNode
{
public:
// This is the strucure of a node.
T Item;
DStackNode *Next;

DStackNode()
{
Next = NULL;
}
DStackNode(const T &TheItem)
{
Item = TheItem;
Next = NULL;
}
DStackNode(const T &TheItem, const DStackNode *NextNode)
{
Item = TheItem;
Next = NextNode;
}
};
DStackNode *StackTop;
void Deallocate();

private:

public:
DStack(); // This Is Our Constructor
DStack(const DStack<T> &AStack);// ThisIsOurCopyConstructor
~DStack(); //This Is Our Destructor

//FunctionOfDStack

bool IsEmpty()const { return( StackTop == 0 ); }
void Push(const T &x);
bool Pop(T *TopItem);
T Pop( T &x);
bool Top( T *TopItem);
T& Top() const;

DStack<T> operator=(const DStack<T> &S);
int StackCounter();
};

//--------SODeallocation------------
template<class T >
void DStack<T>::Deallocate()
{
DStackNode *ThisPtr, *NextPtr;

//Positioning ThisPtr @ Top
ThisPtr= StackTop;
while( ThisPtr != 0 )
{
NextPtr=ThisPtr->Next;
delete ThisPtr;
ThisPtr = NextPtr ;
}
}

//---------EODeallocation-------------

//---------SOCunstractor-------------
template<class T>
DStack<T>::DStack()
{
StackTop=0; // initialize
}
//---------EOCunstractor--------------

//---------SOCopyConstractor----------
template<class T>
DStack<T>::DStack(const DStack<T> &AStack)
{
DStackNode *Clone ,*Original, *TopNode;
Original = AStack.Top;
if (Original == NULL) {
TopNode = NULL;
} else {
TopNode = Clone = new DStackNode(Original ->Item);
while (Original ->Next != NULL){
Original = Original->Next;
Clone ->Next = new DStackNode(Original ->Item);
Clone = Clone ->Next ;
}
}
}
//----------EOCopyConstrator-------------

//----------SODestructor----------------
template< class T >
DStack<T>::~DStack()
{
Deallocate();
}

//------------EODestructor----------------

//------------SOPushFunction--------------
template< class T >
void DStack<T>::Push(const T &x )
{
DStackNode *NewNode, *Temp;
NewNode = new DStackNode;
NewNode->Item = x;
if (IsEmpty())
{
StackTop = NewNode;
NewNode->Next = 0;

} else {
NewNode->Next = StackTop;
Temp = NewNode;
delete StackTop;
StackTop = Temp;

}
}
//-----------EOPushFunction----------------------

//--------------SOBoolPop---------------
template<class T>
bool DStack< T >::Pop(T *TopItem)
{
DStackNode *ptr = NULL;
if(!StackTop)
{
return false;
} else {
ptr = StackTop;
StackTop = StackTop->Next;
TopItem = ptr->Item;
delete ptr;
return true;
}

}
//------------EOBoolPop------------------

//-----------SOPopFunction--------------
template< class T>
T DStack< T >::Pop( T &x )
{ DStackNode *Temp;

if ( IsEmpty())
{
cout<<"the stack is empty"<<endl<<endl;
} else {
x = StackTop->Item;
Temp = StackTop->Next;
delete StackTop;
StackTop = Temp;
}
}
//-----------EOPopFunction---------------

//----------SOTopFunction( *TopItem)------------------------
template< class T>
bool DStack< T >::Top(T *TopItem)
{
DStackNode *ptr = NULL;
if(!StackTop)
{
return false;
} else {

return true ;
}
}

//----------EOTopFunction( *TopItem)----------------------
//---------SOItemTopExtraction( T TOP)------
template< class T>
T& DStack< T >::Top() const
{

if ( IsEmpty())
{
cout<<"the stack is empty"<<endl<<endl;

} else {

return StackTop;
}
}
//--------------EOItemTopExtraction(T TOP)---------------------------------

//------------SOoverLoad = -------------------------------------------------
/*
template<class T>
DStack<T>::operator =(const DStack<T> &X)
{
DStackNode *Original,*NewTop ,*NewCopy, X_Node;
X_Node = X.Top;
if(X_Node == NULL){
NewTop = NULL;
} else {
NewTop = new DStackNode(X_Node->Item);
NewCopy = NewTop;
while( Original->Next != NULL;){
Original = Original->Next;
NewCopy->Next = new DStackNode(Original->Item);
NewCopy = NewCopy->Item;
}
}
while(!IsEmpty()){
//pop();
}

//StackTop=NewTop;

}

//------------EOoverLoad = -----------------------------------------
*/

//---------SOStackCounsterFunction----------------------------------------------
template< class T>
int DStack<T>::StackCounter()
{
int Counter=0;
DStackNode *ThisPtr, *NextPtr;

while( ThisPtr != 0 )
{
NextPtr=ThisPtr->Next;
Counter++;
ThisPtr = NextPtr ;
}

return Counter;
}
//---------EOStackCounterFunction-------------------------------------

#endif

humanfly (5)

thanks klkvgupta ,i put the Dstack.h and theDstack.cpp in one file and i run the program successfull . that was the problem i didn't get any expression now the only thing that matter is my code is correct.

Topic archived. No new replies allowed.