Страница:
дополнительных расходов времени и памяти по сравнению с программами, в
которых наследуется не более одного класса. Статический контроль типов от
этого тоже не страдает.
Все неоднозначности выявляются на стадии трансляции:
class task
{
public:
void trace ();
// ...
};
class displayed
{
public:
void trace ();
// ...
};
class my_displayed_task:public displayed, public task
{
// в этом классе trace () не определяется
};
void g ( my_displayed_task * p )
{
p -> trace (); // ошибка: неоднозначность
}
В этом примере видны отличия С++ от объектно-ориентированных диалектов
языка Лисп, в которых есть множественное наследование. В этих диалектах
неоднозначность разрешается так: или считается существенным порядок
описания, или считаются идентичными объекты с одним и тем же именем в
разных базовых классах, или используются комбинированные способы, когда
совпадение объектов доля базовых классов сочетается с более сложным
способом для производных классов. В С++ неоднозначность, как правило,
разрешается введением еще одной функции:
class my_displayed_task:public displayed, public task
{
// ...
public:
void trace ()
{
// текст пользователя
displayed::trace (); // вызов trace () из displayed
task::trace (); // вызов trace () из task
}
// ...
};
void g ( my_displayed_task * p )
{
p -> trace (); // теперь нормально
}
Пусть члену класса (неважно функции-члену или члену, представляющему
данные) требуется защита от "несанкционированного доступа". Как разумно
ограничить множество функций, которым такой член будет доступен? Очевидный
ответ для языков, поддерживающих объектно-ориентированное
программирование, таков: доступ имеют все операции, которые определены для
этого объекта, иными словами, все функции-члены. Например:
class window
{
// ...
protected:
Rectangle inside;
// ...
};
class dumb_terminal : public window
{
// ...
public:
void prompt ();
// ...
};
Здесь в базовом классе window член inside типа Rectangle описывается
как защищенный (protected), но функции-члены производных классов,
например, dumb_terminal::prompt(), могут обратиться к нему и выяснить, с
какого вида окном они работают. Для всех других функций член
window::inside недоступен.
В таком подходе сочетается высокая степень защищенности
(действительно, вряд ли вы "случайно" определите производный класс) с
гибкостью, необходимой для программ, которые создают классы и используют
их иерархию (действительно, "для себя" всегда можно в производных классах
предусмотреть доступ к защищенным членам).
Неочевидное следствие из этого: нельзя составить полный и
окончательный список всех функций, которым будет доступен защищенный член,
поскольку всегда можно добавить еще одну, определив ее как функцию-член в
новом производном классе. Для метода абстракции данных такой подход часто
бывает мало приемлемым. Если язык ориентируется на метод абстракции
данных, то очевидное для него решение - это требование указывать в
описании класса список всех функций, которым нужен доступ к члену. В С++
для этой цели используется описание частных (private) членов. Оно
использовалось и в приводившихся описаниях классов complex и shape.
Важность инкапсуляции, т.е. заключения членов в защитную оболочку,
резко возрастает с ростом размеров программы и увеличивающимся разбросом
областей приложения. В $$6.6 более подробно обсуждаются возможности языка
по инкапсуляции.
Язык С++ проектировался как "лучший С", поддерживающий абстракцию
данных и объектно-ориентированное программирование. При этом он должен
быть пригодным для большинства основных задач системного программирования.
Основная трудность для языка, который создавался в расчете на методы
упрятывания данных, абстракции данных и объектно-ориентированного
программирования, в том, что для того, чтобы быть языком общего
назначения, он должен:
- идти на традиционных машинах;
- сосуществовать с традиционными операционными системами и языками;
- соперничать с традиционными языками программирования в эффективности
выполнения программы;
- быть пригодным во всех основных областях приложения.
Это значит, что должны быть возможности для эффективных числовых
операций (арифметика с плавающей точкой без особых накладных расходов,
иначе пользователь предпочтет Фортран) и средства такого доступа к памяти,
который позволит писать на этом языке драйверы устройств. Кроме того, надо
уметь писать вызовы функций в достаточно непривычной записи, принятой для
обращений в традиционных операционных системах. Наконец, должна быть
возможность из языка, поддерживающего объектно-ориентированное
программирование, вызывать функции, написанные на других языках, а из
других языков вызывать функцию на этом языке, поддерживающем
объектно-ориентированное программирование.
Далее, нельзя рассчитывать на широкое использование искомого языка
программирования как языка общего назначения, если реализация его целиком
полагается на возможности, которые отсутствуют в машинах с традиционной
архитектурой.
Если не вводить в язык возможности низкого уровня, то придется для
основных задач большинства областей приложения использовать некоторые
языки низкого уровня, например С или ассемблер. Но С++ проектировался с
расчетом, что в нем можно сделать все, что допустимо на С, причем без
увеличения времени выполнения. Вообще, С++ проектировался, исходя из
принципа, что не должно возникать никаких дополнительных затрат времени и
памяти, если только этого явно не пожелает сам программист.
Язык проектировался в расчете на современные методы трансляции,
которые обеспечивают проверку согласованности программы, ее эффективность
и компактность представления. Основным средством борьбы со сложностью
программ видится, прежде всего, строгий контроль типов и инкапсуляция.
Особенно это касается больших программ, создаваемых многими людьми.
Пользователь может не являться одним из создателей таких программ, и может
вообще не быть программистом. Поскольку никакую настоящую программу
нельзя написать без поддержки библиотек, создаваемых другими
программистами, последнее замечание можно отнести практически ко всем
программам.
С++ проектировался для поддержки того принципа, что всякая программа
есть модель некоторых существующих в реальности понятий, а класс является
конкретным представлением понятия, взятого из области приложения ($$12.2).
Поэтому классы пронизывают всю программу на С++, и налагаются жесткие
требования на гибкость понятия класса, компактность объектов класса и
эффективность их использования. Если работать с классами будет неудобно
или слишком накладно, то они просто не будут использоваться, и программы
выродятся в программы на "лучшем С". Значит пользователь не сумеет
насладиться теми возможностями, ради которых, собственно, и создавался
язык.
"Совершенство достижимо только в момент
краха".
(С.Н. Паркинсон)
В данной главе описаны основные типы (char, int, float и т.д.) и
способы построения на их основе новых типов (функций, векторов, указателей
и т.д.). Описание вводит в программу имя, указав его тип и, возможно,
начальное значение. В этой главе вводятся такие понятия, как описание и
определение, типы, область видимости имен, время жизни объектов.
Даются обозначения литеральных констант С++ и способы задания
символических констант. Приводятся примеры, которые просто
демонстрируют возможности языка. Более осмысленные примеры, иллюстрирующие
возможности выражений и операторов языка С++, будут приведены в следующей
главе. В этой главе лишь упоминаются средства для определения
пользовательских типов и операций над ними. Они обсуждаются в главах 5 и 7.
Имя (идентификатор) следует описать прежде, чем оно будет использоваться
в программе на С++. Это означает, что нужно указать его тип, чтобы
транслятор знал, к какого вида объектам относится имя. Ниже приведены
несколько примеров, иллюстрирующих все разнообразие описаний:
char ch;
int count = 1;
char* name = "Njal";
struct complex { float re, im; };
complex cvar;
extern complex sqrt(complex);
extern int error_number;
typedef complex point;
float real(complex* p) { return p->re; };
const double pi = 3.1415926535897932385;
struct user;
template<class T> abs(T a) { return a<0 ? -a : a; }
enum beer { Carlsberg, Tuborg, Thor };
Из этих примеров видно, что роль описаний не сводится лишь к привязке
типа к имени. Большинство указанных описаний одновременно являются
определениями, т.е. они создают объект, на который ссылается имя.
Для ch, count, name и cvar таким объектом является элемент памяти
соответствующего размера. Этот элемент будет использоваться как
переменная, и говорят, что для него отведена память. Для real подобным
объектом будет заданная функция.
Для константы pi объектом будет число 3.1415926535897932385.
Для complex объектом будет новый тип. Для point объектом является
тип complex, поэтому point становится синонимом complex. Следующие
описания уже не являются определениями:
extern complex sqrt(complex);
extern int error_number;
struct user;
Это означает, что объекты, введенные ими, должны быть определены
где-то в другом месте программы. Тело функции sqrt должно быть указано
в каком-то другом описании. Память для переменной error_number типа
int должна выделяться в результате другого описания error_number.
Должно быть и какое-то другое описание типа user, из которого можно
понять, что это за тип. В программе на языке С++ должно быть только
одно определение каждого имени, но описаний может быть много. Однако все
описания должны быть согласованы по типу вводимого в них объекта.
Поэтому в приведенном ниже фрагменте содержатся две ошибки:
int count;
int count; // ошибка: переопределение
extern int error_number;
extern short error_number; // ошибка: несоответствие типов
Зато в следующем фрагменте нет ни одной ошибки (об использовании
extern см. #4.2):
extern int error_number;
extern int error_number;
В некоторых описаниях указываются "значения" объектов, которые они
определяют:
struct complex { float re, im; };
typedef complex point;
float real(complex* p) { return p->re };
const double pi = 3.1415926535897932385;
Для типов, функций и констант "значение" остается неизменным;
для данных, не являющихся константами, начальное значение может
впоследствии изменяться:
int count = 1;
char* name = "Bjarne";
//...
count = 2;
name = "Marian";
Из всех определений только следующее не задает значения:
char ch;
Всякое описание, которое задает значение, является определением.
Описанием определяется область видимости имени. Это значит, что
имя может использоваться только в определенной части текста программы.
Если имя описано в функции (обычно его называют "локальным именем"), то
область видимости имени простирается от точки описания
до конца блока, в котором появилось это описание. Если имя не находится
в описании функции или класса (его обычно называют "глобальным именем"),
то область видимости простирается от точки описания до конца файла,
в котором появилось это описание.
Описание имени в блоке может скрывать описание в объемлющем блоке или
глобальное имя; т.е. имя может быть переопределено так, что оно будет
обозначать другой объект внутри блока. После выхода из блока прежнее
значение имени (если оно было) восстанавливается. Приведем пример:
int x; // глобальное x
void f()
{
int x; // локальное x скрывает глобальное x
x = 1; // присвоить локальному x
{
int x; // скрывает первое локальное x
x = 2; // присвоить второму локальному x
}
x = 3; // присвоить первому локальному x
}
int* p = &x; // взять адрес глобального x
В больших программах не избежать переопределения имен. К сожалению,
человек легко может проглядеть такое переопределение. Возникающие
из-за этого ошибки найти непросто, возможно потому, что они
достаточно редки. Следовательно, переопределение имен следует
свести к минимуму. Если вы обозначаете глобальные переменные или
локальные переменные в большой функции такими именами, как i или x,
то сами напрашиваетесь на неприятности.
Есть возможность с помощью операции разрешения области видимости
:: обратиться к скрытому глобальному имени, например:
int x;
void f2()
{
int x = 1; // скрывает глобальное x
::x = 2; // присваивание глобальному x
}
Возможность использовать скрытое локальное имя отсутствует.
Область видимости имени начинается в точке его описания (по
окончании описателя, но еще до начала инициализатора - см. $$R.3.2). Это
означает, что имя можно использовать даже до того, как задано его
начальное значение. Например:
int x;
void f3()
{
int x = x; // ошибочное присваивание
}
Такое присваивание недопустимо и лишено смысла. Если вы попытаетесь
транслировать эту программу, то получите предупреждение: "использование
до задания значения". Вместе с тем, не применяя оператора ::, можно
использовать одно и то же имя для обозначения двух различных объектов
блока. Например:
int x = 11;
void f4() // извращенный пример
{
int y = x; // глобальное x
int x = 22;
y = x; // локальное x
}
Переменная y инициализируется значением глобального x, т.е. 11,
а затем ей присваивается значение локальной переменной x, т.е. 22.
Имена формальных параметров функции считаются описанными в самом
большом блоке функции, поэтому в описании ниже есть ошибка:
void f5(int x)
{
int x; // ошибка
}
Здесь x определено дважды в одной и той же области видимости.
Это хотя и не слишком редкая, но довольно тонкая ошибка.
Можно выделять память для "переменных", не имеющих имен, и
использовать эти переменные.
Возможно даже присваивание таким странно выглядящим "переменным",
например, *p[a+10]=7. Следовательно, есть потребность именовать
"нечто хранящееся в памяти". Можно привести подходящую цитату из
справочного руководства: "Любой объект - это некоторая область
памяти, а адресом называется выражение, ссылающееся на объект или
функцию" ($$R.3.7). Слову адрес (lvalue - left value, т.е. величина
слева) первоначально приписывался смысл "нечто, что может в
присваивании стоять слева". Адрес может ссылаться и на константу
(см. $$2.5). Адрес, который не был описан со спецификацией const,
называется изменяемым адресом.
Если только программист не вмешается явно, объект будет создан при
появлении его определения и уничтожен, когда исчезнет из
области видимости. Объекты с глобальными именами создаются,
инициализируются (причем только один раз) и существуют до конца
программы. Если локальные объекты описаны со служебным словом
static, то они также существуют до конца программы. Инициализация их
происходит, когда в первый раз управление "проходит через"
описание этих объектов, например:
int a = 1;
void f()
{
int b = 1; // инициализируется при каждом вызове f()
static int c = a; // инициализируется только один раз
cout << " a = " << a++
<< " b = " << b++
<< " c = " << c++ << '\n';
}
int main()
{
while (a < 4) f();
}
Здесь программа выдаст такой результат:
a = 1 b = 1 c = 1
a = 2 b = 1 c = 2
a = 3 b = 1 c = 3
''Из примеров этой главы для краткости изложения исключена
макрокоманда #include <iostream>. Она нужна лишь в тех из них, которые
выдают результат.
Операция "++" является инкрементом, т. е. a++ означает: добавить 1
к переменной a.
Глобальная переменная или локальная переменная static, которая не была
явно инициализирована, инициализируется неявно нулевым значением (#2.4.5).
Используя операции new и delete, программист может создавать
объекты, временем жизни которых он управляет сам (см. $$3.2.6).
Имя (идентификатор) является последовательностью букв или цифр.
Первый символ должен быть буквой. Буквой считается и символ
подчеркивания _. Язык С++ не ограничивает число символов в имени.
Но в реализацию входят программные компоненты, которыми создатель
транслятора управлять не может (например, загрузчик), а они,
к сожалению, могут устанавливать ограничения. Кроме того, некоторые
системные программы, необходимые для выполнения программы на С++, могут
расширять или сужать множество символов, допустимых в идентификаторе.
Расширения (например, использование $ в имени) могут нарушить
переносимость программы. Нельзя использовать в качестве имен
служебные слова С++ (см. $$R.2.4), например:
hello this_is_a_most_unusially_long_name
DEFINED foO bAr u_name HorseSense
var0 var1 CLASS _class ___
Теперь приведем примеры последовательностей символов, которые не могут
использоваться как идентификаторы:
012 a fool $sys class 3var
pay.due foo~bar .name if
Заглавные и строчные буквы считаются различными, поэтому Count и
count - разные имена. Но выбирать имена, почти не отличающиеся
друг от друга, неразумно. Все имена, начинающиеся с символа
подчеркивания, резервируются для использования в самой реализации
или в тех программах, которые выполняются совместно с рабочей,
поэтому крайне легкомысленно вставлять такие имена в
свою программу.
При разборе программы транслятор всегда стремится выбрать самую
длинную последовательность символов, образующих имя, поэтому var10
- это имя, а не идущие подряд имя var и число 10. По той же причине
elseif - одно имя (служебное), а не два служебных имени else и if.
С каждым именем (идентификатором) в программе связан тип. Он
задает те операции, которые могут применяться к имени (т.е. к объекту,
который обозначает имя), а также интерпретацию этих операций.
Приведем примеры:
int error_number;
float real(complex* p);
Поскольку переменная error_number описана как int (целое), ей можно
присваивать, а также можно использовать ее значения в арифметических
выражениях. Функцию real можно вызывать с параметром, содержащим
адрес complex. Можно получать адреса и переменной, и функции.
Некоторые имена, как в нашем примере int и complex, являются именами
типов. Обычно имя типа нужно, чтобы задать в описании типа некоторое
другое имя. Кроме того, имя типа может использоваться
в качестве операнда в операциях sizeof (с ее помощью определяют
размер памяти, необходимый для объектов этого типа) и new (с ее
помощью можно разместить в свободной памяти объект этого типа).
Например:
int main()
{
int* p = new int;
cout << "sizeof(int) = " << sizeof(int) '\n';
}
Еще имя типа может использоваться в операции явного преобразования
одного типа к другому ($$3.2.5), например:
float f;
char* p;
//...
long ll = long(p); // преобразует p в long
int i = int(f); // преобразует f в int
Основные типы С++ представляют самые распространенные единицы памяти
машин и все основные способы работы с ними. Это:
char
short int
int
long int
Перечисленные типы используются для представления различного
размера целых. Числа с плавающей точкой представлены типами:
float
double
long double
Следующие типы могут использоваться для представления беззнаковых целых,
логических значений, разрядных массивов и т.д.:
unsigned char
unsigned short int
unsigned int
unsigned long int
Ниже приведены типы, которые используются для явного задания знаковых
типов:
signed char
signed short int
signed int
signed long int
Поскольку по умолчанию значения типа int считаются знаковыми, то
соответствующие типы с signed являются синонимами типов без
этого служебного слова.
Но тип signed char представляет особый интерес: все 3 типа - unsigned char,
signed char и просто char считаются различными (см. также $$R.3.6.1).
Для краткости (и это не влечет никаких последствий) слово int можно
не указывать в многословных типах, т.е. long означает long int, unsigned -
unsigned int. Вообще, если в описании не указан тип, то предполагается,
что это int. Например, ниже даны два определения объекта типа int:
const a = 1; // небрежно, тип не указан
static x; // тот же случай
Все же обычно пропуск типа в описании в надежде, что по умолчанию
это будет тип int, считается дурным стилем. Он может вызвать тонкий и
нежелательный эффект (см. $$R.7.1).
Для хранения символов и работы с ними наиболее подходит тип char.
Обычно он представляет байт из 8 разрядов. Размеры всех объектов в С++
кратны размеру char, и по определению значение sizeof(char) тождественно 1.
В зависимости от машины значение типа char может быть знаковым
или беззнаковым целым. Конечно, значение типа unsigned char всегда
беззнаковое, и, задавая явно этот тип, мы улучшаем переносимость
программы. Однако, использование unsigned char вместо char может
снизить скорость выполнения программы. Естественно, значение
типа signed char всегда знаковое.
В язык введено несколько целых, несколько беззнаковых типов
и несколько типов с плавающей точкой, чтобы программист мог полнее
использовать возможности системы команд. У многих машин
значительно различаются размеры выделяемой памяти, время доступа
и скорость вычислений для значений различных основных типов.
Как правило, зная особенности конкретной машины, легко выбрать
оптимальный основной тип (например, один из типов int) для данной
переменной. Однако, написать действительно переносимую программу,
использующую такие возможности низкого уровня, непросто. Для размеров
основных типов выполняются следующие соотношения:
1==sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long)
sizeof(float)<=sizeof(double)<=sizeof(long double)
sizeof(I)==sizeof(signed I)==sizeof(unsigned I)
Здесь I может быть типа char, short, int или long. Помимо этого
гарантируется, что char представлен не менее, чем 8 разрядами, short
- не менее, чем 16 разрядами и long - не менее, чем 32 разрядами. Тип char
достаточен для представления любого символа из набора символов
данной машины. Но это означает только то, что тип char может
представлять целые в диапазоне 0..127. Предположить большее -
рискованно.
Типы беззнаковых целых больше всего подходят для таких программ, в
которых память рассматривается как массив разрядов. Но, как
правило, использование unsigned вместо int, не дает ничего хорошего,
хотя таким образом рассчитывали выиграть еще один разряд для
представления положительных целых. Описывая переменную как unsigned,
нельзя гарантировать, что она будет только положительной, поскольку
допустимы неявные преобразования типа, например:
unsigned surprise = -1;
Это определение допустимо (хотя компилятор может выдать предупреждение
о нем).
В присваивании и выражении основные типы могут совершенно свободно
использоваться совместно. Значения преобразовываются всюду, где
это возможно, таким образом, чтобы информация не терялась. Точные
правила преобразований даны в $$R.4 и $$R.5.4.
Все-таки есть ситуации, когда информация может быть потеряна или
даже искажена. Потенциальным источником таких ситуаций становятся
присваивания, в которых значение одного типа присваивается значению
другого типа, причем в представлении последнего используется
меньше разрядов. Допустим, что следующие присваивания выполняются
на машине, в которой целые представляются в дополнительном коде, и символ
занимает 8 разрядов:
int i1 = 256+255;
char ch = i1 // ch == 255
int i2 = ch; // i2 == ?
В присваивании ch=i1 теряется один разряд (и самый важный!), а когда
мы присваиваем значение переменной i2, у переменной ch значение "все
единицы", т.е. 8 единичных разрядов. Но какое значение примет i2? На
машине DEC VAX, в которой char представляет знаковые значения, это будет
-1, а на машине Motorola 68K, в которой char - беззнаковый,
это будет 255. В С++ нет динамических средств контроля
подобных ситуаций, а контроль на этапе трансляции вообще слишком
сложен, поэтому надо быть осторожными.
Исходя из основных (и определенных пользователем) типов, можно с
помощью следующих операций описания:
* указатель
& ссылка
[] массив
() функция
а также с помощью определения структур, задать другие, производные типы.
Например:
int* a;
float v[10];
char* p[20]; // массив из 20 символьных указателей
void f(int);
struct str { short length; char* p; };
Правила построения типов с помощью этих операций подробно объяснены
в $$R.8. Ключевая идея состоит в том, что описание объекта производного
типа должно отражать его использование, например:
int v[10]; // описание вектора
i = v[3]; // использование элемента вектора
int* p; // описание указателя
i = *p; // использование указуемого объекта
Обозначения, используемые для производных типов, достаточно трудны
для понимания лишь потому, что операции * и & являются префиксными, а
[] и () - постфиксными. Поэтому в задании типов, если приоритеты
операций не отвечают цели, надо ставить скобки. Например, приоритет
операции [] выше, чем у *, и мы имеем:
int* v[10]; // массив указателей
int (*p)[10]; // указатель массива
Большинство людей просто запоминает, как выглядят наиболее часто
употребляемые типы.
Можно описать сразу несколько имен в одном описании. Тогда оно содержит
вместо одного имени список отделяемых друг от друга запятыми
имен. Например, можно так описать две переменные целого типа:
int x, y; // int x; int y;
Когда мы описываем производные типы, не надо забывать, что операции
описаний применяются только к данному имени (а вовсе не ко всем
остальным именам того же описания). Например:
int* p, y; // int* p; int y; НО НЕ int* y;
int x, *p; // int x; int* p;
int v[10], *p; // int v[10]; int* p;
Но такие описания запутывают программу, и, возможно, их следует
избегать.
Тип void синтаксически эквивалентен основным типам, но использовать
его можно только в производном типе. Объектов типа void не существует.
С его помощью задаются указатели на объекты неизвестного типа или
функции, невозвращающие значение.
void f(); // f не возвращает значения
void* pv; // указатель на объект неизвестного типа
Указатель произвольного типа можно присваивать переменной типа void*.
На первый взгляд этому трудно найти применение, поскольку для void*
недопустимо косвенное обращение (разыменование). Однако, именно
на этом ограничении основывается использование типа void*. Он
приписывается параметрам функций, которые не должны знать истинного
типа этих параметров. Тип void* имеют также бестиповые объекты,
которых наследуется не более одного класса. Статический контроль типов от
этого тоже не страдает.
Все неоднозначности выявляются на стадии трансляции:
class task
{
public:
void trace ();
// ...
};
class displayed
{
public:
void trace ();
// ...
};
class my_displayed_task:public displayed, public task
{
// в этом классе trace () не определяется
};
void g ( my_displayed_task * p )
{
p -> trace (); // ошибка: неоднозначность
}
В этом примере видны отличия С++ от объектно-ориентированных диалектов
языка Лисп, в которых есть множественное наследование. В этих диалектах
неоднозначность разрешается так: или считается существенным порядок
описания, или считаются идентичными объекты с одним и тем же именем в
разных базовых классах, или используются комбинированные способы, когда
совпадение объектов доля базовых классов сочетается с более сложным
способом для производных классов. В С++ неоднозначность, как правило,
разрешается введением еще одной функции:
class my_displayed_task:public displayed, public task
{
// ...
public:
void trace ()
{
// текст пользователя
displayed::trace (); // вызов trace () из displayed
task::trace (); // вызов trace () из task
}
// ...
};
void g ( my_displayed_task * p )
{
p -> trace (); // теперь нормально
}
Пусть члену класса (неважно функции-члену или члену, представляющему
данные) требуется защита от "несанкционированного доступа". Как разумно
ограничить множество функций, которым такой член будет доступен? Очевидный
ответ для языков, поддерживающих объектно-ориентированное
программирование, таков: доступ имеют все операции, которые определены для
этого объекта, иными словами, все функции-члены. Например:
class window
{
// ...
protected:
Rectangle inside;
// ...
};
class dumb_terminal : public window
{
// ...
public:
void prompt ();
// ...
};
Здесь в базовом классе window член inside типа Rectangle описывается
как защищенный (protected), но функции-члены производных классов,
например, dumb_terminal::prompt(), могут обратиться к нему и выяснить, с
какого вида окном они работают. Для всех других функций член
window::inside недоступен.
В таком подходе сочетается высокая степень защищенности
(действительно, вряд ли вы "случайно" определите производный класс) с
гибкостью, необходимой для программ, которые создают классы и используют
их иерархию (действительно, "для себя" всегда можно в производных классах
предусмотреть доступ к защищенным членам).
Неочевидное следствие из этого: нельзя составить полный и
окончательный список всех функций, которым будет доступен защищенный член,
поскольку всегда можно добавить еще одну, определив ее как функцию-член в
новом производном классе. Для метода абстракции данных такой подход часто
бывает мало приемлемым. Если язык ориентируется на метод абстракции
данных, то очевидное для него решение - это требование указывать в
описании класса список всех функций, которым нужен доступ к члену. В С++
для этой цели используется описание частных (private) членов. Оно
использовалось и в приводившихся описаниях классов complex и shape.
Важность инкапсуляции, т.е. заключения членов в защитную оболочку,
резко возрастает с ростом размеров программы и увеличивающимся разбросом
областей приложения. В $$6.6 более подробно обсуждаются возможности языка
по инкапсуляции.
Язык С++ проектировался как "лучший С", поддерживающий абстракцию
данных и объектно-ориентированное программирование. При этом он должен
быть пригодным для большинства основных задач системного программирования.
Основная трудность для языка, который создавался в расчете на методы
упрятывания данных, абстракции данных и объектно-ориентированного
программирования, в том, что для того, чтобы быть языком общего
назначения, он должен:
- идти на традиционных машинах;
- сосуществовать с традиционными операционными системами и языками;
- соперничать с традиционными языками программирования в эффективности
выполнения программы;
- быть пригодным во всех основных областях приложения.
Это значит, что должны быть возможности для эффективных числовых
операций (арифметика с плавающей точкой без особых накладных расходов,
иначе пользователь предпочтет Фортран) и средства такого доступа к памяти,
который позволит писать на этом языке драйверы устройств. Кроме того, надо
уметь писать вызовы функций в достаточно непривычной записи, принятой для
обращений в традиционных операционных системах. Наконец, должна быть
возможность из языка, поддерживающего объектно-ориентированное
программирование, вызывать функции, написанные на других языках, а из
других языков вызывать функцию на этом языке, поддерживающем
объектно-ориентированное программирование.
Далее, нельзя рассчитывать на широкое использование искомого языка
программирования как языка общего назначения, если реализация его целиком
полагается на возможности, которые отсутствуют в машинах с традиционной
архитектурой.
Если не вводить в язык возможности низкого уровня, то придется для
основных задач большинства областей приложения использовать некоторые
языки низкого уровня, например С или ассемблер. Но С++ проектировался с
расчетом, что в нем можно сделать все, что допустимо на С, причем без
увеличения времени выполнения. Вообще, С++ проектировался, исходя из
принципа, что не должно возникать никаких дополнительных затрат времени и
памяти, если только этого явно не пожелает сам программист.
Язык проектировался в расчете на современные методы трансляции,
которые обеспечивают проверку согласованности программы, ее эффективность
и компактность представления. Основным средством борьбы со сложностью
программ видится, прежде всего, строгий контроль типов и инкапсуляция.
Особенно это касается больших программ, создаваемых многими людьми.
Пользователь может не являться одним из создателей таких программ, и может
вообще не быть программистом. Поскольку никакую настоящую программу
нельзя написать без поддержки библиотек, создаваемых другими
программистами, последнее замечание можно отнести практически ко всем
программам.
С++ проектировался для поддержки того принципа, что всякая программа
есть модель некоторых существующих в реальности понятий, а класс является
конкретным представлением понятия, взятого из области приложения ($$12.2).
Поэтому классы пронизывают всю программу на С++, и налагаются жесткие
требования на гибкость понятия класса, компактность объектов класса и
эффективность их использования. Если работать с классами будет неудобно
или слишком накладно, то они просто не будут использоваться, и программы
выродятся в программы на "лучшем С". Значит пользователь не сумеет
насладиться теми возможностями, ради которых, собственно, и создавался
язык.
"Совершенство достижимо только в момент
краха".
(С.Н. Паркинсон)
В данной главе описаны основные типы (char, int, float и т.д.) и
способы построения на их основе новых типов (функций, векторов, указателей
и т.д.). Описание вводит в программу имя, указав его тип и, возможно,
начальное значение. В этой главе вводятся такие понятия, как описание и
определение, типы, область видимости имен, время жизни объектов.
Даются обозначения литеральных констант С++ и способы задания
символических констант. Приводятся примеры, которые просто
демонстрируют возможности языка. Более осмысленные примеры, иллюстрирующие
возможности выражений и операторов языка С++, будут приведены в следующей
главе. В этой главе лишь упоминаются средства для определения
пользовательских типов и операций над ними. Они обсуждаются в главах 5 и 7.
Имя (идентификатор) следует описать прежде, чем оно будет использоваться
в программе на С++. Это означает, что нужно указать его тип, чтобы
транслятор знал, к какого вида объектам относится имя. Ниже приведены
несколько примеров, иллюстрирующих все разнообразие описаний:
char ch;
int count = 1;
char* name = "Njal";
struct complex { float re, im; };
complex cvar;
extern complex sqrt(complex);
extern int error_number;
typedef complex point;
float real(complex* p) { return p->re; };
const double pi = 3.1415926535897932385;
struct user;
template<class T> abs(T a) { return a<0 ? -a : a; }
enum beer { Carlsberg, Tuborg, Thor };
Из этих примеров видно, что роль описаний не сводится лишь к привязке
типа к имени. Большинство указанных описаний одновременно являются
определениями, т.е. они создают объект, на который ссылается имя.
Для ch, count, name и cvar таким объектом является элемент памяти
соответствующего размера. Этот элемент будет использоваться как
переменная, и говорят, что для него отведена память. Для real подобным
объектом будет заданная функция.
Для константы pi объектом будет число 3.1415926535897932385.
Для complex объектом будет новый тип. Для point объектом является
тип complex, поэтому point становится синонимом complex. Следующие
описания уже не являются определениями:
extern complex sqrt(complex);
extern int error_number;
struct user;
Это означает, что объекты, введенные ими, должны быть определены
где-то в другом месте программы. Тело функции sqrt должно быть указано
в каком-то другом описании. Память для переменной error_number типа
int должна выделяться в результате другого описания error_number.
Должно быть и какое-то другое описание типа user, из которого можно
понять, что это за тип. В программе на языке С++ должно быть только
одно определение каждого имени, но описаний может быть много. Однако все
описания должны быть согласованы по типу вводимого в них объекта.
Поэтому в приведенном ниже фрагменте содержатся две ошибки:
int count;
int count; // ошибка: переопределение
extern int error_number;
extern short error_number; // ошибка: несоответствие типов
Зато в следующем фрагменте нет ни одной ошибки (об использовании
extern см. #4.2):
extern int error_number;
extern int error_number;
В некоторых описаниях указываются "значения" объектов, которые они
определяют:
struct complex { float re, im; };
typedef complex point;
float real(complex* p) { return p->re };
const double pi = 3.1415926535897932385;
Для типов, функций и констант "значение" остается неизменным;
для данных, не являющихся константами, начальное значение может
впоследствии изменяться:
int count = 1;
char* name = "Bjarne";
//...
count = 2;
name = "Marian";
Из всех определений только следующее не задает значения:
char ch;
Всякое описание, которое задает значение, является определением.
Описанием определяется область видимости имени. Это значит, что
имя может использоваться только в определенной части текста программы.
Если имя описано в функции (обычно его называют "локальным именем"), то
область видимости имени простирается от точки описания
до конца блока, в котором появилось это описание. Если имя не находится
в описании функции или класса (его обычно называют "глобальным именем"),
то область видимости простирается от точки описания до конца файла,
в котором появилось это описание.
Описание имени в блоке может скрывать описание в объемлющем блоке или
глобальное имя; т.е. имя может быть переопределено так, что оно будет
обозначать другой объект внутри блока. После выхода из блока прежнее
значение имени (если оно было) восстанавливается. Приведем пример:
int x; // глобальное x
void f()
{
int x; // локальное x скрывает глобальное x
x = 1; // присвоить локальному x
{
int x; // скрывает первое локальное x
x = 2; // присвоить второму локальному x
}
x = 3; // присвоить первому локальному x
}
int* p = &x; // взять адрес глобального x
В больших программах не избежать переопределения имен. К сожалению,
человек легко может проглядеть такое переопределение. Возникающие
из-за этого ошибки найти непросто, возможно потому, что они
достаточно редки. Следовательно, переопределение имен следует
свести к минимуму. Если вы обозначаете глобальные переменные или
локальные переменные в большой функции такими именами, как i или x,
то сами напрашиваетесь на неприятности.
Есть возможность с помощью операции разрешения области видимости
:: обратиться к скрытому глобальному имени, например:
int x;
void f2()
{
int x = 1; // скрывает глобальное x
::x = 2; // присваивание глобальному x
}
Возможность использовать скрытое локальное имя отсутствует.
Область видимости имени начинается в точке его описания (по
окончании описателя, но еще до начала инициализатора - см. $$R.3.2). Это
означает, что имя можно использовать даже до того, как задано его
начальное значение. Например:
int x;
void f3()
{
int x = x; // ошибочное присваивание
}
Такое присваивание недопустимо и лишено смысла. Если вы попытаетесь
транслировать эту программу, то получите предупреждение: "использование
до задания значения". Вместе с тем, не применяя оператора ::, можно
использовать одно и то же имя для обозначения двух различных объектов
блока. Например:
int x = 11;
void f4() // извращенный пример
{
int y = x; // глобальное x
int x = 22;
y = x; // локальное x
}
Переменная y инициализируется значением глобального x, т.е. 11,
а затем ей присваивается значение локальной переменной x, т.е. 22.
Имена формальных параметров функции считаются описанными в самом
большом блоке функции, поэтому в описании ниже есть ошибка:
void f5(int x)
{
int x; // ошибка
}
Здесь x определено дважды в одной и той же области видимости.
Это хотя и не слишком редкая, но довольно тонкая ошибка.
Можно выделять память для "переменных", не имеющих имен, и
использовать эти переменные.
Возможно даже присваивание таким странно выглядящим "переменным",
например, *p[a+10]=7. Следовательно, есть потребность именовать
"нечто хранящееся в памяти". Можно привести подходящую цитату из
справочного руководства: "Любой объект - это некоторая область
памяти, а адресом называется выражение, ссылающееся на объект или
функцию" ($$R.3.7). Слову адрес (lvalue - left value, т.е. величина
слева) первоначально приписывался смысл "нечто, что может в
присваивании стоять слева". Адрес может ссылаться и на константу
(см. $$2.5). Адрес, который не был описан со спецификацией const,
называется изменяемым адресом.
Если только программист не вмешается явно, объект будет создан при
появлении его определения и уничтожен, когда исчезнет из
области видимости. Объекты с глобальными именами создаются,
инициализируются (причем только один раз) и существуют до конца
программы. Если локальные объекты описаны со служебным словом
static, то они также существуют до конца программы. Инициализация их
происходит, когда в первый раз управление "проходит через"
описание этих объектов, например:
int a = 1;
void f()
{
int b = 1; // инициализируется при каждом вызове f()
static int c = a; // инициализируется только один раз
cout << " a = " << a++
<< " b = " << b++
<< " c = " << c++ << '\n';
}
int main()
{
while (a < 4) f();
}
Здесь программа выдаст такой результат:
a = 1 b = 1 c = 1
a = 2 b = 1 c = 2
a = 3 b = 1 c = 3
''Из примеров этой главы для краткости изложения исключена
макрокоманда #include <iostream>. Она нужна лишь в тех из них, которые
выдают результат.
Операция "++" является инкрементом, т. е. a++ означает: добавить 1
к переменной a.
Глобальная переменная или локальная переменная static, которая не была
явно инициализирована, инициализируется неявно нулевым значением (#2.4.5).
Используя операции new и delete, программист может создавать
объекты, временем жизни которых он управляет сам (см. $$3.2.6).
Имя (идентификатор) является последовательностью букв или цифр.
Первый символ должен быть буквой. Буквой считается и символ
подчеркивания _. Язык С++ не ограничивает число символов в имени.
Но в реализацию входят программные компоненты, которыми создатель
транслятора управлять не может (например, загрузчик), а они,
к сожалению, могут устанавливать ограничения. Кроме того, некоторые
системные программы, необходимые для выполнения программы на С++, могут
расширять или сужать множество символов, допустимых в идентификаторе.
Расширения (например, использование $ в имени) могут нарушить
переносимость программы. Нельзя использовать в качестве имен
служебные слова С++ (см. $$R.2.4), например:
hello this_is_a_most_unusially_long_name
DEFINED foO bAr u_name HorseSense
var0 var1 CLASS _class ___
Теперь приведем примеры последовательностей символов, которые не могут
использоваться как идентификаторы:
012 a fool $sys class 3var
pay.due foo~bar .name if
Заглавные и строчные буквы считаются различными, поэтому Count и
count - разные имена. Но выбирать имена, почти не отличающиеся
друг от друга, неразумно. Все имена, начинающиеся с символа
подчеркивания, резервируются для использования в самой реализации
или в тех программах, которые выполняются совместно с рабочей,
поэтому крайне легкомысленно вставлять такие имена в
свою программу.
При разборе программы транслятор всегда стремится выбрать самую
длинную последовательность символов, образующих имя, поэтому var10
- это имя, а не идущие подряд имя var и число 10. По той же причине
elseif - одно имя (служебное), а не два служебных имени else и if.
С каждым именем (идентификатором) в программе связан тип. Он
задает те операции, которые могут применяться к имени (т.е. к объекту,
который обозначает имя), а также интерпретацию этих операций.
Приведем примеры:
int error_number;
float real(complex* p);
Поскольку переменная error_number описана как int (целое), ей можно
присваивать, а также можно использовать ее значения в арифметических
выражениях. Функцию real можно вызывать с параметром, содержащим
адрес complex. Можно получать адреса и переменной, и функции.
Некоторые имена, как в нашем примере int и complex, являются именами
типов. Обычно имя типа нужно, чтобы задать в описании типа некоторое
другое имя. Кроме того, имя типа может использоваться
в качестве операнда в операциях sizeof (с ее помощью определяют
размер памяти, необходимый для объектов этого типа) и new (с ее
помощью можно разместить в свободной памяти объект этого типа).
Например:
int main()
{
int* p = new int;
cout << "sizeof(int) = " << sizeof(int) '\n';
}
Еще имя типа может использоваться в операции явного преобразования
одного типа к другому ($$3.2.5), например:
float f;
char* p;
//...
long ll = long(p); // преобразует p в long
int i = int(f); // преобразует f в int
Основные типы С++ представляют самые распространенные единицы памяти
машин и все основные способы работы с ними. Это:
char
short int
int
long int
Перечисленные типы используются для представления различного
размера целых. Числа с плавающей точкой представлены типами:
float
double
long double
Следующие типы могут использоваться для представления беззнаковых целых,
логических значений, разрядных массивов и т.д.:
unsigned char
unsigned short int
unsigned int
unsigned long int
Ниже приведены типы, которые используются для явного задания знаковых
типов:
signed char
signed short int
signed int
signed long int
Поскольку по умолчанию значения типа int считаются знаковыми, то
соответствующие типы с signed являются синонимами типов без
этого служебного слова.
Но тип signed char представляет особый интерес: все 3 типа - unsigned char,
signed char и просто char считаются различными (см. также $$R.3.6.1).
Для краткости (и это не влечет никаких последствий) слово int можно
не указывать в многословных типах, т.е. long означает long int, unsigned -
unsigned int. Вообще, если в описании не указан тип, то предполагается,
что это int. Например, ниже даны два определения объекта типа int:
const a = 1; // небрежно, тип не указан
static x; // тот же случай
Все же обычно пропуск типа в описании в надежде, что по умолчанию
это будет тип int, считается дурным стилем. Он может вызвать тонкий и
нежелательный эффект (см. $$R.7.1).
Для хранения символов и работы с ними наиболее подходит тип char.
Обычно он представляет байт из 8 разрядов. Размеры всех объектов в С++
кратны размеру char, и по определению значение sizeof(char) тождественно 1.
В зависимости от машины значение типа char может быть знаковым
или беззнаковым целым. Конечно, значение типа unsigned char всегда
беззнаковое, и, задавая явно этот тип, мы улучшаем переносимость
программы. Однако, использование unsigned char вместо char может
снизить скорость выполнения программы. Естественно, значение
типа signed char всегда знаковое.
В язык введено несколько целых, несколько беззнаковых типов
и несколько типов с плавающей точкой, чтобы программист мог полнее
использовать возможности системы команд. У многих машин
значительно различаются размеры выделяемой памяти, время доступа
и скорость вычислений для значений различных основных типов.
Как правило, зная особенности конкретной машины, легко выбрать
оптимальный основной тип (например, один из типов int) для данной
переменной. Однако, написать действительно переносимую программу,
использующую такие возможности низкого уровня, непросто. Для размеров
основных типов выполняются следующие соотношения:
1==sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long)
sizeof(float)<=sizeof(double)<=sizeof(long double)
sizeof(I)==sizeof(signed I)==sizeof(unsigned I)
Здесь I может быть типа char, short, int или long. Помимо этого
гарантируется, что char представлен не менее, чем 8 разрядами, short
- не менее, чем 16 разрядами и long - не менее, чем 32 разрядами. Тип char
достаточен для представления любого символа из набора символов
данной машины. Но это означает только то, что тип char может
представлять целые в диапазоне 0..127. Предположить большее -
рискованно.
Типы беззнаковых целых больше всего подходят для таких программ, в
которых память рассматривается как массив разрядов. Но, как
правило, использование unsigned вместо int, не дает ничего хорошего,
хотя таким образом рассчитывали выиграть еще один разряд для
представления положительных целых. Описывая переменную как unsigned,
нельзя гарантировать, что она будет только положительной, поскольку
допустимы неявные преобразования типа, например:
unsigned surprise = -1;
Это определение допустимо (хотя компилятор может выдать предупреждение
о нем).
В присваивании и выражении основные типы могут совершенно свободно
использоваться совместно. Значения преобразовываются всюду, где
это возможно, таким образом, чтобы информация не терялась. Точные
правила преобразований даны в $$R.4 и $$R.5.4.
Все-таки есть ситуации, когда информация может быть потеряна или
даже искажена. Потенциальным источником таких ситуаций становятся
присваивания, в которых значение одного типа присваивается значению
другого типа, причем в представлении последнего используется
меньше разрядов. Допустим, что следующие присваивания выполняются
на машине, в которой целые представляются в дополнительном коде, и символ
занимает 8 разрядов:
int i1 = 256+255;
char ch = i1 // ch == 255
int i2 = ch; // i2 == ?
В присваивании ch=i1 теряется один разряд (и самый важный!), а когда
мы присваиваем значение переменной i2, у переменной ch значение "все
единицы", т.е. 8 единичных разрядов. Но какое значение примет i2? На
машине DEC VAX, в которой char представляет знаковые значения, это будет
-1, а на машине Motorola 68K, в которой char - беззнаковый,
это будет 255. В С++ нет динамических средств контроля
подобных ситуаций, а контроль на этапе трансляции вообще слишком
сложен, поэтому надо быть осторожными.
Исходя из основных (и определенных пользователем) типов, можно с
помощью следующих операций описания:
* указатель
& ссылка
[] массив
() функция
а также с помощью определения структур, задать другие, производные типы.
Например:
int* a;
float v[10];
char* p[20]; // массив из 20 символьных указателей
void f(int);
struct str { short length; char* p; };
Правила построения типов с помощью этих операций подробно объяснены
в $$R.8. Ключевая идея состоит в том, что описание объекта производного
типа должно отражать его использование, например:
int v[10]; // описание вектора
i = v[3]; // использование элемента вектора
int* p; // описание указателя
i = *p; // использование указуемого объекта
Обозначения, используемые для производных типов, достаточно трудны
для понимания лишь потому, что операции * и & являются префиксными, а
[] и () - постфиксными. Поэтому в задании типов, если приоритеты
операций не отвечают цели, надо ставить скобки. Например, приоритет
операции [] выше, чем у *, и мы имеем:
int* v[10]; // массив указателей
int (*p)[10]; // указатель массива
Большинство людей просто запоминает, как выглядят наиболее часто
употребляемые типы.
Можно описать сразу несколько имен в одном описании. Тогда оно содержит
вместо одного имени список отделяемых друг от друга запятыми
имен. Например, можно так описать две переменные целого типа:
int x, y; // int x; int y;
Когда мы описываем производные типы, не надо забывать, что операции
описаний применяются только к данному имени (а вовсе не ко всем
остальным именам того же описания). Например:
int* p, y; // int* p; int y; НО НЕ int* y;
int x, *p; // int x; int* p;
int v[10], *p; // int v[10]; int* p;
Но такие описания запутывают программу, и, возможно, их следует
избегать.
Тип void синтаксически эквивалентен основным типам, но использовать
его можно только в производном типе. Объектов типа void не существует.
С его помощью задаются указатели на объекты неизвестного типа или
функции, невозвращающие значение.
void f(); // f не возвращает значения
void* pv; // указатель на объект неизвестного типа
Указатель произвольного типа можно присваивать переменной типа void*.
На первый взгляд этому трудно найти применение, поскольку для void*
недопустимо косвенное обращение (разыменование). Однако, именно
на этом ограничении основывается использование типа void*. Он
приписывается параметрам функций, которые не должны знать истинного
типа этих параметров. Тип void* имеют также бестиповые объекты,