объекта d невозможно. Уничтожение объекта d выполняется путем вызова четырех деструкторов (в указанном порядке): M2::~M2(), M1::~M1(), B2::~B2() и B1::~B1(). Если один из этих деструкторов не определен или не может быть вызван, то уничтожение объекта d невозможно. Каждый из этих конструкторов и деструкторов может быть либо определен пользователем, либо сгенерирован автоматически.

Если класс имеет конструктор, определенный пользователем, то неявный (сгенерированный компилятором) конструктор по умолчанию остается неопределенным (не генерируется).

A.12.5. Битовые поля

Битовое поле (bitfield) — это механизм упаковки многих маленьких значений в виде слова или в соответствии с установленным извне битовым форматом (например, форматом регистра какого-нибудь устройства). Рассмотрим пример.

struct PPN {

  unsigned int PFN: 22;

  int: 3;               // не используется

  unsigned int CCA;

  bool nonreacheable;

  bool dirty;

  bool valid;

  bool global;

};

Упаковка битовых полей в виде слова слева направо приводит к следующему формату (см. раздел 25.5.5).

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

A.12.6. Объединения

Объединение (union) — это класс, в котором все члены расположены в одной и той же области памяти. В каждый момент времени объединение может содержать только один элемент, причем считывается только тот элемент объединения, который был записан последним. Рассмотрим пример.

union U {

  int x;

  double d;

}

U a;

a.x = 7;

int x1 = a.x; // OK

a.d = 7.7;

int x2 = a.x; // Ой!

Правила согласованного чтения и записи членов объединения компилятором не проверяются. Мы вас предупредили. 

A.13. Шаблоны

Шаблон (template) — это класс или функция, параметризованные набором типов и/или целыми числами.

template<class T>

class vector {

public:

  // ...

  int size() const;

private:

  int sz;

  T* p;

};

template<class T>

int vector<T>::size() const

{

  return sz;

}

В списке шаблонных аргументов ключевое слово class означает тип; его эквивалентной альтернативой является ключевое слово typename. Функция-член шаблонного класса по умолчанию является шаблонной функцией с тем же списком шаблонных аргументов, что и у класса.

Целочисленные шаблонные аргументы должны быть константными выражениями.

template<typename T, int sz>

class Fixed_array {

public:

  T a[sz];

  // ...

  int size() const { return sz; };

};

Fixed_array<char,256> x1; // OK

int var = 226;

Fixed_array<char,var> x2; // ошибка: неконстантный шаблонный аргумент

A.13.1. Шаблонные аргументы

Аргументы шаблонного класса указываются каждый раз, когда используется его имя.

vector<int> v1;   // OK

vector v2;        // ошибка: пропущен шаблонный аргумент

vector<int,2> v3; // ошибка: слишком много шаблонных аргументов

vector<2> v4;     // ошибка: ожидается тип шаблонного аргумента

Аргументы шаблонной функции обычно выводятся из ее аргументов.

template<class T>

T find(vector<T>& v, int i)

{

 return v[i];

}

vector<int> v1;

vector<double> v2;

// ...

int x1 = find(v1,2); // здесь тип T — это int

int x2 = find(v2,2); // здесь тип T — это double

Можно объявить шаблонную функцию, для которой невозможно вывести ее шаблонные аргументы. В этом случае мы должны конкретизировать шаблонные аргументы явно (точно так же, как для шаблонных классов). Рассмотрим пример.

template<class T, class U> T* make(const U& u) { return new T(u); }

int* pi = make<int>(2);

Node* pn = make<Node>(make_pair("hello",17));

Этот код работает, только если объект класса Node можно инициализировать объектом класса pair<const char*,int> (раздел Б.6.3). Из механизма явной конкретизации шаблонной функции можно исключать только замыкающие шаблонные аргументы (которые будут выведены). 

A.13.2. Конкретизация шаблонов

Вариант шаблона для конкретного набора шаблонных аргументов называется специализацией (specialization). Процесс генерации специализаций на основе шаблона и набора аргументов называется конкретизацией шаблона (template instantiation). Как правило, эту задачу решает компилятор, но программист также может самостоятельно определить отдельную специализацию. Обычно это делается, когда общий шаблон для конкретного набора аргументов неприемлем. Рассмотрим пример.

template<class T> struct Compare { // общее сравнение

  bool operator()(const T& a,const T& b) const

  {

    return a<b;

  }

};

template<> struct Compare<const char*> { // сравнение C-строк

  bool operator()(const char* a,const char* b) const

  {

    return strcmp(a,b)==0;

  }

};

Compare<int> c2;          // общее сравнение

Compare<const char*> c;   // сравнение С-строк

bool b1 = c2(1,2);        // общее сравнение

bool b2 = c("asd","dfg"); // сравнение С-строк

Аналогом специализации для функций является перегрузка.

template<class T> bool compare(const T& a,const T& b)

{

  return a<b;

}

bool compare (const char* a, const char* b) // сравнение С-строк

{

  return strcmp(a,b)==0;

}

bool b3 = compare(2,3);         // общее сравнение

bool b4 = compare("asd","dfg"); // сравнение С-строк

Отдельная компиляция шаблонов (когда в заголовочных файлах содержатся только объявления, а в исходных файлах — однозначные определения) не гарантирует переносимость программы, поэтому, если шаблон необходимо использовать в разных исходных файлах, в заголовочном файле следует дать его полное определение.

A.13.3. Шаблонные типы членов-классов

Шаблон может иметь как члены, являющиеся типами, так и члены, не являющиеся типами (как данные-члены