Overview of the STL &Assorted C++ features

Junaed Sattar

November 19, 2008Lecture 12

The STL

Stands for Standard Template Library set of C++ template classes to provide

common programming data structures and functions

officially (from SGI's STL site): library of container classes, algorithms, and

iterators provides many of the basic algorithms and

data structures of computer science

Basic Characteristics of the STL

a generic library, meaning that its components are heavily parameterized: almost every component in the STL is a

template. make sure that you understand how

templates work in C++ before you use the STL!

Categories

Categorized in the following groupings Containers and algorithms

classes for containing (holding) other objects and related algorithms for data manipulations

Iterators generalization of pointers, which applies to any

object stored in container classes Concepts, Modeling, Refinement

rules about the set of types that may correctly be substituted for the formal template parameters

Utilities Miscellaneous utilities

Containers/Algorithms

Includes classes vector, list, deque, set, multiset, map, multimap, hash_set, hash_multiset, hash_map, and hash_multimap

Each of these classes is a template, and can be instantiated to contain any type of object

Generic algorithms manipulate data stored in these container objects

Container: Vector

Avoids managing dynamic memory by hand

vector<string> SS;

SS.push_back("The number is 10");SS.push_back("The number is 20");SS.push_back("The number is 30");

// Loop by indexfor( int ii=0; ii < SS.size(); ii++ ) {

cout << SS[ii] << endl;

}

Algorithm Example

// Reverse the elements in the Vector

reverse(v.begin(), v.end());

// Loop by index

for( int ii=0; ii < SS.size(); ii++ ) {

cout << SS[ii] << endl;

}

Outputs:

The number is 30

The number is 20

The number is 10

Iterators

STL class to represent position in an STL container i.e. objects that point to other objects

An iterator is declared to be associated with a single container class type i.e. to access a vector of strings, we require

an iterator to vector<string>

Types

input_iterator: Read values with forward movement.

output_iterator: Write values with forward movement.

forward_iterator : Read or write values with forward movement. These combine the functionality of input and output iterators with the ability to store the iterators value.

bidirectional_iterator: Read and write values with forward and backward movement.

random_iterator: Read and write values with random access. These are the most powerful iterators, combining the functionality of bidirectional iterators with the ability to do pointer arithmetic and pointer comparisons.

reverse_iterator: Either a random iterator or a bidirectional iterator that moves in reverse direction.

Iterators: Vector

vector<string> SS;

SS.push_back("The number is 10");SS.push_back("The number is 20");SS.push_back("The number is 30");

vector<string>::iterator cii;

for(cii=SS.begin(); cii!=SS.end(); cii++){ cout << *cii << endl;}

Another example

#include <iostream.h>#include <vector.h>#include <algo.h>#include <iterator.h>

int main (int argc, char *argv[]){int n = atoi (argv[1]); vector<int> v;

for( int i = 0; i < n; i++ ) v.push_back (i);

random_shuffle (v.begin(), v.end());

// print

copy( v.begin(), v.end(), ostream_iterator<int>( cout, "\n"));

}

Sort: STL Style

void sort( iterator start, iterator end );

void sort( iterator start, iterator end, StrictWeakOrdering cmp );

sorts the elements in the range [start,end) into ascending order

if strict weak ordering function object cmp is given, then it will be used to compare two objects instead of the < operator.

Example sort

vector<int> v;

sort( v.begin(), v.end() );

And also,

int array[] = { 23, -1, 9999, 0, 4 };

unsigned int array_size = 5;

sort( array, array+array_size );

Compare function

bool cmp( int a, int b ) {return a > b;

}

sort( v.begin(), v.end(), cmp );

Auto pointers

Pointers, but do not require explicit deallocation i.e. does not have to be “delete”-ed but only individual pointers, not arrays

again, this is a templated type similar to garbage collection in Java

Auto Pointer Example

#include <iostream>#include <memory>

using namespace std;class X {

public:X() { cout << "constructing\n"; }~X() { cout << "destructing\n"; }void f() { cout << "Inside f()\n"; }

};

int main() {auto_ptr<X> p1(new X), p2;p2 = p1; // transfer ownershipp2->f();X *ptr = p2.get(); // can assign to a normal pointerptr->f();return 0;}

More STL Reference

The STL Book (it's in the course outline) STL Homepage:

http://www.sgi.com/tech/stl/ Another tutorial on the STL

http://www.cs.brown.edu/people/jak/proglang/cpp/stltut/

Namespaces

allows grouping of entities (classes, functions, variables etc) under one name similar to a Java package helps to create sub-scopes for identifiers

To declare a namespace:

namespace namespace_identifier {// declare entities here}

Example usagenamespace Probability{

double pdf, cdf;double *distribution;

class GaussianDistribution {...};

}

int main(){ using Probability::GaussianDistribution; GaussianDistribution GD;

...}

The using keyword

used to introduce a name from a namespace into the current declarative region i.e. using Probability::pdf

also can be used to introduce entire namespaces using namespace Probability

utility of namespaces

functionality of namespaces is especially useful to avoid redefinition errors also known as naming collision in the case that a global object or function

uses the same identifier as another one commonplace in large projects, multiple

programmers working on the same program

“Collision avoidance”

namespace Cars {double velocity = 10;

};namespace Planes {

double velocity = 1000;}

int main(){cout << Cars::velocity << “\n”;cout << Planes::velocity << “\n”;

}

Namespace using scope

using, using namespace are valid in the declaring code block, or global scope if declared at the beginning of the program remember, curly braces create code

blocks In C++

C++ Exceptions

react to unexpected circumstances in code using exception handlers

place suspect code under inspection using a try block

control goes to exception handlers in case of exception all the catch blocks

Syntax

try{ // place your code here, for example:ch = new char[100];throw 100;

}catch( std::bad_alloc ex ){ cout << ex.what();

}catch( int exi ) {cout << exi;

}catch(...){ // catches everything else, default

hander}

Exception Throwing

thrown exception can be of any type basic types (int, char, float... ) any object derived from the standard class

called exception exception is declared in the header

<exceptions> virtual member function what returns a null-

terminated character sequence (char *) override in derived classes to contain some

sort of description of the exception

User-defined exceptions

functions throwing exceptions: void GetRoots() throw (int)

throws an integer exception (catch int) void GetRoots()

can throw any type of exception void GetRoots throw ()

cannot throw any type of exception

Custom Exception Classclass CustomException: public exception{ virtual const char* what() const throw() { return "Custom exception happened"; }};

int main() { try {

CustomExcpetion custEx; throw custEx; } catch( exception& e ){ // reference to base is ok cout << e.what() << endl; } return 0;}

Standard Library Exceptions

Exception Descriptionbad_alloc thrown by new on allocation failure

bad_cast

bad_exceptionbad_typeid thrown by typeidios_base::failure thrown by functions in the iostream library

thrown by dynamic_cast when fails with a referenced typethrown when an exception type doesn't match any catch

Miscellaneous

• C++ structs:

– Same as classes, except by default, everything is public (classes have everything private by default)

• C structs do not have methods. Only data.

– C has no concept of data-function binding

• struct Complex { private:

double real, imaginary;public: Complex(); ...

}

return(EXIT_SUCCESS)?

• Concluding remarks.