Namespaces and STL.

We can enclose a group of declarations inside a name space, and these declarations will be visible only inside the name space. To make these objects visible from outside the name space we need to use syntax like

namespace_name::identifier

Defining and using a name space

namespace name {
   declarations;
}

// File: robot.h

namespace RobotWar {
   class Object {
      public: ...
      private: ...
   };

   class Location {
      public: ...
      private: ...
   };

   class Robot : public Object {
      public: ...
      private:
         Location coord;
   };

   double Distance(const Location &one, const Location &two);

} // end of the name space

Now, we don't need to worry that some of these identifiers are used in standard libraries (Object, for example). Inside our program we can use them like:

#include "robot.h"

void main()
{
   RoborWar::Location point(5, 15);
   ...
}

   5:   Location point(5, 45);
error C2065: 'Location' : undeclared identifier

We can also define objects with the same identifiers inside a different name space and there will be no conflict between them:

namespace RobotPeace {
   class Robot {
      ...
   };
}

RobotWar::Robot tank;
RobotPeace::Robot taxi;

We can use the same name space in different header files. In this case, the first appearance of the name space is considered by the compiler as the definition of the name space, and others are considered as extensions of the name space. We can also provide an alternative name for a name space. The syntax for creating an name space alias is:

namespace alias = namespace_name;

namespace RW = RobotWar;

The namespace keyword may appear inside another name spaces. That is, we are allowed to created nested name spaces. For example, if we want to create a lot of objects for robots, but also we would like to separate war robots from peace robots we can do something like this:

// File: robot.h

namespace Robots {
   class Object {
      ...
   };

   class Location {
      ...
   };

   namespace War {
      class Robot : public Object {
         ...
      };
   } // end of the War name space

   namespace Peace {
      class Robot : public Object {
         ...
      };
   }  // end of the Peace name space


} // end of the name space Robot

namespace RW = Robots::War;
namespace RP = Robots::Peace;

Robots::War::Robot   tank;
Robots::Peace::Robot taxi;

So far, to refer to an identifier declared inside a name space we were using the explicit declaration. Another way to refer to these identifiers, is to use the using directive. This directive allows to make one identifier from a name space visible. For example, we can use it in the form like

#include "robot.h"

using Robots::War::Robot; // make the definition of the class Robot visible in this program

void main()
{
   Robot tank;
   Robots::Peace::Robot taxi;
   ...
}

using namespace namespace_name;

using namespace Robots;

using namespace Robots;
...
Location point;
War::Robot tank;

using namespace Robots::War;
using namespace Robots::Peace;

 7: Robot tank;
ns.cpp(31) : error C2872: 'Robot' : ambiguous symbol
        could be 'ns.cpp(19) : Robots::Peace::Robot'
        or       'ns.cpp(15) : Robots::War::Robot'

Predefined name spaces

std name space and Standard Template Library

#include <iostream.h>

using namespace std;

#include <iostream>
using namespace std;

The std name space among other things contains the Standard Template Library (STL) that provides tools to work with different type of containers and a list of algorithms to work with these containers. The STL template container classes are:

• deque
• hash_map
• hash_multimap
• hash_multiset
• hash_set
• list
• map
• multimap
• multiset
• set
• vector

Class vector

vector<int> arr;

vector<int> arr(100);

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void main()
{
   int i, j;
   vector<int> v;

   for(i=0;i<15;i++){
      j = rand() % 20;
      v.insert(v.end(), j);
      cout<<"Inserted new element "<<j<<" into the array\n";
   }

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

   cout<<"\nAfter sorting teh array is:\n";
   for(i=0;i<v.size();i++)
      cout<<v[i]<<" ";
}

Class deque

#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

void main()
{
   int i, j;
   deque pq;

   for(i=0;i<15;i++){
      j = rand() % 25;
      pq.push_back(j);
      cout<<"Inserted new element "<<j<<" into the array\n";
   }

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

   cout<<"\nAfter sorting the deque is:\n";
   while( ! pq.empty() ){
      j = pq.front();
      cout<<j<<" ";
      pq.pop_front();
   }
}

STL algorithms

Iterators

Most often elements of STL containers are accessed through iterators. Iterators are special data members (objects) that can iterate containers. Every iterator object represents a position in a container. We can think of an iterator as a pointer to a particular element of a container. In fact, in some cases iterators are just pointers. The advantage of iterators is that they allow all containers to provide the same interface for accessing their elements. Please note that although we can think of iterators as pointers, they actually are not. They are objects of special iterator class. More over, the exact iterator type depends on the container it iterates through. Thus, do declare an object of iterator type we need to use the following syntax:

container_type<object_type>::iterator iterator_obj_name;

For example, to declare an iterator for iterating a vector if integers we need to type

vector<int>::iterator pos;

and to declare an iterator for a queue of Robots we need to use

deque<Robot>::iterator cur_pos;

Container classes have methods that work with iterators. The two probably most important ones are

• begin() - returns an iterator that represents the position of the first element of the container;
• end() - returns an iterator that represents the position behind the last element of the container.

begin() and end() iterators.

A typical way to iterate through a container's elements is:

vector<int> v;
vector<int>::iterator pos;
for(pos=v.begin(); pos!=v.end(); pos++ )
   cout<<*pos<<endl;

As you can see we used operators !=, ++, and * applied to the iterator variable. Operator != compares two iterators and returns true if they point to different elements of a container (here we are talking about actual elements, net their values). Also there is operator == that does completely the opposite; that is, returns true if the iterators point to the same element.

The ++ operator advanced an iterator to the next element of the container. Bidirectional iterators also have a similar operator -- that moves the iterator to the previous element. The * operator is used to access the element the iterator refers to. For example, *pos is an integer value from the array v in the example above.

random-access iterators (provided by vector and deque containers) also support operator + in the form

iterator + n

where n is an integer. In this case, pos+n references the next n^th value following the iterator. Random-access iterators can also compute the difference between two iterators. This difference is the number of elements between two iterators.