                                                         ++   146

                           4. 

     3       ,   
 .     , ,
 , ,   ..,   . ,
  3+4*5  23,   35 ,  
 (*)    ,    (+). 
,         ,  .
,   3+0.7   3   
  .

                          4.1.   ?

         ,      
  .     r-  .
   :

   void mumble() {
      3.14159;
      "melancholia";
      upperBound;
  }

      3.14159  3.14159  double, 
"melancholia"       const char*. 
 upperBound     upperBound,     
 .
             
,   :

   salary + raise
   ivec[ size/2 ] * delta
   first_name + " " + 1ast_name

      .    
  salary  raise.    size   2. 
     ivec.     
     delta.     
       ,  
 .
   ,    ,   (, 
 (&)   (*)),       .  
          ,   
. ,  

   *ptr

*     .   
  ,     ptr.   :

   var1 * var2

      .
      ,    ,  r-
.       .
    ,      
  . (      
4.14.)
      ,      
. , , ,     
 ,     (   - )7:

   ptr != 0 && *ptr != 0

       :   ptr,  ptr
   .  ptr  

   int ival = 1024;
   int *ptr = &ival;

    1024     . 
     ( &&   ).
         ,  ,   
  . ,     ptr  
   0,     ptr      
.        : 
  ,      false,   
 .      , 
 ,         ++ 
.      4.13,      
,   ++,    .

                                 4.2.  

                          4.1.  

   7    0  .    
   : ptr && *ptr.

                                                                  ++   148

	 	 			

	* 			 			expr * expr
	/ 			 			expr / expr
	% 			   	expr % expr
	+ 			 			expr + expr
	- 			 			expr  expr

          .   ,  
, :

   int ivall = 21 / 6;
   int iva12 = 21 / 7;

    ival1,  ival2     3.
     (%),     ,   
    ,       
(char, short, int, long).  ,    . 
     ,    ,  
-.        
:

   3.14 % 3; // :   double
   21 % 6; // : 3
   21 % 7; // : 0
   21 % -5; // -: -1  1
   int iva1 = 1024;
   double dval = 3.14159;
   iva1 % 12; // :
   iva1 % dval; // :   double

          
  .        (
      ).  
     (,   0)   
       (  
,       ). ,  char
 8       0  255   -128  127 
  ,    .    
   char  256  :

                                                         ++   149
   #include <iostream>

   int main() {
      char byte_value = 32;
      int ival = 8;

      //  ,   byte_value
      byte_value = ival * byte_value;
      cout << "byte_value: " <<static_cast<int>(byte_value) << endl;
   }

      256  9 .  byte_value 
  (-) . ,   
 SGI   0.       :

   cout << "byte_va1ue: " << byte_va1ue << endl;

  :

   byte_value:

       ,   0    
ASCII,      .    
,   ,      
:

   static_cast<int>(byte_value)

    .     
   ,   .     
byte_value  int.      :

   byte_value: 0

          ,  byte_value, 
  ,   -   . 
 char  ASCII- (  ),      
 int      . (  
  4.14.)
             
          -
    ,   
      ,   , , 
 ,    ,  , .  ,
     ,   , 
    :   
        .

                                                             ++   150

     ++    limits,  
    ,       
 .   climits  cfloat    .
(      ,    
 , .  4  6 [PLAUGER92]).
         ,   .
      ( 
   float, double  long double),     
  .      long double  
  .       
  . (. [SHAMPINE97]   
 .)

                              4.1

           ?

   double dvall = 10.0, dva12 = 3.0;
   int ivall = 10, iva12 = 3;
   dvall / dva12;
   ivall / iva12;

                                                               4.2

    , ,      
.

                                                                4.3

      limits, climits  cfloat  ,  
.

                        4.3.     

                          4.2.     

	  	 		
	! 			  	!expr
	< 			 		expr1 < expr2
	<= 			   	expr1 <= expr2
	> 			 		expr1 > expr2
	>= 			   	expr1 >= expr2
	== 			 			expr1 == expr2
	!= 			  		expr1 != expr2
	&& 			  	expr1 && expr2
	|| 			  	expr1 || expr2

	.        bool

                                                              ++   151

             bool, 
 true  false.       , 
 , true   1,  false   0.   ,
   ,   
:

   vector<int>::iterator iter = ivec.beg-in() ;
   while ( iter != ivec.end() ) {
      // : e1em_cnt = e1em_cnt + (*iter < some_va1ue)
      //  true/false  *iter < some_va1ue
      //   1  0
     e1em_cnt += *iter < some_va1ue;
     ++iter;
   }

          . ( += 
  ,   ,  , 
,  .       : elem_count =
elem_count + n.       4.4.)
     (&&)    ,    .
  (||)  ,       .
,        ,
     .   ?  
 :

   expr1 && expr2
   expr1 || expr2

        expr1  false,      
false     expr2,     . 
  expr2  ,  expr1  true,  
   true    expr2.
          
    AND:

   while ( ptr !=  &&
      ptr->va1ue < upperBound &&
      ptr->va1ue >= 0 &&
      notFound( ia[ ptr->va1ue ] ))
      { ... }

            ,   
         (ptr->value).
,  ptr  0,       
.         
ptr->value   ,        
ia,    .
       true,      false, 
. :

   bool found = false;
   //    
   //  ptr    ( 0)
   while ( ! found && ptr ) {
      found = 1ookup( *ptr );
      ++ptr;
   }

   

   ! found

 true,   found  false.     

   found == false

   

   if ( found )

   

   if ( found == true )

       .     ,
,      ,      
.  ,    :

   // !    !
   if ( ia[ index++ ] < ia[ index ] )
      //   

    ,        
 ia[0]  ia[1].       ,
     ia[0]      .  
    - :

   if ( ia[ index ] < ia[ index+1 ] )
   //   
   ++index;

                                                             ++   153

       .   ,     ival,
jval  kval .   ?

   // do something ...
   // !    3    
   if ( ival != jva1 != kva1 )

    0, 1  0       true. ?
  ival != jval,      (true/false 
  1/0)   kval.     :

   if ( ival != jva1 && ival != kva1 && jva1 != kva1 )
   //  - ...

                              4.4

       , .   
? (,         .)

   (a) ptr->iva1 != 0
   (b) ival != jva1 < kva1 (d) iva1++ && ival
   () ptr != 0 && *ptr++
   (e) vec[ iva1++ ] <= vec[ ival ];

                               4.5

    ++        ,  
    .   ,    
  ,   ,  
     ?

                             4.4.  

       . :

   int ival = 1024;
   int *pi = 0;

          ,   
:

   ival = 2048;
   pi = &iva1;

                                                              ++   154

       ,       
  =.         .   
       .
    ,        ,   
? ,

   ival = 3.14159; // ?

          ,  , 
 ,  .    ,  
 ,       .  
   3.14159     3,   
  ival.
       ,    :

   pi = ival; // 

      int     int . (
        4.14.) 
         l-.  
 :

   int value = 1024;
   1024 = ival; // 

   ,    :

   value = ival; // 

     ,        l-
. ,  

   const int array_size = 8;
   int ia[ array_size ] = { 0, 1, 2, 2, 3, 5, 8, 13 };
   int *pia = ia;



   array_size = 512; // 

,  array_size   l-:  array_size 
     . 

   ia = pia; // 

ia   l-,       .

                                                          ++   155

     

   pia + 2=1; // 

    pia+2   ia[2],    .    
 ia[2],     .  
 :

   *(pia + 2) = 1; // 

        ,    
 . ,   

   ival = 0;

 0,  

   ival = 3.14159;

 3.    int   .    
   . ,  

   extern char next_char();

   int main()
   {
   char ch = next_char();
   while ( ch != '\n' ) {
      //  - ...
      ch = next_char();
   }
  }

   :

   while (( ch = next_char() ) != '\n' ) {
      //  - ...
   }
   // ...

   ,      ,  
  ,   .    
:

   next_char() != '\n'

                                                         ++   156

  , true  false,   ch. ( 
    4.13.)
         ,  
  . :

   int ival, jval;
   ival = jval = 0; // :  0  

     ival  jval   0.  
,    pval  ival ,    
. ,  0      :

   int main ()
   {
      int ival; int *pval;
      ival = pval = 0; // :  
   }

        ,    , ,  
jval   :

   int main()
   {
      // ...
     int ival = jval = 0; //   ?
     // ...
   }

        ,   jval    
  ,   int.  :      0
 jval   ival.      
,   :

   int main()
   {
      // :   
      int ival = 0, jval = 0;
      // ...
   }

       ,     
,        . :

                                                            ++   157

   int arraySum( int ia[], int sz )
   {
      int sum = 0;
      for ( int i = 0; i < sz; ++i )
         sum = sum + ia[ i ];
      return sum;
  }

         ++    .
        
:

   int arraySum( int ia[], int sz )
   {
      int sum = 0;
      for ( int i =0; i < sz; ++i )
         // : sum = sum + ia[ i ];
        sum += ia[ i ];
      return sum;
   }

        :

   a op= b;

 op=     :

   	+=	 -=	 *= 	/= 	%=
   	<<=	 >>= 	&= 	^= 	|=

    a op= b     a = a op b.

                              4.6

       .  .

   int main() {
      float fval;
      int ival;
      int *pi;
      fval = ival = pi = 0;
   }

                               4.7

      ,      ,
  . ?   ?

   (a) if ( ptr = retrieve_pointer() != 0 )
   (b) if ( ival = 1024 )
   (c) ival += ival + 1;

                         4.5.    

     (++)   (--)     
      .    
          , 
 :

   #include <vector>
   #include <cassert>

   int main()
   {
      int ia[10] = {0,1,2,3,4,5,6,7,8,9};
      vector<int> ivec( 10 );

      int ix_vec = 0, ix_ia = 9;
      while ( ix_vec < 10 )
         ivec[ ix_vec++ ] = ia[ ix_ia-- ];

      int *pia = &ia[9];
      vector<int>::iterator iter = ivec.begin();

      while ( iter != ivec.end() )
         assert( *iter++ == *pia-- );
   }

   

   ix_vec++

    .   ix_vec
  ,        .
,      ix_vec  0.   
    ivec,   ix_vec   
 1,        .
       :   ix_ia
     ia,  ix_ia   1.
        .    
     ,    
.   :

   // :     
   //  
   int ix_vec = 0, ix_ia = 9;
   while ( ix_vec < 10 )

                                                             ++   159

      ivec[ ++ix_vec ] = ia[ --ix_ia ];

 ix_vec       1  
   .  ix_ia   8  
.       ,  
    ix_ivec  ix_ia:

   // 
   int ix_vec = -1, ix_ia = 8;
   while ( ix_vec < 10 )
      ivec[ ++ix_vec ] = ia[ --ix_ia ];

         .  
  ,      
 LIFO (last in, fist out   ,  ). 
      (push)   (pop).
        .  push 
    ,      (  1
).        .   
   ?     ,
  .   :

   stack[ top++ ] = value;

      pop?    (  
  ),   .    
:

   int value = stack[ --top ];

(  stack     .   stack
   6.16.)

                               4.8

     ,      ++,   ++?

                      4.6.    

        ++   
   .   
     ,      
  .  ,     
      ,  
. (,        
 . . [PERSON68]     .) ,
 :

                                                             ++   160

   #inc1ude <complex>

   comp1ex< double > a;
   comp1ex< double > b;
   complex< double >  = a * b + a / b;

           :

   complex< double > complex_obj = a + 3.14159;

        ,   
   :

   complex_obj = dval;



   complex_obj = ival;

     . ,    
:

   // :   
   //   
   double dval = complex_obj;

     ,          
   .      ,
     .    
,      :

   double re = complex_obj.real();
   double im = complex_obj.imag();

    :

                                                             ++   161


   double im = imag(complex_obj);

          : +=,
-=, *=  /=.  ,

   complex_obj += second_complex_obj;

     /  .   
     ,   . , 
  

   complex< double > complex0( 3.14159, -2.171 );
   comp1ex< double > complex1( complexO.real() );
   cout << complexO << " " << complex1 << endl;

 :


   ( 3.14159, -2.171 ) ( 3.14159, 0.0 )

      :

   //      
   // 3.14159 ==> comp1ex( 3.14159 );
   // ( 3.14159 ) ==> comp1ex( 3.14159 );
   // ( 3.14, -1.0 ) ==> comp1ex( 3.14, -1.0 );
   //    
   // cin >> a >> b >> 
   //  a, b,  -  
   3.14159 ( 3.14159 ) ( 3.14, -1.0 )

     ,      -:

   sqrt(), abs(), polar(), sin(), cos(), tan(), exp(), log(), log10()  pow().

                                4.9

      ++,      , 
   ,     
 . ,   :

   complex_obj += 1;

   (   ++     , 
    .)       
  .   ,    

                                                               ++   162

   #include <complex>
   inline complex<double>&
   operator+=( complex<double> &cval, double dval )
   {
      return cval += complex<double>( dval );
   }

(       , 
   15.)
     ,       
 complex<double>.     ,  , 
   .

   #include <iostream>
   #include <complex>

   //  ...

   int main() {
      complex< double > cval ( 4.0, 1.0 );

      cout << cval << endl;
      cval += 1;
      cout << cval << endl;
      cval -= 1;
      cout << cval << endl;
      cval *= 2;
      cout << cval << endl;
      cout /= 2;
      cout << cval << endl;

   }

                                       4.10

    ++        
 .     :     :

   cval += 1;

    1   cval,    
   .      complex<double> 
  :

                                                           ++   163

   #include <iostream>
   #include <complex>

   //  ...

   int main() {
      complex< double > cval( 4.0, 1.0 );

      cout << cval << endl;
      ++cva1;
      cout << cval << endl;

   }

                             4.7.  

    ,   ,   
  ,   if-else. , :

   bool is_equal;
   if (!strcmp(str1,str2)) is_equal = true;
     else is_equal = false;

    :

   bool is_equa1 = !strcmp( strl, str2 ) ? true : false;

       :

   expr11 ? expr2 : expr3;

     expr1.     true,  expr2,
 false,  expr3.   :

   int min( int ia, int ib )
   { return ( ia < ib ) ? ia : ib; }



   int min(int ia, int ib) {
      if (ia < ib)
         return ia;
      else
         return ib;
   }

         :

                                                             ++   164

   #include <iostream>

   int main()
   {
      int i = 10, j = 20, k = 30;
      cout << "  "
       << i << "  " << j << "  "
              << ( i > j ? i : j ) << end1;

      cout << " " << i
             << ( i % 2 ? " ." : " ." )
             << endl;

      /*     ,
       *      .
       *    max  
       *    
      */

      int max = ( (i > j)
         ? (( i > k) ? i : k)
         : ( j > k ) ? j : k);

      cout << "  "
             << i << ", " << j << "  " << k
             << "  " << max << endl;
   }

   :

     10  20  20
    10 .

                                4.8.  sizeof

    sizeof        .  
:

   sizeof ( type name );
   sizeof ( object );
   sizeof object;

       size_t,    typedef 
  cstddef.       sizeof:

                                                            ++   165







size_t element_size = array_size / sizeof( int );

 sizeof     ,  ,  
          . , , 
,  int   4 ,  array_size  12. 
sizeof      ,   ,    :

size_t pointer_size = sizeof ( pi );

  pointer_size       (4  32-
),    ia.
  ,   sizeof:

#include <cstddef>
int ia[] = { 0, 1, 2 };
// sizeof    
size_t array_size = sizeof ia;
// sizeof    int
int *pi = new int[ 3 ];

++   166

}

   :

pi: 4 *pi: 4
st1: 12 st2: 12 ps: 4 *ps:12
short : 2
short* : 4
short& : 2
short[3] : 6

   ,   sizeof     
,    .    sizeof  ,
      .

,     ++   char  1.

size_t char_size = sizeof( char );
#include <string>
#include <iostream>
#include <cstddef>
int main() {
size_t ia;
ia = sizeof( ia ); // 
ia = sizeof ia; // 
// ia = sizeof int; // 
ia = sizeof( int ); // 
int *pi = new int[ 12 ];
cout << "pi: " << sizeof( pi )
<< " *pi: " << sizeof( pi )
<< endl;
// sizeof    
//   
string stl( "foobar" );
string st2( "a mighty oak" );
string *ps = &stl;
cout << " st1: " << sizeof( st1 )
<< " st2: " << sizeof( st2 )
<< " ps: sizeof( ps )
<< " *ps: " << sizeof( *ps )
<< endl;
cout << "short :\t" << sizeof(short) << endl;
cout << "shorf" :\t" << sizeof(short*) << endl;
cout << "short& :\t" << sizeof(short&) << endl;
cout << "short[3] :\t" << sizeof(short[3]) << endl;
// char_size == 1

++   167

  sizeof       .
    ,    ,    
   . :

int array[ sizeof( some_type_T )];

4.9.  new  delete

        , 
 .        
 ,       (heap). (  
       1.) ,   
     new,    
   ,    . :

int *pi = new int;

   int      pi  
.       ,    :

int *pi = new int( 1024 );

     :

int *pia = new int[ 10 ];

           
int.           
 . (      , 
       .) :

string *ps = new string;

      string,  ps   
         string.


string *psa = new string[10];

        string,  psa 
         .
,       new,   
.       ,    
     .
  ,   ,    
,   delete     . ( 

// :  

++   168

 delete  ,    ,  
,    .) :

delete pi;

 ,      int,    pi.


delete ps;

 ,      string,  
  ps.      . 

delete [] pia;

 ,    pia.    
   .
(  new  delete      8.)

 4.11

    ?

(a) vector<string> svec( 10 );
(b) vector<string> *pvecl = new vector<string>(10);
(c) vector<string> **pvec2 = new vector<string>[10];
(d) vector<string> *pvl = &svec;
(e) vector<string> *pv2 = pvecl;
(f) delete svec;
(g) delete pvecl;
(h) delete [] pvec2;
(i) delete pvl;
(j) delete pv2;

4.10.  

      ,  ; 
   .    
   .       
   .    
  ix,   0.

++   169

}

4.11.  

 4.3.  

   

~   ~expr
<<   expr1 << expr2
>>   expr1 >> expr2
&   expr1 & expr2
^ 
 
expr1 ^ expr2
|   expr1 | expr2
&=   

expr1 &= expr2
^= 
  

expr1 ^= expr2
|=   

expr1 |= expr2
<<=   

expr1 <<= expr2
>>=   

expr1 >>= expr2

       ,
         0  1.   
    . ,  
,    .     
  ,    . , 
      , ,  const 
volatile.  iostream      
 .
  ,  ++      :  C-
    string        :
     vector.      

int main()
{
//   ""
//  ia, sz  index     ...
int ival = (ia != 0)
? ix=get_va1ue(), ia[index]=ix
: ia=new int[sz], ia[index]=0;
// ...

++   170

  ,   ,    
     ,  unsigned int,   bitset
  ++.     ,
     .  , 
    :     (  1) 
?   ?

      bitset, , 
          .  
        
,      bitset.
        
  ,     ,   
  :     
      .
  (~)     . ,   1,
   0  .
  (<<, >>)        
  .    ,
  (   ,    ) 
.     ,       
     ,    
     ( ) .
  (&)        .  
     ,     .  
  1,        1,      0.
(  (&)       (&&),,  , 
       .)
   (^)   . 
   1,    (  0,   1).   
 ,   0.
  (|)       
.       1,     
    1,  0,      0.
(       .)
  .       30 .  
  ,    / .  
    . (,      ,
        .      
  ;  ,   1    1. 
 ,        .)

unsigned int quiz1 = 0;

           .
,  27  .  27    1,  
  .      .     ,
 1  27-   0  .     :

++   171

1 << 27;

      quiz1   , 
 :  27-     1,   
 .

quiz1 |= 1<<27;

  ,       ,
  27   .     27- ,  
.          ,
   ,  27-,  1:

~(1<<27 );

   ()    quiz1    : 0 
27-     .

quiz1 &= ~(1<<27);

     27- ?    true,  27-  
1,  false,  0:

bool hasPassed = quiz1 & (1<<27);

        
.         
  :

}

  :

has_passed_quiz[ index ] = bit_on( quiz1, index );

          , 
   .   ++    bitset,
   .

inline boo1 bit_on (unsigned int ui, int pos)
{
return u1 & ( 1 << pos );
enum students { Danny = 1, Jeffrey, Ethan, Zev, Ebie, // ...
AnnaP = 26, AnnaL = 27 };
const int student_size = 27;
//      1
boo1 has_passed_quiz[ student_size+l ];
for ( int index = 1; index <= student_size; ++-index )

++   172

 4.12

   :

unsigned int ui1 = 3, ui2 = 7;

   ?

(a) ui1 & ui2 (c) uil | ui2
(b) ui1 && ui2 (d) uil || ui2

 4.13

   bit_on(),   bit_turn_on() (
  1), bit_turn_off() (   0), flip_bit() (  
)  bit_off() ( true,    0). 
,   .

 4.14

      ,   unsigned
int?    ,      typedef
  -.   bit_on(), 
typedef,    .

4.12.  bitset

 4.4.    bitset

  

test(pos)  pos  1? a.test(4)
any()      1? a.any()
none()      1? a.none()
count()  ,  1 a.count()
size()    a.size()
[pos]    pos a[4]
flip()    a.flip()
flip(pos)    pos a.flip(4)
set()     1 a.set()
set(pos)   pos  1 a.set(4)
reset()     0 a.reset()
reset(pos)   pos  0 a.reset(4)
   ,      
      .  bitset
    .       
   ,   27- :

++   173

quiz1 |= 1<<27;

  bitset        :

quiz1[27] = 1;



quiz1.set(27);

(       ,   
.   ,     0.)
   bitset    :

#include <bitset>

  bitset     .   
      :

bitset<32> bitvec;

    bitset,  32     0  31. 
  .    any()  ,   
  .    true,      
 . :

bool is_set = bitvec.any();

 is_set   false,    bitset  
 .   none()  true,   
 :

bool is_not_set = bitvec.none();

      : 
 set()  reset()  . ,     1
  :

bitvec[ index ] = 1;

          
 test()    .  ()  true, 
   1,  false   . :

//  bitvec[0]=1 !;
for ( int index=0; index<32; ++index )
if ( index % 2 == 0 )
if ( bitvec.test( 0 ))

++   174

       :

cout << endl;

        :

bitvec[0] = 0;

 set()  reset()        . 
       . :

// -   

 flip()        :

bitvec.flip(); //    

       bitset.    
      .   
       .  N 
       .
:

bitset< 32 > bitvec2( Oxffff );

 bitvec2   :

00000000000000001111111111111111
  
cout << "bitvec:  :\n\t";
for ( int index = 0; index < 32; ++-index )
if ( bitvec[ index ] )
cout << index << " ";
bitvec.reset(0);
//   
bitvec.reset();
if (bitvec.none() != true)
// -  
//   1    bitvec
if ( bitvec.any() != true )
bitvec.f1ip( 0 ); //    
bitvec[0].flip(); //     

++   175

bitset< 32 > bitvec3( 012 );

 bitvec3      1  3:

00000000000000000000000000001010

         ,
    . ,   

bitvec4    ,   bitvec3:
bitset< 32 > bitvec4( bitval );

     ,    
  . :

bitset< 32 > bitvec5( bitval, 6, 4 );

    ,    bitvec3  bitvec4.   
,      :

bitset< 32 > bitvec6( bitval, 6 );

 bitset   -    bitset 
 .    ,      ,
  to_string():

string bitva1( bitvec3.to_string() );

 , to_long(),      
   unsigned long, , ,    unsigned long.
   ,       
   ++,    .
   bitset    . :

bitset<32> bitvec7 = bitvec2 & bitvec3;

 bitvec7       

bitvec2  bitvec3.
//  bitvec3
string bitva1( "1010" );
//      4: 1010
string bitval ( "1111110101100011010101" );
//       : 1010101
string bitva1( "1111110101100011010101" );

++   176

bitset<32> bitvec8 = bitvec2 | bitvec3;
 bitvec8      bitvec2 
bitvec3.          .

 4.15

       ?

(a) bitset<64> bitvec(32);
(b) bitset<32> bv( 1010101 );
(c) string bstr; cin >> bstr; bitset<8>bv( bstr );
(d) bitset<32> bv; bitset<16> bvl6( bv );

 4.16

        ?

(c) bitvec.f1ip( bitvec.count() );

 4.17

 : 1,2,3,5,8,13,21.    
 bitset<32>   ?     
    ?   
      .

4.13. 

       .
,    ival?

int ival = 6 + 3 * 4 / 2 + 2;

    ,  20.   
  9, 14  36.  : 14.
 ++       ,  ,  
  .    ,   
    .  ,   
 :

1. 3 * 4 => 12
2. 12 / 2 => 6
3. 6 + 6 => 12
4. 12 + 2 => 14
extern void bitstring(const char*);
bool bit_on (unsigned long, int);
bitset<32> bitvec;
(a) bitsting( bitvec.to_string().c_str() );
(b) if ( bit_on( bitvec.to_1ong(), 64 )) ...

++   177

     ,     . 
  ,   :

while ( ch = nextChar() != '\n' )

    ch ,   ,   
  .        ,
  nextChar(),  '\n',   true  false  
 ch.
      .   
   . :

4 * 5 + 7 * 2 ==> 34
4 * ( 5 + 7 * 2 ) ==> 76
4 * ( (5 + 7) * 2 ) ==> 96

        :

while ( (ch = nextChar()) != '\n' )

   ,  .  
,    :

ival = jval = kva1 = lval

 kval   lval,  jval    
,     ival   jval.
 , , . ,  

ival + jval + kva1 + 1va1

  ival  jval,     kval,   

lval.

  4.4     ++    
.        . 
      ,    ,
  . ,       , 
      .

 4.18

    ?     4.4.

(c) ch = buf[ bp++ ] != '\n'

 4.19

(a) ! ptr == ptr->next
(b) ~ uc ^ 0377 & ui << 4

++   178

         
, , -,   .  
,     .

 4.20

     -  
 . ,   ,   4.4.

(b) cout << ival % 2 ? "odd" : "even";

 4.4.  

  

::  

::name
::  

class::name
::  
 
namespace::name
.    object.member
->    

pointer->member
[]   variable[expr]
()   name(expr_list)
()   type(expr_list)
++   lvalue++
--   lvalue--
typeid   typeid(type)
typeid  

typeid(expr)
const_cast   const_cast<type>(expr)
dynamic_cast   dynamic_cast<type>(expr)
reinterpret_cast   reinterpret_cast<type>
(expr)
static_cast   static_cast<type>(expr)
sizeof   sizeof expr
sizeof   sizeof( type)
++   ++lvalue
--   --lvalue
(a) int i = doSomething(), 0;

++   179

~   ~expr
!   !expr
-   -expr
+   +expr
*  *expr
&  &expr
()   (type)expr
new   new type
new   

new type(exprlist)
new   new (exprlist)
type(exprlist)
new   

 
delete    
delete  
- 
 
->*    
 
pointer->
*pointer_to_member
.*    
 
object.*pointer_to_member
*  expr * expr
/  expr / expr
%    expr % expr
+  expr + expr
-  expr - expr
<<   expr << expr
>>   expr >> expr
<  expr < expr
<=    expr <= expr
>  expr > expr
>=    expr >= expr
==  expr == expr
!=   expr != expr
&   expr & expr
^ 

expr ^ expr

++   180


|   expr | expr
&&   expr && expr
||   expr || expr
?:   expr ? expr * expr
=  l- = expr
=, *=, /=, %=,
+=, -=, <<=, >>=,
&=, |=, ^=
  l- += expr  ..
throw 

throw expr
,  expr, expr

4.14.  

    :

ival = 3.541 + 3;

  ival   6.   :   
   3.541  double  3  int. C++    
 ,        .  
    .   :
      ,    
.
     3    double,    
 .      
,       .
     double    double.  
6.541.      ival.    
6.541  , ,       
   .     int.  double  int
 ,    (  ). 
, 6.541   6,      ival.
       , 
  .
        double  int, 
      . :

int ival = 0;
//    
double dva1 = 8.6;
int iva1 = 5;

++   181

ival += dva1 + 0.5; //   

       :

ival = static_cast< int >( 3.541 ) + 3;

          3.541  
int,      .
         (   ), 
   (  ).

4.14.1.   

        ,
     :

      :  
     .  
 . :

ival + dva1;

        .  
    ,   .
,     0  int    int*,
   0.    double   int.

ivat = dva1;

   ,     
  .   
   :

cout << "   2: " << sqrt( 2 ) << endt;
//    double  int
int ival = 3;
double dva1 = 3.14159;
// ival   double: 3.0
// 0      int*
int *pi = 0;
// dva1   int: 3
extern double sqrt( double );
// 2   double: 2.0

++   182

    ,      
 ,    .  
    . :

}

4.14.2.   

      
   ,      .  
 :

       ,   
     .  
    ;

   ,      ,
  int,       int.

     ,   
 long double.

      long double,       
 . ,      'a'
  long double ( 97   ASCII)  
     : 3.14159L + 'a'.
     long double,    double, 
   . :

dval + fva1 + ival;

  ,     double  long double,    float,
     float:

double difference( int ivati, int iva12 )
{
//    double
return ivati - iva12;
int iva1;
float fval;
double dval;
// fva1  iva1   double  
char cvat;
int iva1;
float fva1;
// iva1  cval   float  

++   183

cvat + fva1 + iva1;

      , ,     
.     ,  , 
  :     ,  int,   int.
     char, signed char, unsigned char  short int
  int.  unsigned short int   int,   
      unsigned short int (
   ,    short     int), 
  unsigned short int   unsigned int.
 wchar_t       , 
   . ,  

enum status { bad, ok };

   0  1.        char,
 char       .
    char  int.
  

cval + ulong; ulong + found; mval + ulong;

    cval, found  mval   int.
       .   
   unsigned long,      .    
 ,   ulong,    unsigned long.
     unsigned long,     long, 
    long. :

cval + 1024 + lval;

     :  unsigned int  long
    ,   long    
 unsigned int. (     32- ,   long,  int
   .)    long   
  unsigned int,     unsigned long.

char cval;
bool found;
enum mumble { ml, m2, m3 } mval;
unsigned long ulong;
char cval;
long lval;
// cval  1024   long  

++   184

     unsigned long  long,  
unsigned int.       ,   int.
 ,       .
  :      
   .      
 ,         
.

4.14.3.   

       :
static_cast, dynamic_cast, const_cast  reinterpret_cast. , , 
   ,    
,    ,  . 
 ,    .
          
void*,     ,     
,       .  
void*    . :

const void *pcv = pci; // 

  void*     .  
  ,   .    ,
    void*    . ++ 
   :

}
int iva1;
int *pi = 0;
char *pc = 0;
void *pv;
pv = pi; // :  
pv = pc; // :  
const int *pci = &iva1;
pv = pci; // : pv  ,   const void*;
#inc1ude <cstring>
int ival = 1024;
void *pv;
int *pi = &iva1;
const char *pc = "a casting call";
void mumble() {
pv = pi; // : pv   ival
pc = pv; // :   
char *pstr = new char[ str1en( pc )+1 ];
strcpy( pstr, pc );

++   185

    ,       pv
    ival,       
 .        ,   
strcpy(),          ,  
   ,     strcpy()     .
     ,   ++  
   void     .    
 :

}

       
       
. ,    ival    double,
    dval,       int.

ival += dval;

    ,   dval  int:

ival += static_cast< int >( dval );

      ,  
       . (
     9,      .)
     :

cast-name< type >( expression );

 cast-name      static_cast, const_cast, dynamic_cast
 reinterpret_cast,  type  ,     expression.
      ,    
  .  const_cast    
     (volatile)   . :

void mumble 0 {
// :  -  ,
//    !
//    
//   ...
pc = static_cast< char* >( pv );
char *pstr = new char[ str1en( pc )+1 ];
//     
strcpy( pstr, pc );
double dval;
int iva1;

++   186

char *pc = string_copy( const_cast< char* >( pc_str ));

   const_cast   ,   
        .
  static_cast   ,   
 ,     :

char ch = static_cast< char >( d );

  static_cast?   ,     
    .   static_cast
  ,  ,  ,    
.
 ,   static_cast  void*    
 ,       (enum), 
    . (     
    19.)
   ,      , 
        
:

mumble mums_the_word = static_cast< mumble >( ival );

 ival  mumble      ,  ival  1,
2  3.
reinterpret_cast      (re-interpret 
     ),   
    . :

char *pc = reinterpret_cast< char* >( pcom );

       ,    
 char* pc.       , 
     pc   :

string str( pc );
extern char *string_copy( char* );
const char *pc_str;
double d = 97.0;
enum mumble { first = 1, second, third };
extern int ival;
complex<double> *pcom;

++   187

       .
  , ,     
.         
 ,       ,      .
,    ,   ,  
    .
    ,      
 ,      .
        ++: 
      ,     
       
       .      
    pc      . 
  str    ,   ,
 pc   , ,  - ,   !
         ++ 
       . ,
      ++    
:

char *pc = (char*) pcom;

     reinterpret_cast,   
 .   xxx_cast      
,      .
      , ,  
    .   
      ,   
. (      
   (delete),         
.       8.4,    
 .)
 dynamic_cast       
(run-time type identification).         19.1.

4.14.4.    

   ,    ,
    ++;   ,  
.      ,     
. (       .)
      :

//   C++ 
type (expr);
// ,   C

++   188

(type) expr;

     static_cast, const_cast 
reinterpret_cast.
    :

int addr_va1ue = int( &iva1 );

     ++      
,       ++.

 4.21

  :

unsigned int ui;

     ?

(d) cva1 = ival + fvat + dva1;

 4.22

  :

const string *ps;

  ,     :

(d) pc = (char*) pv;
const char *pc = (const char*) pcom;
int ival = (int) 3.14159;
extern char *rewrite_str( char* );
char *pc2 = rewrite_str( (char*) pc );
char cval; int ival;
float fval; double dva1;
(a) cva1 = 'a' + 3;
(b) fval = ui - ival * 1.0;
(c) dva1 = ui * fval;
void *pv; int ival;
char *pc; double dval;
(a) pv = (void*)ps;
(b) ival = int( *pc );
(c) pv = &dva1;

++   189

4.15. :   Stack

    ,    
       .   
   iStack  ,     int.
   ,         
 (push)   (pop) .      
      (empty())   (full()),   
  (size()).         
 int.    :

};

       :  
        
. (  6    ,   
 .)
     _stack.  _top   
  .     
 .    size():    
  _top.

inline int iStack::size() { return _top; };
empty()  true,  _top  0; full()  true,  _top
 _stack.size()-1 (,      0,  
  1).
}
#include <vector>
class iStack {
public:
iStack( int capacity )
: _stack( capacity ), _top( 0 ) {}
bool pop( int &va1ue );
boot push( int value );
bool full();
bool empty();
void display();
int size();
private:
int _top;
vector< int > _stack;
inline bool iStack::empty() { return _top ? false : true; }
inline bool iStack::full() {
return _top < _stack.size()-l ? false : true;

++   190

   pop()  push().       
,     :

}

      ,   display(), 
   .     :

( 0 )

      0, 1, 2  3    display() :
( 4 )( bot: 0 1 2 3 :top )
   display():

}

       .  for  50 .
  (2, 4, 6, 8  ..)   .   ,  5 (5,
10, 15...),    .  ,  10 (10, 20,
30...),           .

bool iStack::pop( int &top_va1ue ) {
if ( empty() )
return false;
top_value = _stack[ --_top ];
cout << "iStack::pop(): " << top_value << endl;
return true;
}
bool iStack::push( int value ) {
cout << "iStack::push( " << value << " )\n";
if ( full() )
return false;
_stack[ _top++ ] = value;
return true;
void iStack::display() {
cout << "( " << size() << " )( bot: ";
for ( int ix = 0; ix < _top; ++ix )
cout << _stack[ ix ] <<" ";
cout << " :top )\n";

++   191

}

   :

( 0 )( bot: :top )
iStack push( 2 )
iStack push( 4 )
( 2 )( bot: 2 4 :top )
iStack push( 6 )
iStack push( 8 )
iStack push ( 10 )
( 5 )( bot: 2 4 6 8 10 :top )
iStack pop(): 10
iStack pop(): 8
( 3 )( bot: 2 4 6 :top )
iStack push( 12 )
iStack push( 14 )
( 5 )( bot: 2 4 6 12 14 :top )
iStack::push( 16 )
iStack::push( 18 )
iStack::push( 20 )
( 8 )( bot: 2 4 6 12 14 16 18 20 :top )
iStack::pop(): 20
iStack::pop(): 18
( 6 )( bot: 2 4 6 12 14 16 :top )
iStack::push( 22 )
iStack::push( 24 )
( 8 )( bot: 2 4 6 12 14 16 22 24 :top )
iStack::push( 26 )
iStack::push( 28 )
iStack::push( 30 )
( 11 )( bot: 2 4 6 12 14 16 22 24 26 28 30 :top )
iStack::pop(): 30
iStack::pop(): 28
( 9 )( bot: 2 4 6 12 14 16 22 24 26 :top )
iStack::push( 32 )
iStack::push( 34 )
( 11 )( bot: 2 4 6 12 14 16 22 24 26 32 34 :top )
iStack::push( 36 )
iStack::push( 38 )
iStack::push( 40 )
( 14 )( bot: 2 4 6 12 14 16 22 24 26 32 34 36 38 40 :top )
iStack::(): 40
iStack::popQ: 38
( 12 )( bot: 2 4 6 12 14 16 22 24 26 32 34 36 :top )
iStack::push( 42 )
iStack::push( 44 )
( 14 )( bot: 2 4 6 12 14 16 22 24 26 32 34 36 42 44 :top )
iStack::push( 46 )
iStack::push( 48 )
#inc1ude <iostream>
#inc1ude "iStack.h"
int main() {
iStack stack( 32 ) ;
stack.display();
for ( int ix = 1; ix < 51; ++ix )
{
if ( ix%2 == 0 )
stack.push( ix );
if ( ix%5 == 0 )
stack.display();
if ( ix%10 == 0 ) {
int dummy;
stack.pop( dummy ); stack.pop( dummy );
stack.display();
}

++   192

iStack::push( 50 )
( 17 )( bot: 2 4 6 12 14 16 22 24 26 32 34 36 42 44 46 48 50 :top )
iStack::pop(): 50
iStack::pop(): 48
( 15 )( bot: 2 4 6 12 14 16 22 24 26 32 34 36 42 44 46 :top )

 4.23

   peek(),      
    .   peek()   
 main()    .

 4.24

         iStack?   
?
