What is a stack in c plus plus?

Answer 1

You don't say which operation you wish to perform, however a stack has relatively few members:

construct: e.g. default and copy (C++11 includes move construct)

operator=: copy assignment (C++11 includes move assignment)

empty: test whether the stack is empty or not

pop: extract the top element from the stack

push: insert an element on top of the stack

size: return the size of the stack, count of elements

top (return the top element)

Additional members since C++11:

emplace: construct and push a new element from argument

swap: exchange elements with another stack

Non-member operator overloads are limited to the standard relational operators (e.g. ==, !=, <, <=, > and >=).

Stacks are typically used in backtracking algorithms because the last element pushed becomes the top element and is therefore the first element to be popped. Usually referred to as a LIFO (last in first out) sequence.

An example usage of a stack:

#include<iostream>

#include<stack>

#include<string>

#include<cassert>

int main ()

{

std::stack<std::string> mystack;

assert (mystack.empty());

mystack.push ("First element");

mystack.push ("Second element");

assert (mystack.size()==2);

std::cout << "mystack contains:\n";

while (!mystack.empty())

{

std::cout << mystack.top() << '\n';

mystack.pop();

}

}

Answer 2

Stack has various applications one the most common uses is to reverse the order of the data, as we just saw this is what stack is known for, it is also used for backtracking in computer games and various other applications. Converting an infix expression to a postfix expression and evaluating a post fix expressions are two common tasks easily accomplished by stack.

Answer 3

There are no advantages of stacks in data structures per se. Data structures and data container types must be chosen to mee the requirements and constrains of the algorithm which uses them.

Characteristic for a stack is that it supports only a last-in-first-out operation with constant insertion and removal time. One item A can be added, then one item B can be added, but A cannot be removed before B is removed. A stack data structure can be compared with a stack of plates, where plates can only be added to and removed from the top of the stack.

In standard C++, many implementations of a stack are based on implementations of the vector container supplied with the standard template library, which supports push and pop operations in the manner described above.

Many tools also support degenerated stacks. A degenerated, or enhanced, stack might support push and pop operations from both ends, or support a notion of priority among stacked items.

Answer 4

A collection of items, only you can only Pop + Push the stack. Due to the way the stack works, the first item you add to the stack will be the last item off of the stack.

When you "Push" an item onto a stack, you place it at the top. When you "Pop" an item off of the stack, you take it off and can use that item's value. You can also "Peek" into the stack (i'm not sure if you can do this in C though) to see what's on top.

You can't get any items below the first one without taking the first one off first.

Example stack:

• Item 1
• Item 2
• Item 3
• Item 4
• Item 5

If I wanted to use Item 1, I could use Peek. If I wanted to get to item 2, I would have to remove Item 1 first.

Stacks are used for quite a few things but often you won't need them as arrays are more appropriate for that situation.

http://en.wikipedia.org/wiki/Stack_%28data_structure%29

Answer 5

There is no need to implement a stack. The std::vector container class already provides push and pop methods. If the elements are different classes, simply derive those elements from a common base class.

Answer 6

Stacks are useful when you need a last in, first out list (LIFO list). Stacks can be likened to a stack of plates. The last plate added to the stack is the first to be used. Its opposing structure, the first in, first out list (FIFO list) can be likened to a queue of people waiting to be served. The first person in the queue is the first to be served.

The call stack is a key structure in C++. We use it without realising it, but it's there all the same. Every time we make a function call, we "push" the return address of the instruction following the function call onto the stack. Control is then passed to the function and, when it finishes executing, the return address is "popped" off the stack and control returned to that address.

Since a function call pushes the return address onto the stack, but does not pop it off until it has completed execution, functions that call themselves recursively can end up consuming the limited space available (followed by an out of memory error). In extreme cases of recursion, the only options are to increase the stack space (memory permitting), or to alter the function to an iterative implementation rather than a deeply recursive one.

Call stacks are also used to pass parameters to functions (by moving the top of the stack to accommodate them), as well as for storage of local variables, the evaluation stack, the thispointer in objects, amongst others. Some values may be placed in registers, but there are few registers to play with, so the call stack provides additional storage when required.

Answer 7

A stack is a container object, similar to a queue except that where a queue has a first in, first out data structure, a stack has a last in, first out data structure. Stacks are typically used in backtracking algorithms as they allow us to retrace our steps. The function call mechanism depends on a stack; no matter how deeply nested a function call is, we can always find our way back to the function's caller.

Answer 8

Stacks are predominantly used in backtracking algorithms. They allow us to retrace our steps in the reverse order we performed those steps.