2.   ++

++    ,    
  , , ,      
    ,    ,   ,
,    .

     ,    
 ,   ;

++    ,     
.   ,    ival,  
:

   int *pint; //     int

     ,   &. 
   .     pint
  ival:

   pint = &ival; // pint    ival

     ,    pint (ival  
),   ,    .
    *.       
ival,   :

   *pint = *pint + 1; //   ival

       ,  

   ival = ival + 1; //   ival

      :    
  ival     .   
   ,       . 
        
 .

 new   .       
 :

    int *pint = new int(1024);

  new       int, 
  1024     .    
  pint.      
    , ..  
  .

   new      , 
   :

    int *pia = new int[4];

           int. 
,    new    
.

      ,     new  
,       .  pint,  pia  
,  pint      int,  pia   
      int.
        ,     
   .      delete, , 
 new,         :

   delete pint;  //   
   delete[] pia; //  

        ,
,   ,   .   8.4  
    .

2.3.  

   IntArray *pArray = new IntArray;

   class IntArray {
   public:
      //  : #2b
      bool operator== (const IntArray&) const;
      bool operator!= (const IntArray&) const;

      //  : #2a
      IntArray& operator= (const IntArray&);

      int size() const; // #1
      void sort(); // #4

      int min() const; // #3a
      int max() const; // #3b

      //  find   
      //   
      //  -1,    
      int find (int value) const; // #3c
   private:
      //    ,
      //   
      ...
   }

            ,  
 ,    .   
   .
            
,  .

           .

   ,     ,     ,
   .   ,     
 ?
     , . ++    (inline) . 
      ,    
. (   ,    ,   
  ++.    ,       .)
    .       :

   for (int index=0; index<array.size(); ++index)

  size()    _size    .  
   ,       
  ,     :

   for (int index=0; index<array._size; ++index)

         (   ),  
 .     inline,  
  3.

   class IntArray {
   public:
      explicit IntArray (int sz = DefaultArraySize);
      IntArray (int *array, int array_size);
      IntArray (const IntArray &rhs);
      // ...
   private:
      static const int DefaultArraySize = 12;
   };

   IntArray::IntArray (int sz)
   {
      //   
      _size = sz;
      ia = new int[_size];
      //   
      for (int ix=0; ix<_size; ++ix)
         ia[ix] = 0;
   }


      IntArray   IntArray 
   .    :  
        .

   int ia[10] = {0,1,2,3,4,5,6,7,8,9};
   IntArray iA3(ia,10);

   IntArray::IntArray (int *array, int sz)
   {
      //   
      _size = sz;
      ia = new int[_size];
      //   
      for (int ix=0; ix<_size; ++ix)
        ia[ix] = array[ix];
    }

    .   
  IntArray    IntArray.  
     :

   IntArray array;

   //     :
   IntArray ia1 = array;
   IntArray ia2 (array);

   IntArray::IntArray (const IntArray &rhs )
   {
      //   
      _size = rhs._size;
      ia = new int[_size];
      //   
      for (int ix=0; ix<_size; ++ix)
         ia[ix] = rhs.ia[ix];
      }

                , 
  &.      :
      .    
:     ,      , 
 ,   ; ,   rhs._size,   rhs->_size.
(    3.6.)

55

(  17        .  
    ,      .)

   class IntArray {
   public:
      // 
      explicit IntArray (int sz = DefaultArraySize);
      IntArray (int *array, int array_size);
      IntArray (const IntArray &rhs);

      //  
      virtual ~IntArray() { delete[] ia; }

      //  :
      bool operator== (const IntArray&) const;
      bool operator!= (const IntArray&) const;

      //  :
      IntArray& operator= (const IntArray&);
      int size() const { return _size; };

      //    ...
      virtual int& operator[](int index)
      { return ia[index]; }
      virtual void sort();

      virtual int min() const;
      virtual int max() const;
      virtual int find (int value) const;
   protected:
      static const int DefaultArraySize = 12;
      void init (int sz; int *array);
      int _size;
      int *_ia;    // int *ia; !!!!!!!!
   };


   #ifndef IntArrayRC_H
   #define IntArrayRC_H

   #include "IntArray.h"

   class IntArrayRC : public IntArray {
   public:
      IntArrayRC( int sz = DefaultArraySize );
      IntArrayRC( const int *array, int array_size );
      IntArrayRC( const IntArrayRC &rhs );

      virtual int& operator[]( int ) const;

   private:
      void check_range( int ix );
   };

   #endif

   IntArrayRC::operator[]( int index )
   {
      check_range( index );
      return _ia[ index ];   // _ia ??????????????????
   }

   #include <cassert>

   inline void IntArrayRC::check_range(int index)
   {
      assert (index>=0 && index < _size);
   }

    ,      IntArrayRC   ,
 .   ,      
 ?         
  .
      ,      , 
     ++.  ,   
      . 
.       IntArrayRC  :

   int ia[] = {0,1,1,2,3,5,8,13};
   IntArrayRC iarc(ia,8);

       ia  8    IntArray. 
    .    
  IntArrayRC:

   inline IntArrayRC::IntArrayRC( int sz )
      : IntArray( sz ) {}

   inline IntArrayRC::IntArrayRC( const int *iar, int sz )
      : IntArray( iar, sz ) {}

(        14  17.    ,
       IntArrayRC.)

    ,   ,    .
 ,    ,     .
   ,       
   .      
IntArrayRC,      .   ,    
      ,   ,
      ,  
:   ,  .  , 
       IntArrayRC,     
  .
         IntArrayRC     
IntArrayRC.h.      ,   
IntArrayRC.C  .

   #include <iostream>
   #include "IntArray.h"
   #include "IntArrayRC.h"

   void swap( IntArray &ia, int ix, int jx )
   {
      int tmp = ia[ ix ];
      ia[ ix ] = ia[ jx ];
      ia[ jx ] = tmp;
   }

   int main()
   {
      int array[ 4 ] = { 0, 1, 2, 3 };

      IntArray ia1( array, 4 );
      IntArrayRC ia2( array, 4 );

      // :   size-1
      //      IntArray
      cout << "swap() with IntArray ia1" << endl;
      swap( ia1, 1, ia1.size() );

      // :  IntArrayRC "" 
      cout << "swap() with IntArrayRC ia2" << endl;
      swap( ia2, 1, ia2.size() );

      return 0;
   }

                             2.10
      ,       
 .  ,        
        . 
  ,       
         
   .       ?
                             2.11
           
   .  ,       
,          
   ,  -  
 ,        ,
   .   ,  
   ,      
 .   ?

63

                      2.5.  

      -?    - elemType 
  ,      ,  
  -  . (     16.8.)

   template <class elemType>
   class Array {
   public:
      explicit Array( int sz = DefaultArraySize );
      Array( const elemType *ar, int sz );
      Array( const Array &iA );

      virtual ~Array() { delete[] _ia; }
      Array& operator=( const Array & );
      int size() const { return _size; }

      virtual elemType& operator[]( int ix )
      { return _ia[ix]; }
      virtual void sort( int,int );
      virtual int find( const elemType& );
      virtual elemType min();
      virtual elemType max();
   protected:
      void init( const elemType*, int );
      void swap( int, int );
      static const int DefaultArraySize = 12;
      int _size;
      elemType *_ia;
   };

   #include <cassert>
   #include "Array.h"

   template <class elemType>
   class ArrayRC : public Array<elemType> {
   public:
      ArrayRC( int sz = DefaultArraySize )
         : Array<elemType>( sz ) {}
      ArrayRC( const ArrayRC& r )
         : Array<elemType>( r ) {}
      ArrayRC( const elemType *ar, int sz )
         : Array<elemType>( ar, sz ) {}

      elemType& ArrayRC<elemType>::operator[]( int ix )
      {
         assert( ix >= 0 && ix < Array<elemType>::_size );
         return _ia[ ix ];
      }

      private:
         // ...
   };

   #include <iostream>
   #include "Array.h"
   #include "ArrayRC.h"

   template <class elemType>
   inline void swap( Array<elemType> &array, int i, int j )
   {
      elemType tmp = array[ i ];
      array[ i ] = array[ j ];
      array[ j ] = tmp;
   }

   int main()
   {
      Array<int> ia1;
      ArrayRC<int> ia2;

      cout << "swap() with Array<int> ia1" << endl;
      int size = ia1.size();
      swap( ia1, 1, size );

      cout << "swap() with ArrayRC<int> ia2" << endl;
      size = ia2.size();
      swap( ia2, 1, size );

      return 0;
   }


                              2.16
           
,      elemType. ,  
    0:

   explicit Example2 (elemType val=0) : _val(val) {};

           (,  string),
  

   Example2<string> exs("Walden");

 , 

   Example2<string> exs2;

   4.

   4       :

   Example2( elemType nval = elemType() ) : _val( nval ) {}

        min(), 
      . ++    
 ,   .   ,     
?  ,      
     Example2.  ,  .
                               2.17
     ,    Example2
 ,      ,   
.     ,    
     min(),   
  .   ,    ?  
    ,    ?  
.


69

                          2.6.  

   ++      .   
   ,      ,
        .

   if ( !infile ) {
      string errMsg("  : ");
      errMsg += fileName;
      throw errMsg;
   }

               
.      ,     , 
  ,   ,   .
     new   .   ++
   bad_alloc    
  .      
 bad_alloc,      
.
    , ,  

   pstats [3] = pstats[0] / size;

     ,       
.
    ,  ,       try- 
  .
    ,     sum_it()  :

   throw string (": adump27832");

     sum_it() , ,   try- 
  ,    ,  pstats[0]  
.       
 catch-.     catch    string:

   catch (string exceptionMsg) {
      //  
   }

72


        ,   
catch-,    try-.
    stats()      : string 
statsException.     ,  
   ,        ,   
   ,     main().  
 ,   .
      ,     
.   :

   catch (...) {
      //   ,
      //    , 
      //     throw

(       11  19.)

                      2.7.   

          ,   
      .   , , 
   Array:

   namespace Cplusplus_Primer_3E {
      template <class elemType> class Array { ... };
   }

          .
      . :

   // 
   namespace LIB = IBM_Canada_Laboratory;
   namespace DFA = Disney_Feature_Animation;
   int main()
   {
      LIB::Array<int> ia(1024);
   }

       ,     .
 ,        ,
        .   
    ,      
:

   namespace LIB = Cplusplus_Primer_3E;
   int main()
   {
      LIB::Array<int> ia(1024);
   }

   ,    ,    
  ,     . ,  
Array  Disney_Feature_Animation       
.     :

   namespace LIB = Disney_Feature_Animation;

   int main()
   {
      LIB::Array<int> ia(1024);
   }

         , 
    ,     . 
   using:

   #include "IBM_Canada_Laboratory.h"
   using namespace IBM_Canada_Laboratory;

        ,      (
 using):

   #include "IBM_Canada_Laboratory.h"
   using namespace IBM_Canada_Laboratory::Matrix;
   //    Matrix

      ,     ++  
  std.      ,
      :

   #include <string>
   // : string 
   string current_chapter = " ++";

76


      using:

   #include <string>
   using namespace std;

   , ,        
  ,       
 .      :

   // :  
   std::string current_chapter = " ++";

      using:

   #include <string>
   using namespace std::string;
   // Ok: string 
   string current_chapter = " ++";

       .

   (  using-      ++ 
   8.6.)


                      2.8.     

          , ,  
  ???,     .
           C++.    
 ,  .
           Array  
  vector.
       ,       
 ,     ,     
  ,       . 
            . 
      -,   , ,  
sort(), min(), max(), find()  ,  vector   : 
     , size()  empty().   ,  
,     .

   //      vector
   vector<int> vec0; //  

   const int size = 8;
   const int value = 1024;

   //   8
   //    0
   vector<int> vec1(size);

   //   8
   //     1024
   vector<int> vec2(size,value);

   //   4
   //     ia
   int ia[4] = { 0, 1, 1, 2 };
   vector<int> vec3(ia,ia+4);

   // vec4 -  vec2
   vector<int> vec4(vec2);

    ,    Array,  vector     .
          .   
 ,    .   
vector   -  begin()  end(),  
       ,    .
       .  ,
     :

   #include <vector>

   extern int getSize();

   void mumble()
   {
      int size = getSize();

      vector<int> vec(size);
      vector<int>::iterator iter = vec.begin();

      for (int ix=0; iter!=vec.end(); ++iter, ++ix)
         *iter = ix;
      // ...
   }

      ++    ,  
 vector,     - ,   
 .
             
. , ,   :

   int ia[7] = { 10, 7, 9, 5, 3, 7, 1 };

         sort():

   sort ( ia, ia+7 );

        :

   sort ( ia, ia+4 );

     ++    . 
   ,       
,     .    
    (map).
   ( ,        
 6.      ,   . 
 12   ,      
.)

84
