    4:	private: 
    5:	  int valueO; 
    6:	  int value1; 
    7:	  int value2; 
    8:	  int valueS; 
    9:	public: 
    10:	  PseudoArray(int v0, int v1, int v2, int v3) 
    11:	  { value0 = v0; value1 = v1; value2 = v2; values = v3; } 
    12:	  int Getlnt(unsigned i); 
    13:	  int operator[](unsigned i); 
    14:	}; 
    15: 
    16:	main()
    17:	{ 
    18:	  PseudoArray pa{10, 20, 30, 40); 
    19: 
    20:	  for (int i = 0; i <= 3; i++) 
    21:	   cout « "pa[" « i « "J == " « pa[i] « '\n'; 
    22:	  return 0; 
    23:	} 
    24: 
    25:	int PseudoArray::Getlnt(unsigned i) 
    26:	{ 
    27:	 switch (i) { 
    28:	  case 0: return value0; // Обратите внимание: break не нужен 
    29:	  case 1: return value1; // " 
    30:	  case 2: return value2; // 
    31:	  case 3: return value3; // " 
    32;	  default: return value0; 
    33:	  } 
    34:	} 
    35: 
    36:	int PseudoArray::operator[](unsigned i) 
    37:	{ 
    38:	  return Getlnt(i); 
    39:	} 

    В строке 12 демонстрируется обычный способ доступа к закрытым данным 
класса с помощью функции-члена GetlntO, возвращающей одно из целочисленных 
значений класса. Вы можете объявить объект класса и отобразить второе значение 
с помощью следующих операторов: 

    PseudoArray pa(10, 20, 30, 40); 
    cout « "Value #2 == " « pa.Getlnt(1);	// Вызов функции-члена 

    Это обычный способ "добраться" к закрытым членам класса. Поскольку в 
классе перегружен оператор индексации, вы также можете использовать следующий оператор: 

    cout « "Value #2 == " « ра[1];    // pa используется в качестве массива 

    В строке 21 приводится еще один пример. Выражения ра[1] и ра[2], 
оказывается, обеспечивают доступ к массиву несмотря на то, что указатель ра в 
действительности ссылается на объект класса. Перегрузка оператора индексации 
дает возможность использовать в массиве индексацию (удобный и ясный способ 
доступа к нескольким значениям) вместо вызова функции-члена для объекта класса.     
    Имейте в виду, что индексы перегруженных массивов могут быть произвольными 
типами данных. Например, вы можете заменить строку 13 на: 

    int operator[](char с); 

но затем использовать символьные индексы, подобные символам от 'А' до 'D', 
для индексации массива с начальным индексом 'А', в отличие от обычных массивов 
в С и C++, в которых используются целочисленные индексные  значения, начинающиеся 
с нуля. По сути, перегружая [] и используя символы в качестве индексов, вы устанавливаете 
соответствие между множеством символов и множеством значений, создавая тем самым 
так называемый ассоциативный массив. Вы можете реализовать функцию-член 
перегрузки оператора [] следуюobv образом: 

    int PseudoArray: :operator[](char с) 
   {
    return Getlnt(c - 'A'); 
    }

    Затем вы можете использовать символьную переменную в качестве индекса 
массива. Например, после внесения предыдущих изменений замените строки 20-21 
на следующие: 

    for( char с = 'А';  с<='D'; с++)
       cout  « "ра[" « с « "] == " « ра[с] «'\п'; 


    Глава 15. Передовые средства C++     377 
