5.4 Друзья и Объединения

Предположим, вы определили два класса, vector и matrix (вектор и матрица). Каждый скрывает свое представление и предоставляет полный набор действий для манипуляции объектами его типа. Теперь определим функцию, умножающую матрицу на вектор. Для простоты допустим, что в векторе четыре элемента, которые индексируются 0...3, и что матрица состоит из четырех векторов, индексированных 0...3. Допустим также, что доступ к элементам вектора осуществляется через функцию elem(), которая осуществляет проверку индекса, и что в matrix имеется аналогичная функция. Один подход состоит в определении глобальной функции multiply() (перемножить) примерно следующим образом:

  vector multiply(matrix& m, vector& v);
  {
      vector r;
      for (int i = 0; i<3; i++) {    // r[i] = m[i] * v;
          r.elem(i) = 0;
          for (int j = 0; j<3; j++)
              r.elem(i) += m.elem(i,j) * v.elem(j);
      }
      return r;
  }

  class matrix;
  class vector {
      float v[4];
      // ...
      friend vector multiply(matrix&, vector&);
  };
  class matrix {
      vector v[4];
      // ...
      friend vector multiply(matrix&, vector&);
  };

  vector multiply(matrix& m, vector& v);
  {
      vector r;
      for (int i = 0; i<3; i++) {    // r[i] = m[i] * v;
          r.v[i] = 0;
          for (int j = 0; j<3; j++)
              r.v[i] += m.v[i][j] * v.v[j];
      }
      return r;
  }

5.4.3 Вложенные Классы

Описание класса может быть вложенным. Например:

  class set {
      struct setmem {
          int mem;
          setmem* next;
          setmem(int m, setmem* n) { mem=m; next=n; }
      };
      setmem* first;
  public:
      set() { first=0; }
      insert(int m) { first = new setmem(m,first);}
      // ...
  };

  class set {
      struct setmem {
          int mem;
          setmem* next;
          setmem(int m, setmem* n)
      };
      // ...
  };
      setmem::setmem(int m, setmem* n) { mem=m, next=n}
      setmem m1(1,0);

5.4.4 Статические Члены

Класс - это тип, а не объект данных, и в каждом объекте класса имеется своя собственная копия данных, членов этого класса. Однако некоторые типы наиболее элегантно реализуются, если все объекты этого типа могут совместно использовать (разделять) некоторые данные. Предпочтительно, чтобы такие разделяемые данные были описаны как часть класса. Например, для управления задачами в операционной системе или в ее модели часто бывает полезен список всех задач:

  class task {
      // ...
      task* next;
      static task* task_chain;
      void shedule(int);
      void wait(event);
      // ...
  };

  task::task_chain

5.4.5 Указатели на Члены

5.4.6 Структуры и Объединения

По определению struct - это просто класс, все члены которого общие, то есть

  struct s { ...
есть просто сокращенная запись
  class s { public: ...

  union tok_val {
      char* p;          // строка
      char v[8];        // идентификатор (максимум 8 char)
      long i;           // целые значения
      double d;         // значения с плавающей точкой
  };

  void strange(int i)
  {
      tok_val x;
      if (i)
          x.p = "2";
      else
          x.d = 2;
      sqrt(x.d);            // ошибка если i != 0
  }

  tok_val curr_val = 12;    // ошибка: int присваивается tok_val'у

  union tok_val {
      char* p;          // строка
      char v[8];        // идентификатор (максимум 8 char)
      long i;           // целые значения
      double d;         // значения с плавающей точкой
      tok_val(char*);     // должна выбрать между p и v
      tok_val(int ii)     { i = ii; }
      tok_val()           { d = dd; }
  };

5.5 Конструкторы и Деструкторы

5.5.2 Статическая Память

Рассмотрим следующее:

  table tbl1(100);
  void f() {
      static table tbl2(200);
  }
  main()
  {
      f();
  }

5.5.3 Свободная Память

Рассмотрим:

  main() {
      table* p = new table(100);
      table* q = new table(200);
      delete p;
      delete p;             // возможно, ошибка
  }

5.5.4 Объекты Класса и Члены

Рассмотрим

  class classdef {
      table members;
      int no_of_members;
      // ...
      classdef(int size);
      ~classdef();
  };

  classdef::classdef(int size)
  : members(size)
  {
      no_of_members = size;
      // ...
  }

  class classdef {
      table members;
      table friends;
      int no_of_members;
      // ...
      classdef(int size);
      ~classdef();
  };

  classdef::classdef(int size)
  : friends(size), members(size)
  {
      no_of_members = size;
      // ...
  }

  classdef::classdef(int size)
  : friends(size=size/2), members(size);      // дурной стиль
  {
      no_of_members = size;
      // ...
  }

  classdef::classdef(int size)
  : members(size)
  {
      no_of_members = size;
      // ...
  }

  class classdef {
      table* members;
      table* friends;
      int no_of_members;
      // ...
      classdef(int size);
      ~classdef();
  };
  classdef::classdef(int size)
  {
      members = new table(size);
      friends = new table;          // размер таблицы по умолчанию
      no_of_members = size;
      // ...
  }

  classdef::~classdef()
  {
      // ...
      delete members;
      delete friends;
  }

5.5.5 Вектора Объектов Класса

Чтобы описать вектор объектов класса, имеющего конструктор, этот класс должен иметь конструктор, который может вызываться без списка параметров. Нельзя использовать даже параметры по умолчанию. Например:

  table tblvec[10];

5.5.6 Небольшие Объекты

Когда вы используете много небольших объектов, размещаемых в свободной памяти, то вы можете обнаружить, что ваша программа тратит много времени выделяя и освобождая память под эти объекты. Первое решение - это обеспечить более хороший распределитель памяти общего назначения, второе для разработчика классов состоит в том, чтобы взять под контроль управление свободной памятью для объектов некоторого класса с помощью подходящих конструкторов и деструкторов.
Рассмотрим класс name, который использовался в примерах table. Его можно было бы определить так:

  struct name {
      char* string;
      name* next;
      double value;
      name(char*, double, name*);
      ~name();
  };

  const NALL = 128;
  name* nfree;

  name::name(char* s, double v, name* n)
  {
      register name* p = nfree;       // сначала выделить
      if (p)
          nfree = p->next;
      else {                          // выделить и сцепить
          name* q = (name*)new char[ NALL*sizeof(name) ];
          for (p=nfree=&q[NALL-1]; qnext = p-1;
          (p+1)->next = 0;
      }
      this = p;                       // затем инициализировать
      string = s;
      value = v;
      next = n;
  }

5.5.7 Предостережение

Когда в конструкторе производится присваивание указателю this, значение this до этого присваивания не определено. Таким образом, ссылка на член до этого присваивания не определена и скорее всего приведет к катастрофе. Имеющийся компилятор не пытается убедиться в том, что присваивание указателю this происходит на всех траекториях выполнения:

  mytype::mytype(int i)
  {
      if (i) this = mytype_alloc();
      // присваивание членам
  };

  mytype::mytype(int i)
  {
      if (this == 0) this = mytype_alloc();
      // присваивание членам
  };

5.5.8 Объекты Переменного Размера

Когда пользователь берет управление распределением и освобождением памяти, он может конструировать объекты, размер которых во время компиляции недетерминирован. В предыдущих примерах вмещающие (или контейнерные - перев.) классы vector, stack, intset и table реализовывались как структуры доступа фиксированного размера, содержание указатели на реальную память. Это подразумевает, что для создания таких объектов в свободной памяти необходимо две операции по выделению памяти, и что любое обращение к хранимой информации будет содержать дополнительную косвенную адресацию. Например:

  class char_stack {
      int size;
      char* top;
      char* s;
  public:
      char_stack(int sz) { top=s=new char[size=sz]; }
      ~char_stack()      { delete s; }     // деструктор
      void push(char c)  { *top++ = c; }
      char pop()         { return *--top; }
  };

  class char_stack {
      int size;
      char* top;
      char s[1];
  public:
      char_stack(int sz);
      void push(char c)  { *top++ = c; }
      char pop()         { return *--top; }
  };
  char_stack::char_stack(int sz)
  {
      if (this) error("стек не в свободной памяти");
      if (sz < 1) error("размер стека < 1");
      this = (char_stack*) new char[sizeof(char_stack)+sz-1];
      size = sz;
      top = s;
  }

5.6 Упражнения