STACKS AND QUEUES UNIT 2 DS THROUGH C++

C++ Templates Templates Part of the ongoing development of the C++ language Templates are the foundation of generic programming, which involves writing code in a way that is independent of any particular type. A template is a blueprint or formula for creating a generic class or a function. Integral part of the larger C++ Standard Library The Standard Template Library Easily create a large range of related functions or classes Function template - the blueprint of the related functions

Class Templates Class templates Format: Allow type-specific versions of generic classes Format: template <class T> class ClassName{ definition } Need not use "T", any identifier will work To create an object of the class, type ClassName< type > myObject; Example: Stack< double > doubleStack;

Template class functions Declared normally, but preceded by template<class T> Generic data in class listed as type T Binary scope resolution operator used Template class function definition: template<class T> MyClass< T >::MyClass(int size) { myArray = new T[size]; } Constructor definition - creates an array of type T

Class Templates and Non-type Parameters Can use non-type parameters in templates Default argument Treated as const Example: template< class T, int elements > Stack< double, 100 > mostRecentSalesFigures; Declares object of type Stack< double, 100> This may appear in the class definition: T stackHolder[ elements ]; //array to hold stack Creates array at compile time, rather than dynamic allocation at execution time

Classes can be overridden For template class Array, define a class named Array<myCreatedType> This new class overrides then class template for myCreatedType The template remains for unoverriden types

Templates and Inheritance A class template can be derived from a template class A class template can be derived from a non-template class A template class can be derived from a class template A non-template class can be derived from a class template

Templates and friends Friendships allowed between a class template and Global function Member function of another class Entire class friend functions Inside definition of class template X: friend void f1(); f1() a friend of all template classes friend void f2( X< T > & ); f2( X< int > & ) is a friend of X< int > only. The same applies for float, double, etc. friend void A::f3(); Member function f3 of class A is a friend of all template classes

friend classes friend void C< T >::f4( X< T > & ); C<float>::f4( X< float> & ) is a friend of class X<float> only friend classes friend class Y; Every member function of Y a friend with every template class made from X friend class Z<T>; Class Z<float> a friend of class X<float>, etc.

Templates and static Members Non-template class static data members shared between all objects Template classes Each class (int, float, etc.) has its own copy of static data members static variables initialized at file scope Each template class gets its own copy of static member functions

Templates to Represent Container Classes The C++ standard library: provides support for language features (memory management, RTTI) supplies info about implementation-dependent aspects (largest float value etc) supplies functions that cannot be implemented optimally in the language itself for every system (sqrt, memmove etc.) provides strings and I/O streams (with internationalization and localization support) provides a framework of containers (vectors, maps etc.) and generic algorithms (traversals, sorting, merging etc.) supports numerical computations (complex numbers, BLAS=Basic Linear Algebra Subprograms etc.) provides a framework for extending the provided facilities provides a common foundation for other libraries Framework of containers, algorithms and iterators is commonly referred as STL = Standard Template Library [Stepanov, 1994]

Containers DEFINITON [Container] A container is an object that holds other objects. Examples: list, vectors, stacks etc. Using abstract classes to provide a standard interface for containers and iterators – it doesn’t meet the efficiency requirements! (small functions, that cannot be inlined because they are virtual). Advantages of containers: simple and efficient each container provides a set of common operations; they can be used interchangeably wherever reasonable standard iterators are available for each container type-safe and homogeneous are non-intrusive (i.e. an object doesn’t need to have a special base class to be a member of the container) each container takes an argument called allocator, which can be used as a handle for implementing services for every container (persistence, I/O)

Basic containers: vector, list, deque. Other containers: stack, queue, priority queue (implemented using basic containers). Associative containers: map, multimap Almost containers: bitset, String, valarray

Abstract Data Type Abstract Data Type as a design tool Concerns only on the important concept or model No concern on implementation details. Stack & Queue is an example of ADT

Stack & Queue vs. Array Stack & Queue vs. Array Arrays are data storage structures while stacks and queues are specialized DS and used as programmer’s tools. Stack – a container that allows push and pop Queue - a container that allows enqueue and dequeue No concern on implementation details. In an array any item can be accessed, while in these data structures access is restricted. They are more abstract than arrays.

Stacks Allows access to only the last item inserted. An item is inserted or removed from the stack from one end called the “top” of the stack. This mechanism is called Last-In-First-Out (LIFO).

Last In First Out B A C B A D C B A E D C B A top D C B A top top top

Stack Applications Real life Pile of books Plate trays More applications related to computer science Program execution stack (read more from your text) Evaluating expressions

Stack ADT objects: a finite ordered list with zero or more elements. methods: for all stack  Stack, item  element, max_stack_size  positive integer Stack createS(max_stack_size) ::= create an empty stack whose maximum size is max_stack_size Boolean isFull(stack, max_stack_size) ::= if (number of elements in stack == max_stack_size) return TRUE else return FALSE Stack push(stack, item) ::= if (IsFull(stack)) stack_full else insert item into top of stack and return

Boolean isEmpty(stack) ::= if(stack == CreateS(max_stack_size)) return TRUE else return FALSE Element pop(stack) ::= if(IsEmpty(stack)) return else remove and return the item on the top f the stack.

Array-based Stack Implementation Allocate an array of some size (pre-defined) Maximum N elements in stack Bottom stack element stored at element 0 last index in the array is the top Increment top when one element is pushed, decrement after pop

Stack createS(max_stack_size) ::= #define MAX_STACK_SIZE 100 / Stack createS(max_stack_size) ::= #define MAX_STACK_SIZE 100 /* maximum stack size */ typedef struct { int key; /* other fields */ } element; element stack[MAX_STACK_SIZE]; int top = -1; Boolean isEmpty(Stack) ::= top< 0; Boolean isFull(Stack) ::= top >= MAX_STACK_SIZE-1;

Push void push(int *top, element item) { /* add an item to the global stack */ if (*top >= MAX_STACK_SIZE-1) { stack_full( ); return; } stack[++*top] = item; }

Pop element pop(int *top) { /* return the top element from the stack */ if (*top == -1) return stack_empty( ); /* returns and error key */ return stack[(*top)--]; }

The Towers of Hanoi A Stack-based Application GIVEN: three poles a set of discs on the first pole, discs of different sizes, the smallest discs at the top GOAL: move all the discs from the left pole to the right one. CONDITIONS: only one disc may be moved at a time. A disc can be placed either on an empty pole or on top of a larger disc.

void hanoi (int discs, Stack fromPole, Stack toPole, Stack aux) { Disc d; if( discs >= 1) { hanoi(discs-1, fromPole, aux, toPole); d = fromPole.pop(); toPole.push(d); hanoi(discs-1,aux, toPole, fromPole); }