I notice a few things...

There's no need to declare push() and display() as being friends of abc, since abc has no protected members.

The designation of head and top is kind of confusing. Why not head and tail, or top and bottom?

The top variable isn't being updated, in any case. It looks as if you think that push() is updating the top pointer declared in main(), but it's really updating its own copy of the pointer.

The head variable should be initialized to NULL.

The static ctr variable has no use at all. You are only using it to check to see if the stack is empty, but you can just as easily do that by checking head (which should be NULL).

Hope this helps.

Your stack is a doubly linked list with restricted access to the links in the list. The links themselves need to do nothing (they could display their value if you want but other than display themselves they do nothing) so remove everything from abc but the member variables (and write a display method if you wish). The stack in this program is really called head, and head is really a pointer to the first link in the list, just like you have declared it. To use the list you have to have knowledge of at least one node in the list. Usually you would keep track of the first link in the list, but you could keep track of something else if you want.

When you display the list you don't want to change anything in the list, you just want to display the values stored in it. If you change the value of head as you display the list you will have to have some mechanism to remember what head really is pointing to before you do another function call. This adds another level of complexity to the program but would be doable if you insist. On the other hand, you wouldn't have to keep track of this new location if you have a policy saying head always points to the first link in the list so I will leave it alone when I display the list; instead I will use another abc pointer to run the list in the body of the function.

Stacks differ from doubly linked lists in that you are resticted by ensuring that the last link added is the first link removed. The easiest way to do this is to always add to the front of the list or to always add to the back of the list. If you always add/remove from the front of the list, then the address stored in head will have to change each time one of these operations is performed. If you always add/remove from the end of the list, then value in head may or may not change, depending on whether there is more than one link in the list or not. However, you will have to either keep track of the end of the list or run the list to find the end of the list every time you want to do one of these tasks. So pick your poison, state it clearly, and deal with it.

You also have some other decisions to make.

First you can use free standing functions to manipulate the stack as you do in the post, or you could create another class to encapsulate a stack. Each stack has variables, such as the first node in a linked list and the number of nodes in the list, and a number of methods that can manipulate the stack itself, such as add/remove a link, display link(s), etc. I think it makes sense to create a second class, but it's up to you.

Second, you can either declare your stack and the variables associated with your stack, like ctr, with global scope so it is accessable to all the functions that will use them---using global variables is frowned upon, OR you could declare them within main() and pass then back and forth among the various functions--which would be the prefered way. If you are passing them back and forth between freestanding functions, then you will want to pass the variables by reference to any function that could change the value of the variable, so any changes to the value in the variable is maintained after the function stops.

The stack is a lifo(last in first out) based sequential structure. I think you don't need a double link list to implment it, you can implement lifo based list directly.

C++ Syntax (Toggle Plain Text)

struct Node {
  int m_iVal;
  Node* m_pNext;
  Node(int const& iVal,m_pNext=0)
}

struct Node { int m_iVal; Node* m_pNext; Node(int const& iVal,m_pNext=0) }

if you've used the stack it provides three basic as well as standard functionality
push() to push the element on the top of stack
pop() to pop the element from the top
top() returns the top element;
there is no need for display function in the standard stack.
if you need that function
you should have written like that

C++ Syntax (Toggle Plain Text)

void display() 
{
//it uses 
while(HEAD) 
{ 
   while(HEAD) 
    {
        cout<<HEAD->top()<<endl;
        HEAD->pop();
     }
}

void display() { //it uses while(HEAD) { while(HEAD) { cout<<HEAD->top()<<endl; HEAD->pop(); } }

Your push function takes the pointer as an argument there is no need for that, and remove the friend from there.......
push should be member function.~! i.e. void push(int value) remember this pointer is always passed quitely to member function so no need to pass explicity and declare it as a friend and you are violating the OOP concept encapsulation by doing this.why you've used static counter.............if you declare push as a member function there is no need for that. also why don't you utilize HEAD variable for this.
your push function should be like this.

C++ Syntax (Toggle Plain Text)

void push(int value)
{
HEAD= new Node(value,HEAD);
//or its also fine
/* if(HEAD==0)
HEAD= new Node(value);
else {
Node* temp = new Node(value)
temp->m_pNext=HEAD;
HEAD=temp;
}*/
 
}

void push(int value) { HEAD= new Node(value,HEAD); //or its also fine /* if(HEAD==0) HEAD= new Node(value); else { Node* temp = new Node(value) temp->m_pNext=HEAD; HEAD=temp; }*/ }

you didn't include the another important function of stack i.e. pop() it simply releases the top element. it doesn't return the data.

C++ Syntax (Toggle Plain Text)

void pop() 
{
if(HEAD)
   {
      Node* temp = HEAD;
      HEAD=HEAD->m_pNext;
      delete HEAD;
    }
}

void pop() { if(HEAD) { Node* temp = HEAD; HEAD=HEAD->m_pNext; delete HEAD; } }

the last is top()

C++ Syntax (Toggle Plain Text)

void top() const {
return HEAD->m_iVal;
}

void top() const { return HEAD->m_iVal; }

Now i m giving you the sample code not complete for Stack using Doubly Link list, implement it completely........ Hope you got the idea.........

(Toggle Plain Text)

#include "stdafx.h"
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
struct Node{
  int m_iVal;
  Node* m_pNext;
  Node* m_pPrev;
   Node(int const& val,Node* pNext=0,Node* pPrev=0):m_iVal(val),m_pNext  (pNext),m_pPrevpPrev){}
};
class DList {
public:
  DList():m_HEAD(0),m_TAIL(0){}
  virtual ~DList()
 {
  while(m_HEAD)
    pop_back();
 
//don't forget to add 
//while(m_TAIL)
//pop_front()
  } 
 
//interface provided by double link List;
void push_back(int const& value);
void pop_back();
int back()const 
{
  return m_HEAD->m_iVal;
} 
//implement yourself 
void push_front(int const& value);
void pop_front();
int front();
 
private:
Node* m_HEAD; 
Node* m_TAIL; 
};
void DList::push_back(intconst& value)
{
   if(!m_HEAD) {
      m_TAIL = m_HEAD = new Node(value);
   }
   else {
           Node* temp=new Node(value);
           temp->m_pPrev=m_HEAD;
           m_HEAD->m_pNext=temp;
           m_HEAD=temp;
   }
}
void DList::pop_back()
{
      if(m_HEAD){
      Node* temp= m_HEAD;
      m_HEAD = m_HEAD->m_pPrev;
      delete temp;
}
else {
       cout<<"Nothing to Delete"<<endl;
}
}
class MyStack: public DList {
     //implement stack using the DList; just change the names of interfaces and call base class version :)
};
int main(int argc, char* argv[])
{
DList* dlist = new DList();
dlist->push_back(4);
dlist->push_back(2);
cout<<dlist->back()<<endl;
dlist->pop_back();
cout<<dlist->back()<<endl;
dlist->pop_back();
delete dlist;
return 0;
}

#include "stdafx.h" #include <iostream> using std::cout; using std::cin; using std::endl; struct Node{ int m_iVal; Node* m_pNext; Node* m_pPrev; Node(int const& val,Node* pNext=0,Node* pPrev=0):m_iVal(val),m_pNext (pNext),m_pPrevpPrev){} }; class DList { public: DList():m_HEAD(0),m_TAIL(0){} virtual ~DList() { while(m_HEAD) pop_back(); //don't forget to add //while(m_TAIL) //pop_front() } //interface provided by double link List; void push_back(int const& value); void pop_back(); int back()const { return m_HEAD->m_iVal; } //implement yourself void push_front(int const& value); void pop_front(); int front(); private: Node* m_HEAD; Node* m_TAIL; }; void DList::push_back(intconst& value) { if(!m_HEAD) { m_TAIL = m_HEAD = new Node(value); } else { Node* temp=new Node(value); temp->m_pPrev=m_HEAD; m_HEAD->m_pNext=temp; m_HEAD=temp; } } void DList::pop_back() { if(m_HEAD){ Node* temp= m_HEAD; m_HEAD = m_HEAD->m_pPrev; delete temp; } else { cout<<"Nothing to Delete"<<endl; } } class MyStack: public DList { //implement stack using the DList; just change the names of interfaces and call base class version :) }; int main(int argc, char* argv[]) { DList* dlist = new DList(); dlist->push_back(4); dlist->push_back(2); cout<<dlist->back()<<endl; dlist->pop_back(); cout<<dlist->back()<<endl; dlist->pop_back(); delete dlist; return 0; }

Wish you good luck (y)

Thanks Lerner , Azimuth0 and Laiq Ahmed for your help. I will be updating my program according to your inputs and would post if I have a problem .
Thanks

hi,
i tried implementing the stack with pop front , pop back ,push front and push back functions . well , i tried them separately and they worked , but i want a single stack performing all the functions , and here tow separate stacks are being created . so , i cant figure out how to make them into a single one by giving a link to the last element of stack using head and first element of stack using end.
Any suggestion or hint would be of great help. Also , any suggestion to optimize the code would be great.
heres the code
Thanks,
comwizz

Lists with push/pop restricted to head/end mimic functionality of double ended queues, aka dequeues (dequeues have some other properties too, but that's the guts of 'em). To me, head would indicate the first node in the list and end would indicate last node in list so there is just one list per "stack" or "dequeue" or whatever you are calling this container. When you pop/push to front it would change head (and end if less than two nodes in list) and when you pop/push to back it would change end (and head if less than two nodes in list). When popping first node onto list or removing second to last node from list, then head is same as end. If pop_back to a single node list, then end is hend->next (aka new node added) and if pop_front to single node list then end becomes head and head becomes head->previous (aka new node added), etc. If head != NULL then end != NULL either. If length == 1, then head == end. Following successful push/pop event head->previous will always be NULL and end->next will always be NULL.