Программирование. Принципы и практика использования C++ Исправленное издание

A.7.1. Определения

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

double f();        // объявление

double f() { /* ... */ }; // также определение

extern const int x;    // объявление

int y;           // также определение

int z = 10;        // определение с явной инициализацией

Константы должны быть инициализированы. Для этого используется инициализатор, если константа не объявлена с помощью ключевого слова extern (в таком случае инициализатор вместе с определением должны быть расположены в другом месте) или если константа не имеет тип, имеющий конструктор по умолчанию (раздел A.12.3). Константные члены класса должны инициализироваться в каждом конструкторе с помощью инициализатора (раздел A.12.3).

A.8.1. Указатели

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

int x = 7;

int* pi = &x; // указатель pi ссылается на объект x

int xx = *pi; // *pi — это значение объекта,

        // на который ссылается указатель pi, т.е. 7

Некорректный указатель — это указатель, не содержащий указателя ни на один объект.

int* pi2;     // неинициализированный

*pi2 = 7;     // неопределенное поведение

pi2 = 0;      // нулевой указатель (указатель pi2 остается некорректным)

*pi2 = 7;     // неопределенное поведение

pi2 = new int(7); // теперь указатель pi2 становится корректным

int xxx = *pi2;  // отлично: переменная xxx становится равной 7

Мы хотим, чтобы все некорректные указатели были нулевыми (

0

if (p2 == 0) { // "если указатель некорректный"

        // не используйте значение *p2

}

Или еще проще:

if (p2) { // "если указатель корректный"

      // используйте значение *p2

}

См. разделы 17.4 и 18.5.4.

Перечислим операции над указателями на объекты (не

void

<

<=

>

>+

Подчеркнем, что операции арифметики указателей (например,

++p

p+=7

Только операции над указателем типа

void*

Указатель на функцию (см. раздел 27.2.5) можно только копировать и вызывать. Рассмотрим пример.

typedef void (*Handle_type)(int);

void my_handler(int);

Handle_type handle = my_handler;

handle(10); // эквивалент my_handler(10)

A.8.2. Массивы

Массив (array) — это неразрывная последовательность объектов (элементов) одинакового типа, имеющая фиксированную длину.

int a[10]; // 10 целых чисел

Если массив является глобальным, то его элементы могут быть инициализированы соответствующим значением, принятым для данного типа по умолчанию. Например, значение

a[7]

0

new

Имя массива неявно преобразуется в указатель на его первый элемент. Рассмотрим пример.

int* p = a; // указатель p ссылается на элемент a[0]

Массив или указатель на элемент массива может индексироваться с помощью оператора

[]

a[7] = 9;

int xx = p[6];

Элементы массива нумеруются начиная с нуля (разделы 18.5).

Диапазон индексов массива не проверяется. Кроме того, поскольку они часто передаются с помощью указателей, информация, необходимая для проверки диапазона, передается пользователям ненадежным способом. Рекомендуем использовать класс

vector

int a[max]; // sizeof(a) == sizeof(int)*max

Можно определить и использовать массив массивов (двумерный массив), массив массивов массивов (многомерный массив) и т.д. Рассмотрим пример.

double da[100][200][300]; // 300 элементов типа, состоящего из

da[7][9][11] = 0;

Нетривиальное использование многомерных массивов — тонкое и уязвимое для ошибок дело (см. раздел 24.4). Если у вас есть выбор, следует предпочесть класс

Matrix

A.8.3. Ссылки

Ссылка (reference) — это синоним (alias), т.е. альтернативное имя объекта.

int a = 7;

int& r = a;

r = 8; // переменная a становится равной 8

Ссылки часто используются в качестве параметров функций, чтобы предотвратить копирование.

void f(const string& s);

// ...

f("эту строку слишком дорого копировать, \\

  поэтому используется ссылка");

См. разделы 8.5.4–8.5.6.

A.9.1. Разрешение перегрузки

Разрешение перегрузки (overload resolution) — это процесс выбора функции для вызова на основе набора аргументов. Рассмотрим пример.

void print(int);

void print(double);

void print(const std::string&);

print(123);  // вызывается print(int)

print(1.23);  // вызывается print(double)

print("123"); // вызывается print(const string&)

Компилятор, руководствуясь правилами языка, может самостоятельно выбрать правильную функцию. К сожалению, эти правила довольно сложные, поскольку они пытаются учесть максимально сложные примеры. Здесь мы приведем их упрощенный вариант.

Выбор правильного варианта перегруженной функции осуществляется на основе поиска наилучшего соответствия между типами аргументов функции и типами ее параметров (формальных аргументов).

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

1. Точное совпадение, т.е. совпадение при полном отсутствии преобразований типов или при наличии только самых простых преобразований (например, преобразование имени массива в указатель, имени функции — в указатель на функцию и типа

T

const T

2. Совпадение после продвижения, т.е. целочисленные продвижения (

bool

int

char

int

short

int

float

double

3. Совпадение после стандартных преобразований, например,

int

double

double

int

double

long double

Derived*

Base*

T*

void*

int

unsigned int

4. Совпадение после преобразований, определенных пользователем (см. раздел A.5.2.3).

5. Совпадение на основе эллипсиса ... в объявлении функции (раздел A.9.3). Если найдено два совпадения, то вызов отменяется как неоднозначный. Правила разрешения перегрузки ориентированы в основном на встроенные числовые типы (см. раздел A.5.3).

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

void f(int, const string&, double); 

void f(int, const char*, int); 

f(1,"hello",1);      // OK: call f(int, const char*, int) 

f(1,string("hello"),1.0); // OK: call f(int, const string&, double) 

f(1, "hello",1.0);     // ошибка: неоднозначность 

В последнем вызове строка "

hello

const char*

const string&

1.0

double

int

f()

Если эти упрощенные правила не соответствуют правилам вашего компилятора и вашим представлениям, в первую очередь следует предположить, что ваша программа сложнее, чем требуется. Постарайтесь упростить код, в противном случае проконсультируйтесь с экспертами.

A.9.2. Аргументы по умолчанию

Иногда функции имеют больше аргументов, чем это требуется в наиболее часто встречающихся распространенных ситуациях. Для того чтобы учесть это обстоятельство, программист может предусмотреть аргументы по умолчанию, которые будут использоваться, если при вызове соответствующие аргументы не будут заданы. Рассмотрим пример.

void f(int, int=0, int=0);

f(1,2,3);

f(1,2); // вызовы f(1,2,0)

f(1); // вызовы f(1,0,0)

Задавать по умолчанию можно только замыкающие аргументы. Рассмотрим пример.

void g(int, int =7, int); // ошибка: по умолчанию задан

              // не замыкающий аргумент

f(1,,1);          // ошибка: пропущен второй аргумент

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

A.9.3. Неопределенные аргументы

Можно задать функцию, не указав ни количество аргументов, ни их тип. Для этого используется эллипсис (...), означающий “и, возможно, другие аргументы”. Например, вот как выглядит объявление и некоторые вызовы, вероятно, самой известной функции в языке C:

printf()

void printf(const char* format ...); // получает форматную строку и,

                    // может быть, что-то еще

int x = 'x';

printf("hello, world!");

printf("print a char '%c'\n",x);  // печатает целое число x как

                   // символ

printf("print a string \"%s\"",x); // "выстрел себе в ногу"

Спецификаторы формата в форматной строке, такие как

%c

%s

A.9.4. Спецификации связей

Код на языке С++ часто используется наряду с кодом на языке С в одной и той же программе; иначе говоря, одни части бывают написаны на языке С++ (и скомпилированы с помощью компилятора языка С++), а другие — на языке С (и скомпилированы с помощью компилятора языка С). Для того чтобы воспользоваться этой возможностью, язык С++ предлагает программистам спецификации связей (linkage specifications), указывающие, что та или иная функция может быть вызвана из модуля, написанного на языке С. Спецификацию связи с языком С можно поместить перед объявлением функции.

extern "C" void callable_from_C(int);

В качестве альтернативы ее можно применить ко всем объявлениям в блоке.

extern "C" {

void callable_from_C(int);

int and_this_one_also(double, int*);

/* ... */

}

Детали можно найти в разделе 27.2.3.

В языке С нет возможности перегружать функции, поэтому можете поместить спецификацию связи с языком С только в одной версии перегруженной функции.

A.10.1. Перегрузка операций

Программист может определить смысл большинства операторов, принимающих операнды пользовательского типа. Изменить стандартный смысл операторов для встроенных типов или ввести новый оператор невозможно. Имя оператора, определенного пользователем (перегруженного оператора), состоит из символа оператора, которому предшествует ключевое слово

operator

+

operator +

Matrix operator+(const Matrix&, const Matrix&);

Примеры можно найти в определениях классов

std::ostream

std::vector

std::complex

Matrix

Перегрузить можно все операторы за исключением следующих:

?: . .* :: sizeof typeid

Функции, определяющие следующие операторы, должны быть членами класса:

= [ ] ( ) –>

Все остальные операторы можно определить и как члены-функции, и как самостоятельные функции.

Обратите внимание на то, что каждый пользовательский тип имеет оператор

=

&

,

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

A.12.1. Доступ к членам класса

Открытый член класса доступен для пользователей; закрытый член класса доступен только членам класса.

class Date {

public:

 // ...

 int next_day();

private:

 int y, m, d;

};

void Date::next_day() { return d+1; } // OK

void f(Date d)

{

 int nd = d.d+1; // ошибка: Date::d — закрытый член класса

 // ...

}

Структура — это класс, члены которого по умолчанию являются открытыми.

struct S {

 // члены (открытые, если явно не объявлены закрытыми)

};

Более подробная информация о доступе к членам класса, включая обсуждение защищенных членов, приведена в разделе 14.3.4.

К членам объекта можно обращаться с помощью оператора

.

–>

struct Date {

 int d, m, y;

 int day() const { return d; } // определенный в классе

 int month() const;       // просто объявленный; определен

                // в другом месте

 int year() const;       // просто объявленный; определен

                 // в другом месте

};

Date x;

x.d = 15;      // доступ через переменную

int y = x.day();   // вызов через переменную

Date* p = &x;

p–>m = 7;      // доступ через указатель

int z = p–>month(); // вызов через указатель

На члены класса можно ссылаться с помощью оператора

::

int Date::year() const { return y; } // определение за пределами

                    // класса

В функциях-членах класса можно ссылаться на другие члены класса, не указывая имя класса.

struct Date {

 int d, m, y;

 int day() const { return d; }

 // ...

};

Такие имена относятся к объекту, из которого вызвана функция:

void f(Date d1, Date d2)

{

 d1.day(); // обращается к члену d1.d

 d2.day(); // обращается к члену d2.d

 // ...

}

A.12.2. Определения членов класса

Члены класса, являющиеся целочисленными константами, функциями или типами, могут быть определены как в классе, так и вне его.

struct S {

 static const int c = 1;

 static const int c2;

 void f() { }

 void f2();

 struct SS { int a; };

 struct SS2;

};

Члены, которые не были определены в классе, должны быть определены “где-то”.

const int S::c2 = 7;

void S::f2() { }

struct S::SS2 { int m; };

Статические константные целочисленные члены класса (

static const int

struct X {

 int x;

 int y = 7; // ошибка: нестатические данные-члены

       // не могут инициализироваться внутри класса

 static int z = 7; // ошибка: данные-члены, не являющиеся

          // константами, не могут инициализироваться

           // внутри класса

 static const string ae = "7"; // ошибка: нецелочисленный тип

                 // нельзя инициализировать

                 // внутри класса

 static const int oe = 7; // OK: статический константный

              // целочисленный тип

};

int X::x = 7; // ошибка: нестатические члены класса нельзя

       // определять вне класса 

Если вам необходимо инициализировать не статические и не константные данные-члены, используйте конструкторы.

Функции-члены не занимают память, выделенную для объекта.

struct S {

 int m;

 void f();

};

Здесь

sizeof(S)==sizeof(int)

A.12.3. Создание, уничтожение и копирование

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

class Date {

public:

 Date(int yy,int mm,int dd):y(yy),m(mm),d(dd) { }

 // ...

private:

 int y,m,d;

};

Date d1(2006,11,15); // OK: инициализация с помощью конструктора

Date d2;       // ошибка: нет инициализации

Date d3(11,15);   // ошибка: неправильная инициализация

            // (требуются три инициализатора)

Обратите внимание на то, что данные-члены могут быть инициализированы с помощью списка инициализации в конструкторе. Члены класса инициализируются в порядке их определения в классе.

Конструкторы обычно используются для установления инвариантов класса и получения ресурсов (см. разделы 9.4.2 и 9.4.3).

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

Если конструктор с одним аргументом не объявлен с помощью ключевого слова

explicit

class Date {

public:

 Date(string);

 explicit Date(long); // используется целочисленное

            // представление даты

 // ...

};

void f(Date);

Date d1 = "June 5, 1848"; // OK

f("June 5, 1848");     // OK

Date d2 = 2007*12*31+6*31+5; // ошибка: Date(long) — явный

               // конструктор

f(2007*12*31+6*31+5);     // ошибка: Date(long) — явный конструктор

Date d3(2007*12*31+6*31+5);     // OK

Date d4 = Date(2007*12*31+6*31+5); // OK

f(Date(2007*12*31+6*31+5));     // OK

Если базовые классы или члены производного класса не требуют явных аргументов и в классе нет других конструкторов, то автоматически генерируется конструктор по умолчанию (default constructor). Этот конструктор инициализирует каждый объект базового класса и каждый член, имеющий конструктор по умолчанию (оставляя члены, не имеющие конструкторы по умолчанию, неинициализированными). Рассмотрим пример.

struct S {

 string name, address;

 int x;

};

Этот класс

S

S()

address

x

A.12.4. Производные классы

Класс можно определить производным от других классов. В этом случае он наследует члены классов, от которых происходит (своих базовых классов).

struct B {

 int mb;

 void fb() { };

};

class D:B {

 int md;

 void fd();

};

В данном случае класс

B

mb

fb()

D

mb

fb()

md

fd()

Как и члены класса, базовые классы могут быть открытыми и закрытыми (

public

private

Class DD:public B1,private B2 {

 // ...

};

В таком случае открытые члены класса

B1

DD

B2

DD

DD

B1

B2

Если класс имеет несколько непосредственных базовых классов (как, например, класс

DD

Указатель на производный класс

D

B

B

D

struct B { };

struct B1: B { }; // B — открытый базовый класс по отношению

          // к классу B1

struct B2: B { }; // B — открытый базовый класс по отношению

          // к классу B1

struct C { };

struct DD : B1, B2, private C { };

DD* p = new DD;

B1* pb1 = p; // OK

B* pb = p;  // ошибка: неоднозначность: B1::B или B2::B

C* pc = p;  // ошибка: DD::C — закрытый класс

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

Более подробную информацию о производных классах можно найти в разделе 14.3. Описание защищенного наследования (

protected

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.1. Шаблонные аргументы

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

vector v1;   // OK

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

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

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

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

template

T find(vector& v, int i)

{

 return v[i];

}

vector v1;

vector v2;

// ...

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

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

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

template T* make(const U& u) { return new T(u); }

int* pi = make(2);

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

Этот код работает, только если объект класса

Node

pair

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

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

template struct Compare { // общее сравнение

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

  {

   return a

 }

};

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

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

 {

   return strcmp(a,b)==0;

 }

};

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

Compare c;  // сравнение С-строк

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

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

template bool compare(const T& a,const T& b)

{

 return a

}

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

{

 return strcmp(a,b)==0;

}

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

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