For the comparison of two pairs, the C++ standard library provides the usual comparison operators. Two value pairs are equal if both values are equal:

   namespace std {
       template <class T1, class T2>
       bool operator== (const pair<T1,T2>& x, const pair<T1,T2>& y) {
           return x.first == y.first && x.second == y.second;
       }
   }

In a comparison of pairs, the first value has higher priority. Thus, if the first values of two pairs differ, the result of their comparison is used as the result of the comparison of the whole pairs. If the first values are equal, the comparison of the second values yields the result:

    namespace std {
       template <class T1, class T2>
       bool operator< (const pair<T1,T2>& x, const pair<T1,T2>& y) {
           return x.first < y.first ||
                  (!(y.first < x.first) && x.second < y.second);
       }
    }

The other comparison operators are defined accordingly.

Functions often operate in the following way^[4]:

If the resources acquired on entry are bound to local objects, they get freed automatically on function exit because the destructors of those local objects are called. But if resources are acquired explicitly and are not bound to any object, they must be freed explicitly. Resources are typically managed explicitly when pointers are used.

A typical example of using pointers in this way is the use of new and delete to create and destroy an object:

    void f()
    {
        ClassA* ptr = new ClassA;     //create an object explicitly
        ...                            //perform some operations
        delete ptr;                    //clean up (destroy the object explicitly)
    }

This function is a source of trouble. One obvious problem is that the deletion of the object might be forgotten (especially if you have return statements inside the function). There also is a not-so-obvious danger that an exception might occur. Such an exception would exit the function immediately without calling the delete statement at the end of the function. The result would be a memory leak or, more generally, a resource leak. Avoiding such a resource leak usually requires that a function catches all exceptions. For example:

   void f()
   {
       ClassA* ptr = new ClassA;     //create an object explicitly


       try {
          ...                        //perform some operations
       }
       catch (...) {                  //for any exception
           delete ptr;                //- clean up
           throw;                     //- rethrow the exception
       }


       delete ptr;                    //clean up on normal end
   }

To handle the deletion of this object properly in the event of an exception, the code gets more complicated and redundant. If a second object is handled in this way, or if more than one catch clause is used, the problem gets worse. This is bad programming style and should be avoided because it is complex and error prone.

A kind of smart pointer can help here. The smart pointer can free the data to which it points whenever the pointer itself gets destroyed. Furthermore, because the pointer is a local variable, it gets destroyed automatically when the function is exited regardless of whether the exit is normal or is due to an exception. The class auto_ptr was designed to be such a kind of smart pointer.

An auto_ptr is a pointer that serves as owner of the object to which it refers (if any). As a result, an object gets destroyed automatically when its auto_ptr gets destroyed. A requirement of an auto_ptr is that its object has only one owner.

Here is the previous example rewritten to use an auto_ptr:

//header file for auto_ptr
    #include <memory>


    void f()
    {
        //create and initialize an auto_ptr
        std::auto_ptr<ClassA> ptr(new ClassA);


        ...                           //perform some operations
    }

The delete statement and the catch clause are no longer necessary. An auto_ptr has much the same interface as an ordinary pointer; that is, operator * dereferences the object to which it points, whereas operator -> provides access to a member if the object is a class or a structure. However, any pointer arithmetic (such as ++) is not defined (this might be an advantage, because pointer arithmetic is a source of trouble).

Note that class auto_ptr<> does not allow you to initialize an object with an ordinary pointer by using the assignment syntax. Thus, you must initialize the auto_ptr directly by using its value^[5]:

   std::auto_ptr<ClassA> ptr1(new ClassA);     //OK
   std::auto_ptr<ClassA> ptr2 = new ClassA;    //ERROR

An auto_ptr provides the semantics of strict ownership. This means that because an auto_ptr deletes the object to which it points, the object should not be "owned" by any other objects. Two or more auto_ptrs must not own the same object at the same time. Unfortunately, it might happen that two auto_ptrs own the same object (for example, if you initialize two auto_ptrs with the same object). Making sure this doesn't happen is up to the programmer.

This leads to the question of how the copy constructor and the assignment operator of auto_ptrs operate. The usual behavior of these operations would be to copy the data of one auto_ptr to the other. However, this behavior would result in the situation, in which two auto_ptrs own the same object. The solution is simple, but it has important consequences: The copy constructor and assignment operator of auto_ptrs "transfer ownership" of the objects to which they refer.

Consider, for example, the following use of the copy constructor:

//initialize an auto_ptr with a new object
    std::auto_ptr<ClassA> ptr1(new ClassA);


    //copy the auto_ptr
    //- transfers ownership from ptr1 to ptr2
    std::auto_ptr<ClassA> ptr2(ptr1);

After the first statement, ptr1 owns the object that was created with the new operator. The second statement transfers ownership from ptr1 to ptr2. So after the second statement, ptr2 owns the object created with new, and ptr1 no longer owns the object. The object created by new ClassA gets deleted exactly once — when ptr2 gets destroyed.

The assignment operator behaves similarly:

//initialize an auto_ptr with a new object
    std::auto_ptr<ClassA> ptr1(new ClassA);
    std::auto_ptr<ClassA> ptr2;  //create another auto_ptr


    ptr2 = ptr1;                 //assign the auto_ptr
                                 //- transfers ownership from ptr1 to ptr2

Here, the assignment transfers ownership from ptr1 to ptr2. As a result, ptr2 owns the object that was previously owned by ptr1.

If ptr2 owned an object before an assignment, delete is called for that object:

//initialize an auto_ptr with a new object
    std::auto_ptr<ClassA> ptr1(new ClassA);
    //initialize another auto_ptr with a new object
    std::auto_ptr<ClassA> ptr2(new ClassA);


    ptr2 = ptr1;                  //assign the auto_ptr
                                  //- delete object owned by ptr2
                                  //- transfers ownership from ptr1 to ptr2

Note that a transfer of ownership means that the value is not simply copied. In all cases of ownership transfer, the previous owner (ptr1 in the previous examples) loses its ownership. As a consequence the previous owner has the null pointer as its value after the transfer. This is a significant violation of the general behavior of initializations and assignments in programming languages. Here, the copy constructor modifies the object that is used to initialize the new object, and the assignment operator modifies the right-hand side of the assignment. It is up to the programmer to ensure that an auto_ptr that lost ownership and got the null pointer as value is no longer dereferenced.

To assign a new value to an auto_ptr, this new value must be an auto_ptr. You can't assign an ordinary pointer:

    std::auto_ptr<ClassA> ptr;                         //create an auto_ptr


    ptr = new ClassA;                                  //ERROR 
    ptr = std::auto_ptr<ClassA>(new ClassA);           //OK, delete old object
//    and own new

//this is a
bad example
   template <class T>
   void bad_print(std::auto_ptr<T> p)    //p gets ownership of passed argument
   {
      //does p own an object ?
      if (p.get() == NULL) {
             std::cout << "NULL";
      }
      else {
          std::cout << *p;
      }
   }            //Oops, exiting deletes the object to which p refers

   std::auto_ptr<int> p(new int);
   *p = 42;         //change value to which p refers
   bad_print(p);   //Oops, deletes the memory to which p refers
   *p = 18;         //RUNTIME ERROR

   const std::auto_ptr<int> p(new int);
   *p = 42;         //change value to which p refers
   bad_print(p);    //COMPILE-TIME ERROR
   *p = 18;         //OK

   template <class T>
   void container::insert (const T& value)
   {
         ...
         X = value;   //assign or copy value internally
         ...
   }

container<std::auto_ptr<int> > c;
   const std::auto_ptr<int> p(new int);
   ...
   c.insert(p);     //ERROR
   ...

    std::auto_ptr<int> f()
    {
       const std::auto_ptr<int> p(new int);   //no ownership transfer possible
       std::auto_ptr<int> q(new int);         //ownership transfer possible


       *p = 42;          //OK, change value to which p refers
       bad_print(p);     //COMPILE-TIME ERROR
       *p = *q;          //OK, change value to which p refers
       p = q;            //COMPILE-TIME ERROR
       return p;         //COMPILE-TIME ERROR
    }

By using auto_ptrs within a class you can also avoid resource leaks. If you use an auto_ptr instead of an ordinary pointer, you no longer need a destructor because the object gets deleted with the deletion of the member. In addition, an auto_ptr helps to avoid resource leaks that are caused by exceptions that are thrown during the initialization of an object. Note that destructors are called only if any construction is completed. So, if an exception occurs inside a constructor, destructors are only called for objects that have been fully constructed. This might result in a resource leak if, for example, the first new was successful but the second was not. For example:

   class ClassB {
     private:
       ClassA* ptr1;                 //pointer members
       ClassA* ptr2;
     public:
       //constructor that initializes the pointers
//- will cause resource leak if second new throws
       ClassB (ClassA val1, ClassA val2)
        : ptr1(new ClassA(val1)), ptr2(new ClassA(val2)) {
       }


       //copy constructor
//- might cause resource leak if second new throws
       ClassB (const ClassB& x)
        : ptr1(new ClassA(*x.ptr1)), ptr2(new ClassA(*x.ptr2)) {
       }


       //assignment operator
       const ClassB& operator= (const ClassB& x) {
          *ptr1 = *x.ptr1;
          *ptr2 = *x.ptr2;
          return *this;
       }


       ~ClassB () {
           delete ptr1;
           delete ptr2;
       }
       ...
   };

To avoid such a possible resource leak, you can simply use auto_ptrs:

   class ClassB {
     private:
       const std::auto_ptr<ClassA> ptr1;         //auto_ptr members
       const std::auto_ptr<ClassA> ptr2;
     public:
       //constructor that initializes the auto_ptrs
//- no resource leak possible
       ClassB (ClassA val1, ClassA val2)
        : ptr1(new ClassA(val1)), ptr2(new ClassA(val2)) {
       }


       //copy constructor
//- no resource leak possible
       ClassB (const ClassB& x)
        : ptr1(new ClassA(*x.ptr1)), ptr2(new ClassA(*x.ptr2)) {
       }


       //assignment operator
       const ClassB& operator= (const ClassB& x) {
          *ptr1 = *x.ptr1;
          *ptr2 = *x.ptr2;
          return *this;
       }


       //no destructor necessary
//(default destructor lets ptr1 and ptr2 delete their objects)
       ...
   };

Note, however, that although you can skip the destructor, you still have to program the copy constructor and the assignment operator. By default, both would try to transfer ownership, which is probably not the intention. In addition, and as mentioned on page 42, to avoid an unintended transfer of ownership you should use constant auto_ptrs here if the auto_ptr should not refer to the same object throughout its lifetime.

auto_ptrs satisfy a certain need; namely, to avoid resource leaks when exception handling is used. Unfortunately, the exact behavior of auto_ptrs changed in the past and no other kind of smart pointers are provided in the C++ standard library, so people tend to misuse auto_ptrs. Here are some hints to help you use them correctly:

Unfortunately, sometimes the misuse of an auto_ptr works. Regarding this, using nonconstant auto_ptrs is no safer than using ordinary pointers. You might call it luck if the misuse doesn't result in a crash, but in fact you are unlucky because you don't realize that you made a mistake.

See Section 5.10.2, for a discussion and Section 6.8, for an implementation of a smart pointer for reference counting. This pointer is useful when sharing elements in different containers.

The first example shows how auto_ptrs behave regarding the transfer of ownership:

//util/autoptr1.cpp

   #include <iostream>
   #include <memory>
   using namespace std;


   /* define output operator for auto_ptr
    * - print object value or NULL
*/
   template <class T>
   ostream& operator<< (ostream& strm, const auto_ptr<T>& p)
   {
       //does p own an object ?
       if (p.get() == NULL) {
           strm << "NULL";        //NO: print NULL
        }
        else {
           strm << *p;           //YES: print the object
        }
        return strm;
   }


   int main()
   {
       auto_ptr<int> p(new int(42));
       auto_ptr<int> q;


       cout << "after initialization:" << endl;
       cout << " p: " << p << endl;
       cout << " q: " << q << endl;


       q = p;
       cout << "after assigning auto pointers:" << endl;
       cout << " p: " << p << endl;
       cout << " q: " << q << endl;


       *q += 13;                   //change value of the object q owns
       p = q;
       cout << "after change and reassignment:" << endl;
       cout << " p: " << p << endl;
       cout << " q: " << q << endl;
   }

The output of the program is as follows:

   after initialization:
    p: 42
    q: NULL
   after assigning auto pointers:
    p: NULL
    q: 42
   after change and reassignment:
    p: 55
    q: NULL

Note that the second parameter of the output operator function is a constant reference. So it uses auto_ptrs without any transfer of ownership.

As mentioned on page 40, bear in mind that you can't initialize an auto_ptr by using the assignment syntax or assign an ordinary pointer:

    std::auto_ptr<int> p(new int(42));     //OK
    std::auto_ptr<int> p = new int(42);    //ERROR


    p = std::auto_ptr<int>(new int(42));   //OK
    p = new int(42);                       //ERROR

This is because the constructor to create an auto_ptr from an ordinary pointer is declared as explicit (see Section 2.2.6, for an introduction of explicit).

The following example shows how constant auto_ptrs behave:

//util/autoptr2.cpp

   #include <iostream>
   #include <memory>
   using namespace std;


   /* define output operator for auto_ptr
    * - print object value or NULL
*/
   template <class T>
   ostream& operator<< (ostream& strm, const auto_ptr<T>& p)
   {
       //does p own an object ?
       if (p.get() == NULL) {
           strm << "NULL";       //NO: print NULL
       }
       else {
           strm << *p;           //YES: print the object
       }
       return strm;
   }


   int main()
   {
       const auto_ptr<int> p(new int(42));
       const auto_ptr<int> q(new int(0));
       const auto_ptr<int> r;
       cout << "after initialization:" << endl;
       cout << " p: " << p << endl;
       cout << " q: " << q << endl;
       cout << " r: " << r << endl;


       *q = *p;
   //  *r = *p;    //ERROR: undefined behavior
       *p = −77;
       cout << "after assigning values:" << endl;
       cout << " p: " << p << endl;
       cout << " q: " << q << endl;
       cout << " r: " << r << endl;


   //  q = p;      //ERROR at compile time
   //  r = p;      //ERROR at compile time
   }

Here, the output of the program is as follows:

   after initialization:
    p: 42
    q: 0
    r: NULL
   after assigning values:
    p: −77
    q: 42
    r: NULL

This example defines an output operator for auto_ptrs. To do this, it passes an auto_ptr as a constant reference. According to the discussion on page 43, you should usually not pass an auto_ptr in any form. This function is an exception to this rule.

Note that the assignment

   *r = *p;

is an error. It dereferences an auto_ptr that refers to no object. According to the standard, this results in undefined behavior; for example, a crash. As you can see, you can manipulate the objects to which constant auto_ptrs refer, but you can't change which objects they own. Even if r was nonconstant, the last statement would not be possible because it would change the constant p.

Class auto_ptr is declared in <memory>:

   #include <memory>

It provides auto_ptr as a template class for any types in namespace std. The following is the exact declaration of the class auto_ptr:^[6]

   namespace std {
       //auxiliary type to enable copies and assignments
       template <class Y> struct auto_ptr_ref {};


       template<class T>
       class auto_ptr {
         public:
           //type names for the value
           typedef T element_type;


           //constructor
           explicit auto_ptr(T* ptr = 0) throw();


           //copy constructors (with implicit conversion)
//- note: nonconstant parameter
           auto_ptr(auto_ptr&) throw();
           template<class U> auto_ptr(auto_ptr<U>&) throw();


           //assignments (with implicit conversion)
//- note: nonconstant parameter
           auto_ptr& operator= (auto_ptr&) throw();
           template<class U>
               auto_ptr& operator= (auto_ptr<U>&) throw();


           //destructor 
           ~auto_ptr() throw();


           //value access
           T* get() const throw();
           T& operator*() const throw();
           T* operator->() const throw();


           //release ownership
           T* release() throw();


           //reset value
           void reset(T* ptr = 0) throw();


         //special conversions to enable copies and assignments
         public:
           auto_ptr(auto_ptr_ref<T>) throw();
           auto_ptr& operator= (auto_ptr_ref<T> rhs) throw();
           template<class U> operator auto_ptr_ref<U>() throw();
           template<class U> operator auto_ptr<U>() throw();
      };
   }

The individual members are described in detail in the following sections, in which auto_ptr is an abbreviation for auto_ptr<T>. A complete sample implementation of class auto_ptr is located on page 56.

// util/autoptr.hpp
/* class auto_ptr
    *- improved standard conforming implementation
    */
   namespace std {
       //auxiliary type to enable copies and assignments (now global)
       template<class Y> 
       struct auto_ptr_ref {
           Y* yp; 
           auto_ptr_ref (Y* rhs)
            : yp(rhs) {
           }
       };


       template<class T>
       class auto_ptr {
         private:
           T* ap;    //refers to the actual owned object (if any)
         public:
           typedef T element_type;


           //constructor
           explicit auto_ptr (T* ptr = 0) throw()
            : ap(ptr) {
           }


           //copy constructors (with implicit conversion)
//- note: nonconstant parameter
           auto_ptr (auto_ptr& rhs) throw()
            : ap (rhs.release()) {
           }
           template<class Y>
           auto_ptr (auto_ptr<Y>& rhs) throw()
            : ap(rhs.release()) { 
           }


           //assignments (with implicit conversion)
//- note: nonconstant parameter
           auto_ptr& operator= (auto_ptr& rhs) throw() {
               reset(rhs.release());
               return *this; 
           }
           template<class Y>
           auto_ptr& operator= (auto_ptr<Y>& rhs) throw() {
               reset(rhs.release());
               return *this; 
           }


           //destructor
            ~auto_ptr() throw() {
                delete ap; 
           }


           //value access
           T* get() const throw() {
               return ap; 
           } 
           T& operator*() const throw() {
               return *ap; 
           }
           T* operator->() const throw() {
               return ap; 
           }


           //release ownership
           T* release() throw() {
               T* tmp(ap);
               ap = 0;
               return tmp;
           }


           //reset value
           void reset (T* ptr=0) throw(){
               if (ap != ptr) { 
                   delete ap; 
                   ap = ptr; 
               }
           }


           /* special conversions with auxiliary type to enable copies and assignments
*/
           auto_ptr(auto_ptr_ref<T> rhs) throw()
            : ap(rhs.yp) {
           }
           auto_ptr& operator= (auto_ptr_ref<T> rhs) throw() { //new 
                reset(rhs.yp);
                return *this;
           }
           template<class Y> 
           operator auto_ptr_ref<Y>() throw() {
               return auto_ptr_ref<Y>(release()); 
           }
           template<class Y> 
           operator auto_ptr<Y>() throw() {
               return auto_ptr<Y>(release()); 
           }
       };
   }

Usually you use templates to implement something once for any type. However, you can also use templates to provide a common interface that is implemented for each type, where it is useful. You can do this by providing specialization of a general template. numeric_limits is a typical example of this technique, which works as follows:

The general numeric_limits template and its standard specializations are provided in the header file <limits>. The specializations are provided for any fundamental type that can represent numeric values: bool, char, signed char, unsigned char, wchar_t, short, unsigned short, int, unsigned int, long, unsigned long, float, double, and long double. They can be supplemented easily for user-defined numeric types.

Table 4.2 and Table 4.3 list all members of the class numeric_limits<> and their meanings. Applicable corresponding C constants for these members are given in the right column of the tables (they are defined in <climits>, <limits.h>, <cfloat>, and <float.h>).

The following is a possible full specialization of the numeric limits for type float, which is platform dependent. It also shows the exact signatures of the members:

   namespace std {
      template<> class numeric_limits<float> {
        public:
          //yes, a specialization for numeric limits of float does exist
          static const bool is_specialized = true;


          inline static float min() throw() {
              return 1.17549435E-38F; 
          } 
          inline static float max() throw() {
              return 3.40282347E+38F; 
          }


          static const int digits = 24;
          static const int digits10 = 6;


          static const bool is_signed = true;
          static const bool is_integer = false;
          static const bool is_exact = false;
          static const bool is_bounded = true;
          static const bool is_modulo = false;
          static const bool is_iec559 = true;


          static const int radix = 2;


          inline static float epsilon() throw() {
              return 1.19209290E-07F;
          }


          static const float_round_style round_style
              = round_to_nearest;
          inline static float round_error() throw() {
              return 0.5F;
          }


          static const int min_exponent = −125;
          static const int max_exponent = +128;
          static const int min_exponent10 = −37;
          static const int max_exponent10 = +38;


          static const bool has_infinity = true;
          inline static float infinity() throw() { return ...; }
          static const bool has_quiet_NaN = true;
          inline static float quiet_NaN() throw() { return ...; }
          static const bool has_signaling_NaN = true;
          inline static float signaling_NaN() throw() { return ...; }
          static const float_denorm_style has_denorm = denorm_absent;
          static const bool has_denorm_loss = false;
          inline static float denorm_min() throw() { return min(); }


          static const bool traps = true;
          static const bool tinyness_before = true; 
      };
   }

Note that all nonfunction members are constant and static so that their values can be determined at compile time. For members that are defined by functions, the value might not be defined clearly at compile time on some implementations. For example, the same object code may run on different processors and may have different values for floating values.

The values of round_style are shown in Table 4.4. The values of has_denorm are shown in Table 4.5. Unfortunately, the member has_denorm is not called denorm_style. This happened because during the standardization process there was a late change from a Boolean to an enumerative value. However, you can use the has_denorm member as a Boolean value because the standard guarantees that denorm_absent is 0, which is equivalent to false, whereas denorm_present is 1 and denorm_indeterminate is −1, both of which are equivalent to true. Thus, you can consider has_denorm a Boolean indication of whether the type may allow denormalized values.

The following example shows possible uses of some numeric limits, such as the maximum values for certain types and determining whether char is signed.

// util/limits1.cpp

   #include <iostream>
   #include <limits>
   #include <string>
   using namespace std;


   int main()
   {
      //use textual representation for bool
      cout << boolalpha;


      //print maximum of integral types
      cout << "max(short): " << numeric_limits<short>::max() << endl; 
      cout << "max(int): " << numeric_limits<int>::max() << endl; 
      cout << "max(long): " << numeric_limits<long>::max() << endl; 
      cout << endl;


      //print maximum of floating-point types
      cout << "max(float): "
           << numeric_limits<float>::max() << endl; 
      cout << "max(double): "
           << numeric_limits<double>::max() << endl; 
      cout << "max(long double): "
           << numeric_limits<long double>::max() << endl; 
      cout << endl;


      //print whether char is signed
      cout << "is_signed(char): "
           << numeric_limits<char>::is_signed << endl;
      cout << endl;


      //print whether numeric limits for type string exist
       cout << "is_specialized(string): "
            << numeric_limits<string>::is_specialized << endl; 
   }

The output of this program is platform dependent. Here is a possible output of the program:

   max(short): 32767
   max(int): 2147483647
   max(long): 2147483647


   max(float): 3.40282e+38
   max(double): 1.79769e+308
   max(long double): 1.79769e+308


   is_signed(char): false


   is_specialized(string): false

The last line shows that there are no numeric limits defined for the type string. This makes sense because strings are not numeric values. However, this example shows that you can query for any arbitrary type whether or not it has numeric limits defined.

The functions to process the minimum and the maximum of two values are defined in <algorithm> as follows:

   namespace std {
       template <class T>
       inline const T& min (const T& a, const T& b) {
           return b < a ? b : a;
       }


       template <class T>
       inline const T& max (const T& a, const T& b) {
           return a < b ? b : a;
       }
   }

If both values are equal, generally the first element gets returned. However, it is not good programming style to rely on this.

Both functions are also provided with the comparison criterion as an additional argument:

   namespace std {
       template <class T, class Compare>
       inline const T& min (const T& a, const T& b, Compare comp) {
           return comp(b,a) ? b : a;
       }


       template <class T, class Compare>
       inline const T& max (const T& a, const T& b, Compare comp) {
           return comp(a,b) ? b : a;
       }
   }

The comparison argument might be a function or a function object that compares both arguments and returns whether the first is less than the second in some particular order (function objects are introduced in Section 5.9, page 124).

The following example shows how to use the maximum function by passing a special comparison function as an argument:

// util/minmax1.cpp

   #include <algorithm>
   using namespace std;


   /* function that compares two pointers by comparing the values to which they point
*/
   bool int_ptr_less (int* a, int* b)
   {
       return *a < *b;
   }


   int main()
   {
       int x = 17;
       int y = 42;
       int* px = &x;
       int* py = &y;
       int* pmax;


       //call max() with special comparison function
       pmax = max (px, py, int_ptr_less);
       ...
   }

Note that the definition of min() and max() require that both types match. Thus, you can't call them for objects of different types:

   int i;
   long l;
   ...
   1 = std::max(i,l) ;        //ERROR: argument types don't match

However, you could qualify explicitly the type of your arguments (and thus the return type):

   1 = std::max<long>(i,l) ;   //OK

The function swap() is provided to swap the values of two objects. The general implementation of swap() is defined in <algorithm> as follows:

   namespace std {
       template<class T>
       inline void swap(T& a, T& b) {
           T tmp(a);
           a = b;
           b = tmp;
       }
   }

By using this function you can have two arbitrary variables x and y swap their values by calling

   std::swap(x,y);

Of course, this call is possible only if the copy constructions and assignments inside the swap() function are possible.

The big advantage of using swap() is that it enables to provide special implementations for more complex types by using template specialization or function overloading. These special implementations might save time by swapping internal members rather than by assigning the objects. This is the case, for example, for all standard containers (Section 6.1.2, page 147) and strings (Section 11.2.8, page 490). For example, a swap() implementation for a simple container that has only an array and the number of elements as members could look like this:

    class MyContainer {
      private:
        int* elems;        //dynamic array of elements
        int numElems;      //number of elements
      public:
        ...
        //implementation of swap()
        void swap(MyContainer& x) {
            std::swap(elems,x.elems);
            std::swap(numElems,x.numElems); 
        }
        ...
    };


    //overloaded global swap() for this type
    inline void swap (MyContainer& c1, MyContainer& c2)
    {
        c1. swap (c2);  //calls implementation of swap()
    }

So, calling swap() instead of swapping the values directly might result in substantial performance improvements. You should always offer a specialization of swap() for your own types if doing so has performance advantages.

Table 4.6 shows the definitions of the <cstddef> header file. NULL is often used to indicate that a pointer points to nothing. It is simply the value 0 (either as an int or as a long). Note that in C, NULL often is defined as (void*)0. This is incorrect in C++ because there the type of NULL must be an integer type. Otherwise, you could not assign NULL to a pointer. This is because in C++ there is no automatic conversion from void* to any other type.^[10] Note that NULL is also defined in the header files <cstdio>, <cstdlib>, <cstring>, <ctime>, <cwchar>, and <clocale>.

Table 4.7 shows the most important definitions of the <cstdlib> header file. The two constants EXIT_SUCCESS and EXIT_FAILURE are defined as arguments for exit(). They can also be used as a return value in main().

The functions that are registered by atexit() are called at normal program termination in reverse order of their registration. It doesn't matter whether the program exits due to a call of exit() or the end of main(). No arguments are passed.

The exit() and abort() functions are provided to terminate a program in any function without going back to main():

None of these functions destroys local objects because no stack unwinding occurs. To ensure that the destructors of all local objects are called, you should use exceptions or the ordinary return mechanism to return to and exit main().