|
Архитектура Аудит Военная наука Иностранные языки Медицина Металлургия Метрология Образование Политология Производство Психология Стандартизация Технологии |
|
|
Архитектура Аудит Военная наука Иностранные языки Медицина Металлургия Метрология Образование Политология Производство Психология Стандартизация Технологии |
Стандартный массив – это вектор
Хотя встроенный массив формально и обеспечивает механизм контейнера, он, как мы видели выше, не поддерживает семантику абстракции контейнера. До принятия стандарта C++ для программирования на таком уровне мы должны были либо приобрести нужный класс, либо реализовать его самостоятельно. Теперь же класс массива является частью стандартной библиотеки C++. Только называется он не массив, а вектор. Разумеется, вектор реализован в виде шаблона класса. Так, мы можем написать vector< int> ivec(10); vector< string> svec(10); Есть два существенных отличия нашей реализации шаблона класса Array от реализации шаблона класса vector. Первое отличие состоит в том, что вектор поддерживает как присваивание значений существующим элементам, так и вставку дополнительных элементов, то есть динамически растет во время выполнения, если программист решил воспользоваться этой его возможностью. Второе отличие более радикально и отражает существенное изменение парадигмы проектирования. Вместо того чтобы поддержать большой набор операций-членов, применимых к вектору, таких, как sort(), min(), max(), find()и так далее, класс vector предоставляет минимальный набор: операции сравнения на равенство и на меньше, size() и empty(). Более общие операции, перечисленные выше, определены как независимые обобщенные алгоритмы. Для использования класса vector мы должны включить соответствующий заголовочный файл.
// разные способы создания объектов типа vector vector< int> vec0; // пустой вектор
const int size = 8; const int value = 1024;
// вектор размером 8 // каждый элемент инициализируется 0 vector< int> vec1(size);
// вектор размером 8 // каждый элемент инициализируется числом 1024 vector< int> vec2(size, value);
// вектор размером 4 // инициализируется числами из массива ia int ia[4] = { 0, 1, 1, 2 }; vector< int> vec3(ia, ia+4);
// vec4 - копия vec2 #include < vector> vector< int> vec4(vec2); Так же, как наш класс Array, класс vector поддерживает операцию доступа по индексу. Вот пример перебора всех элементов вектора: #include < vector> extern int getSize();
void mumble() { int size = getSize(); vector< int> vec(size);
for (int ix=0; ix< size; ++ix) vec[ix] = ix;
//... } Для такого перебора можно также использовать итераторную пару. Итератор – это объект класса, поддерживающего абстракцию указательного типа. В шаблоне класса vector определены две функции-члена – begin() и end(), устанавливающие итератор соответственно на первый элемент вектора и на элемент, который следует за последним. Вместе эти две функции задают диапазон элементов вектора. Используя итератор, предыдущий пример можно переписать таким образом: #include < vector> extern int getSize();
void mumble() { int size = getSize(); vector< int> vec(size);
vector< int>:: iterator iter = vec.begin();
for (int ix=0; iter! =vec.end(); ++iter, ++ix) *iter = ix;
//... } Определение переменной iter vector< int>:: iterator iter = vec.begin(); инициализирует ее адресом первого элемента вектора vec. iterator определен с помощью typedef в шаблоне класса vector, содержащего элементы типа int. Операция инкремента ++iter перемещает итератор на следующий элемент вектора. Чтобы получить сам элемент, нужно применить операцию разыменования: *iter В стандартной библиотеке С++ имеется поразительно много функций, работающих с классом vector, но определенных не как функции-члены класса, а как набор обобщенных алгоритмов. Вот их неполный перечень: алгоритмы поиска: find(), find_if(), search(), binary_search(), count(), count_if(); алгоритмы сортировки и упорядочения: sort(), partial_sort(), merge(), partition(), rotate(), reverse(), random_shuffle(); алгоритмы удаления: unique(), remove(); численные алгоритмы: accumulate(), partial_sum(), inner_product(), adjacent_difference(); алгоритмы генерации и изменения последовательности: generate(), fill(), transform(), copy(), for_each(); алгоритмы сравнения: equal(), min(), max(). В число параметров этих обобщенных алгоритмов входит итераторная пара, задающая диапазон элементов вектора, к которым применяется алгоритм. Скажем, чтобы упорядочить все элементы некоторого вектора ivec, достаточно написать следующее: sort ( ivec.begin(), ivec.end() ); Чтобы применить алгоритм sort() только к первой половине вектора, мы напишем: sort ( ivec.begin(), ivec.begin() + ivec.size()/2 ); Роль итераторной пары может играть и пара указателей на элементы встроенного массива. Пусть, например, нам дан массив: int ia[7] = { 10, 7, 9, 5, 3, 7, 1 }; Упорядочить весь массив можно вызовом алгоритма sort(): sort ( ia, ia+7 ); Так можно упорядочить первые четыре элемента: sort ( ia, ia+4 ); Для использования алгоритмов в программу необходимо включить заголовочный файл #include < algorithm> Ниже приведен пример программы, использующей разнообразные алгоритмы в применении к объекту типа vector:
Стандартная библиотека С++ поддерживает и ассоциативные массивы. Ассоциативный массив – это массив, элементы которого можно индексировать не только целыми числами, но и значениями любого типа. В терминологии стандартной библиотеки ассоциативный массив называется отображением (map). Например, телефонный справочник может быть представлен в виде ассоциативного массива, где индексами служат фамилии абонентов, а значениями элементов – телефонные номера: #include < map> #include < string> #include " TelephoneNumber.h"
map< string, telephoneNum> telephone_directory; (Классы векторов, отображений и других контейнеров в подробностях описываются в главе 6. Мы попробуем реализовать систему текстового поиска, используя эти классы. В главе 12 рассмотрены обобщенные алгоритмы, а в Приложении приводятся примеры их использования.) В данной главе были очень бегло рассмотрены основные аспекты программирования на С++, основы объектно-ориентированного подхода применительно к данному языку и использование стандартной библиотеки. В последующих главах мы разберем эти вопросы более подробно и систематично. Упражнение 2.22
Поясните результаты каждого из следующих определений вектора: Упражнение 2.23 Напишите две реализации функции min(), объявление которой приведено ниже. Функция должна возвращать минимальный элемент массива. Используйте цикл for и перебор элементов с помощью
индекса итератора elemType min (const vector< elemType> & vec); Часть II Основы языка Код программы и данные, которыми программа манипулирует, записываются в память компьютера в виде последовательности битов. Бит – это мельчайший элемент компьютерной памяти, способная хранить либо 0, либо 1. На физическом уровне это соответствует электрическому напряжению, которое, как известно, либо есть, либо нет. Посмотрев на содержимое памяти компьютера, мы увидим что-нибудь вроде: 00011011011100010110010000111011... Очень трудно придать такой последовательности смысл, но иногда нам приходится манипулировать и подобными неструктурированными данными (обычно нужда в этом возникает при программировании драйверов аппаратных устройств). С++ предоставляет набор операций для работы с битовыми данными. (Мы поговорим об этом в главе 4.) Как правило, на последовательность битов накладывают какую-либо структуру, группируя биты в байты и слова. Байт содержит 8 бит, а слово – 4 байта, или 32 бита. Однако определение слова может быть разным в разных операционных системах. Сейчас начинается переход к 64-битным системам, а еще недавно были распространены системы с 16-битными словами. Хотя в подавляющем большинстве систем размер байта одинаков, мы все равно будем называть эти величины машинно-зависимыми. Так выглядит наша последовательность битов, организованная в байты. Рис 1. Адресуемая машинная память Теперь мы можем говорить, например, о байте с адресом 1040 или о слове с адресом 1024 и утверждать, что байт с адресом 1032 не равен байту с адресом 1040. Однако мы не знаем, что же представляет собой какой-либо байт, какое-либо машинное слово. Как понять смысл тех или иных 8 бит? Для того чтобы однозначно интерпретировать значение этого байта (или слова, или другого набора битов), мы должны знать тип данных, представляемых данным байтом. С++ предоставляет набор встроенных типов данных: символьный, целый, вещественный – и набор составных и расширенных типов: строки, массивы, комплексные числа. Кроме того, для действий с этими данными имеется базовый набор операций: сравнение, арифметические и другие операции. Есть также операторы переходов, циклов, условные операторы. Эти элементы языка С++ составляют тот набор кирпичиков, из которых можно построить систему любой сложности. Первым шагом в освоении С++ станет изучение перечисленных базовых элементов, чему и посвящена часть II данной книги. Глава 3 содержит обзор встроенных и расширенных типов, а также механизмов, с помощью которых можно создавать новые типы. В основном это, конечно, механизм классов, представленный в разделе 2.3. В главе 4 рассматриваются выражения, встроенные операции и их приоритеты, преобразования типов. В главе 5 рассказывается об инструкциях языка. И наконец глава 6 представляет стандартную библиотеку С++ и контейнерные типы – вектор и ассоциативный массив. 3. Типы данных С++ В этой главе приводится обзор встроенных, или элементарных, типов данных языка С++. Она начинается с определения литералов, таких, как 3.14159 или pi, а затем вводится понятие переменной, или объекта, который должен принадлежать к одному из типов данных. Оставшаяся часть главы посвящена подробному описанию каждого встроенного типа. Кроме того, приводятся производные типы данных для строк и массивов, предоставляемые стандартной библиотекой С++. Хотя эти типы не являются элементарными, они очень важны для написания настоящих программ на С++, и нам хочется познакомить с ними читателя как можно раньше. Мы будем называть такие типы данных расширением базовых типов С++. Литералы В С++ имеется набор встроенных типов данных для представления целых и вещественных чисел, символов, а также тип данных “символьный массив”, который служит для хранения символьных строк. Тип char служит для хранения отдельных символов и небольших целых чисел. Он занимает один машинный байт. Типы short, int и long предназначены для представления целых чисел. Эти типы различаются только диапазоном значений, которые могут принимать числа, а конкретные размеры перечисленных типов зависят от реализации. Обычно short занимает половину машинного слова, int – одно слово, long – одно или два слова. В 32-битных системах int и long, как правило, одного размера. Типы float, double и long double предназначены для чисел с плавающей точкой и различаются точностью представления (количеством значащих разрядов) и диапазоном. Обычно float (одинарная точность) занимает одно машинное слово, double (двойная точность) – два, а long double (расширенная точность) – три. char, short, int и long вместе составляют целые типы, которые, в свою очередь, могут быть знаковыми (signed) и беззнаковыми (unsigned). В знаковых типах самый левый бит служит для хранения знака (0 – плюс, 1 – минус), а оставшиеся биты содержат значение. В беззнаковых типах все биты используются для значения. 8-битовый тип signed char может представлять значения от -128 до 127, а unsigned char – от 0 до 255. Когда в программе встречается некоторое число, например 1, то это число называется литералом, или литеральной константой. Константой, потому что мы не можем изменить его значение, и литералом, потому что его значение фигурирует в тексте программы. Литерал является неадресуемой величиной: хотя реально он, конечно, хранится в памяти машины, нет никакого способа узнать его адрес. Каждый литерал имеет определенный тип. Так, 0 имеет тип int, 3.14159 – тип double. Литералы целых типов можно записать в десятичном, восьмеричном и шестнадцатеричном виде. Вот как выглядит число 20, представленное десятичным, восьмеричным и шестнадцатеричным литералами: 20 // десятичный 024 // восьмеричный 0х14 // шестнадцатеричный Если литерал начинается с 0, он трактуется как восьмеричный, если с 0х или 0Х, то как шестнадцатеричный. Привычная запись рассматривается как десятичное число. По умолчанию все целые литералы имеют тип signed int. Можно явно определить целый литерал как имеющий тип long, приписав в конце числа букву L (используется как прописная L, так и строчная l, однако для удобства чтения не следует употреблять строчную: ее легко перепутать с 1). Буква U (или u) в конце определяет литерал как unsigned int, а две буквы – UL или LU – как тип unsigned long. Например:
128u 1024UL 1L 8Lu
Литералы, представляющие действительные числа, могут быть записаны как с десятичной точкой, так и в научной (экспоненциальной) нотации. По умолчанию они имеют тип double. Для явного указания типа float нужно использовать суффикс F или f, а для long double - L или l, но только в случае записи с десятичной точкой. Например:
3.14159F 0/1f 12.345L 0.0 3el 1.0E-3E 2. 1.0L
Слова true и false являются литералами типа bool. Представимые литеральные символьные константы записываются как символы в одинарных кавычках. Например:
'a' '2' ', ' ' ' (пробел)
Специальные символы (табуляция, возврат каретки) записываются как escape-последовательности. Определены следующие такие последовательности (они начинаются с символа обратной косой черты):
новая строка \n горизонтальная табуляция \t забой \b вертикальная табуляция \v возврат каретки \r прогон листа \f звонок \a обратная косая черта \\ вопрос \? одиночная кавычка \' двойная кавычка \"
escape-последовательность общего вида имеет форму \ooo, где ooo – от одной до трех восьмеричных цифр. Это число является кодом символа. Используя ASCII-код, мы можем написать следующие литералы:
\7 (звонок) \14 (новая строка) \0 (null) \062 ('2')
Символьный литерал может иметь префикс L (например, L'a'), что означает специальный тип wchar_t – двухбайтовый символьный тип, который применяется для хранения символов национальных алфавитов, если они не могут быть представлены обычным типом char, как, например, китайские или японские буквы. Строковый литерал – строка символов, заключенная в двойные кавычки. Такой литерал может занимать и несколько строк, в этом случае в конце строки ставится обратная косая черта. Специальные символы могут быть представлены своими escape-последовательностями. Вот примеры строковых литералов:
" " (пустая строка) " a" " \nCC\toptions\tfile.[cC]\n" " a multi-line \ string literal signals its \ continuation with a backslash"
Фактически строковый литерал представляет собой массив символьных констант, где по соглашению языков С и С++ последним элементом всегда является специальный символ с кодом 0 (\0). Литерал 'A' задает единственный символ А, а строковый литерал " А" – массив из двух элементов: 'А' и \0 (пустого символа). Раз существует тип wchar_t, существуют и литералы этого типа, обозначаемые, как и в случае с отдельными символами, префиксом L: L" a wide string literal" Строковый литерал типа wchar_t – это массив символов того же типа, завершенный нулем. Если в тесте программы идут подряд два или несколько строковых литералов (типа char или wchar_t), компилятор соединяет их в одну строку. Например, следующий текст " two" " some" породит массив из восьми символов – twosome и завершающий нулевой символ. Результат конкатенации строк разного типа не определен. Если написать: // this is not a good idea " two" L" some" то на каком-то компьютере результатом будет некоторая осмысленная строка, а на другом может оказаться нечто совсем иное. Программы, использующие особенности реализации того или иного компилятора или операционной системы, являются непереносимыми. Мы крайне не рекомендуем пользоваться такими конструкциями. Упражнение 3.1 Объясните разницу в определениях следующих литералов: (a) 'a', L'a', " a", L" a" (b) 10, 10u, 10L, 10uL, 012, 0*C (c) 3.14, 3.14f, 3.14L Упражнение 3.2 Какие ошибки допущены в приведенных ниже примерах? (a) " Who goes with F\144rgus? \014" (b) 3.14e1L (c) " two" L" some" (d) 1024f (e) 3.14UL (f) " multiple line comment" Переменные Представим себе, что мы решаем задачу возведения 2 в степень 10. Пишем: #include < iostream>
int main() { // a first solution cout < < " 2 raised to the power of 10: "; cout < < 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2; cout < < endl; return 0; } Задача решена, хотя нам и пришлось неоднократно проверять, действительно ли 10 раз повторяется литерал 2. Мы не ошиблись в написании этой длинной последовательности двоек, и программа выдала правильный результат – 1024. Но теперь нас попросили возвести 2 в 17 степень, а потом в 23. Чрезвычайно неудобно каждый раз модифицировать текст программы! И, что еще хуже, очень просто ошибиться, написав лишнюю двойку или пропустив ее... А что делать, если нужно напечатать таблицу степеней двойки от 0 до 15? 16 раз повторить две строки, имеющие общий вид: cout < < " 2 в степени X\t"; cout < < 2 *... * 2; где Х последовательно увеличивается на 1, а вместо отточия подставляется нужное число литералов? Да, мы справились с задачей. Заказчик вряд ли будет вникать в детали, удовлетворившись полученным результатом. В реальной жизни такой подход достаточно часто срабатывает, более того, бывает оправдан: задача решена далеко не самым изящным способом, зато в желаемый срок. Искать более красивый и грамотный вариант может оказаться непрактичной тратой времени. В данном случае “метод грубой силы” дает правильный ответ, но как же неприятно и скучно решать задачу подобным образом! Мы точно знаем, какие шаги нужно сделать, но сами эти шаги просты и однообразны. Привлечение более сложных механизмов для той же задачи, как правило, значительно увеличивает время подготовительного этапа. Кроме того, чем более сложные механизмы применяются, тем больше вероятность ошибок. Но даже несмотря на неизбежные ошибки и неверные ходы, применение “высоких технологий” может принести выигрыш в скорости разработки, не говоря уже о том, что эти технологии значительно расширяют наши возможности. И – что интересно! – сам процесс решения может стать привлекательным. Вернемся к нашему примеру и попробуем “технологически усовершенствовать” его реализацию. Мы можем воспользоваться именованным объектом для хранения значения степени, в которую нужно возвести наше число. Кроме того, вместо повторяющейся последовательности литералов применим оператор цикла. Вот как это будет выглядеть: #include < iostream>
int main() { // objects of type int int value = 2; int pow = 10;
cout < < value < < " в степени " < < pow < < ": \t";
int res = 1;
// оператор цикла: // повторить вычисление res // до тех пор пока cnt не станет больше pow for ( int cnt=1; cnt < = pow; ++cnt ) res = res * value;
cout < < res < < endl; } value, pow, res и cnt – это переменные, которые позволяют хранить, модифицировать и извлекать значения. Оператор цикла for повторяет строку вычисления результата pow раз. Несомненно, мы создали гораздо более гибкую программу. Однако это все еще не функция. Чтобы получить настоящую функцию, которую можно использовать в любой программе для вычисления степени числа, нужно выделить общую часть вычислений, а конкретные значения задать параметрами. int pow( int val, int exp ) { for ( int res = 1; exp > 0; --exp ) res = res * val; return res; } Теперь получить любую степень нужного числа не составит никакого труда. Вот как реализуется последняя наша задача – напечатать таблицу степеней двойки от 0 до 15: #include < iostream> extern int pow(int, int); int main() { int val = 2; int exp = 15;
cout < < " Степени 2\n"; for ( int cnt=0; cnt < = exp; ++cnt ) cout < < cnt < < ": " < < pow( val, cnt ) < < endl;
return 0; } Конечно, наша функция pow() все еще недостаточно обобщена и недостаточно надежна. Она не может оперировать вещественными числами, неправильно возводит числа в отрицательную степень – всегда возвращает 1. Результат возведения большого числа в большую степень может не поместиться в переменную типа int, и тогда будет возвращено некоторое случайное неправильное значение. Видите, как непросто, оказывается, писать функции, рассчитанные на широкое применение? Гораздо сложнее, чем реализовать конкретный алгоритм, направленный на решение конкретной задачи. Что такое переменная Переменная, или объект – это именованная область памяти, к которой мы имеем доступ из программы; туда можно помещать значения и затем извлекать их. Каждая переменная С++ имеет определенный тип, который характеризует размер и расположение этой области памяти, диапазон значений, которые она может хранить, и набор операций, применимых к этой переменной. Вот пример определения пяти объектов разных типов: int student_count; double salary; bool on_loan; string street_address; char delimiter; Переменная, как и литерал, имеет определенный тип и хранит свое значение в некоторой области памяти. Адресуемость – вот чего не хватает литералу. С переменной ассоциируются две величины: · собственно значение, или r-значение (от read value – значение для чтения), которое хранится в этой области памяти и присуще как переменной, так и литералу; · значение адреса области памяти, ассоциированной с переменной, или l-значение (от location value – значение местоположения) – место, где хранится r-значение; присуще только объекту. В выражении ch = ch - '0'; переменная ch находится и слева и справа от символа операции присваивания. Справа расположено значение для чтения (ch и символьный литерал '0'): ассоциированные с переменной данные считываются из соответствующей области памяти. Слева – значение местоположения: в область памяти, соотнесенную с переменной ch, помещается результат вычитания. В общем случае левый операнд операции присваивания должен быть l-значением. Мы не можем написать следующие выражения: // ошибки компиляции: значения слева не являются l-значениями
// ошибка: литерал - не l-значение 0 = 1;
// ошибка: арифметическое выражение - не l-значение salary + salary * 0.10 = new_salary; Оператор определения переменной выделяет для нее память. Поскольку объект имеет только одну ассоциированную с ним область памяти, такой оператор может встретиться в программе только один раз. Если же переменная, определенная в одном исходном файле, должна быть использована в другом, появляются проблемы. Например: // файл module0.C // определяет объект fileName string fileName; //... присвоить fileName значение
// файл module1.C // использует объект fileName
// увы, не компилируется: // fileName не определен в module1.C ifstream input_file( fileName ); С++ требует, чтобы объект был известен до первого обращения к нему. Это вызвано необходимостью гарантировать правильность использования объекта в соответствии с его типом. В нашем примере модуль module1.C вызовет ошибку компиляции, поскольку переменная fileName не определена в нем. Чтобы избежать этой ошибки, мы должны сообщить компилятору об уже определенной переменной fileName. Это делается с помощью инструкции объявления переменной:
// файл module1.C // использует объект fileName
// fileName объявляется, то есть программа получает // информацию об этом объекте без вторичного его определения extern string fileName;
ifstream input_file( fileName ) Объявление переменной сообщает компилятору, что объект с данным именем, имеющий данный тип, определен где-то в программе. Память под переменную при ее объявлении не отводится. (Ключевое слово extern рассматривается в разделе 8.2.) Программа может содержать сколько угодно объявлений одной и той же переменной, но определить ее можно только один раз. Такие объявления удобно помещать в заголовочные файлы, включая их в те модули, которые этого требуют. Так мы можем хранить информацию об объектах в одном месте и обеспечить удобство ее модификации в случае надобности. (Более подробно о заголовочных файлах мы поговорим в разделе 8.2.) Имя переменной Имя переменной, или идентификатор, может состоять из латинских букв, цифр и символа подчеркивания. Прописные и строчные буквы в именах различаются. Язык С++ не ограничивает длину идентификатора, однако пользоваться слишком длинными именами типа gosh_this_is_an_impossibly_name_to_type неудобно. Некоторые слова являются ключевыми в С++ и не могут быть использованы в качестве идентификаторов; в таблице 3.1 приведен их полный список.
Таблица 3.1. Ключевые слова C++
Чтобы текст вашей программы был более понятным, мы рекомендуем придерживаться общепринятых соглашений об именах объектов: · имя переменной обычно пишется строчными буквами, например index (для сравнения: Index – это имя типа, а INDEX – константа, определенная с помощью директивы препроцессора #define); · идентификатор должен нести какой-либо смысл, поясняя назначение объекта в программе, например: birth_date или salary; если такое имя состоит из нескольких слов, как, например, birth_date, то принято либо разделять слова символом подчеркивания (birth_date), либо писать каждое следующее слово с большой буквы (birthDate). Замечено, что программисты, привыкшие к ОбъектноОриентированномуПодходу предпочитают выделять слова заглавными буквами, в то время как те_кто_много_писал_на_С используют символ подчеркивания. Какой из двух способов лучше – вопрос вкуса. Определение объекта В самом простом случае оператор определения объекта состоит из спецификатора типа и имени объекта и заканчивается точкой с запятой. Например: double salary; double wage; int month; int day; int year; unsigned long distance; В одном операторе можно определить несколько объектов одного типа. В этом случае их имена перечисляются через запятую: double salary, wage; int month, day, year; unsigned long distance; Простое определение переменной не задает ее начального значения. Если объект определен как глобальный, спецификация С++ гарантирует, что он будет инициализирован нулевым значением. Если же переменная локальная либо динамически размещаемая (с помощью оператора new), ее начальное значение не определено, то есть она может содержать некоторое случайное значение. Использование подобных переменных – очень распространенная ошибка, которую к тому же трудно обнаружить. Рекомендуется явно указывать начальное значение объекта, по крайней мере в тех случаях, когда неизвестно, может ли объект инициализировать сам себя. Механизм классов вводит понятие конструктора по умолчанию, который служит для присвоения значений по умолчанию. (Мы уже сказали об этом в разделе 2.3. Разговор о конструкторах по умолчанию будет продолжен немного позже, в разделах 3.11 и 3.15, где мы будем разбирать классы string и complex из стандартной библиотеки.) int main() { // неинициализированный локальный объект int ival;
// объект типа string инициализирован // конструктором по умолчанию string project;
//... } Начальное значение может быть задано прямо в операторе определения переменной. В С++ допустимы две формы инициализации переменной – явная, с использованием оператора присваивания: int ival = 1024; string project = " Fantasia 2000"; и неявная, с заданием начального значения в скобках: int ival( 1024 ); string project( " Fantasia 2000" ); Оба варианта эквивалентны и задают начальные значения для целой переменной ival как 1024 и для строки project как " Fantasia 2000". Явную инициализацию можно применять и при определении переменных списком: double salary = 9999.99, wage = salary + 0.01; int month = 08; day = 07, year = 1955; Переменная становится видимой (и допустимой в программе) сразу после ее определения, поэтому мы могли проинициализировать переменную wage суммой только что определенной переменной salary с некоторой константой. Таким образом, определение: // корректно, но бессмысленно int bizarre = bizarre; является синтаксически допустимым, хотя и бессмысленным. Встроенные типы данных имеют специальный синтаксис для задания нулевого значения: // ival получает значение 0, а dval - 0.0 int ival = int(); double dval = double(); В следующем определении: // int() применяется к каждому из 10 элементов vector< int > ivec( 10 ); к каждому из десяти элементов вектора применяется инициализация с помощью int(). (Мы уже говорили о классе vector в разделе 2.8. Более подробно об этом см. в разделе 3.10 и главе 6.) Переменная может быть инициализирована выражением любой сложности, включая вызовы функций. Например: #include < cmath> #include < string>
double price = 109.99, discount = 0.16; double sale_price( price * discount ); string pet( " wrinkles" );
extern int get_value(); int val = get_value();
unsigned abs_val = abs( val ); abs() – стандартная функция, возвращающая абсолютное значение параметра. get_value() – некоторая пользовательская функция, возвращающая целое значение. Упражнение 3.3 Какие из приведенных ниже определений переменных содержат синтаксические ошибки? (a) int car = 1024, auto = 2048; (b) int ival = ival; (c) int ival( int() ); (d) double salary = wage = 9999.99; (e) cin > > int input_value;
Упражнение 3.4 Объясните разницу между l-значением и r-значением. Приведите примеры. Упражнение 3.5 Найдите отличия в использовании переменных name и student в первой и второй строчках каждого примера: (a) extern string name; string name( " exercise 3.5a" );
(b) extern vector< string> students; vector< string> students; Упражнение 3.6 Какие имена объектов недопустимы в С++? Измените их так, чтобы они стали синтаксически правильными: (a) int double = 3.14159; (b) vector< int > _; (c) string namespase; (d) string catch-22; (e) char 1_or_2 = '1'; (f) float Float = 3.14f; Упражнение 3.7 В чем разница между следующими глобальными и локальными определениями переменных? string global_class; int global_int;
int main() { int local_int; string local_class;
//... } Указатели Указатели и динамическое выделение памяти были вкратце представлены в разделе 2.2. Указатель – это объект, содержащий адрес другого объекта и позволяющий косвенно манипулировать этим объектом. Обычно указатели используются для работы с динамически созданными объектами, для построения связанных структур данных, таких, как связанные списки и иерархические деревья, и для передачи в функции больших объектов – массивов и объектов классов – в качестве параметров. Каждый указатель ассоциируется с некоторым типом данных, причем их внутреннее представление не зависит от внутреннего типа: и размер памяти, занимаемый объектом типа указатель, и диапазон значений у них одинаков[5]. Разница состоит в том, как компилятор воспринимает адресуемый объект. Указатели на разные типы могут иметь одно и то же значение, но область памяти, где размещаются соответствующие типы, может быть различной: · указатель на int, содержащий значение адреса 1000, направлен на область памяти 1000-1003 (в 32-битной системе); · указатель на double, содержащий значение адреса 1000, направлен на область памяти 1000-1007 (в 32-битной системе). Вот несколько примеров: int *ip1, *ip2; complex< double> *cp; string *pstring; vector< int> *pvec; double *dp; Указатель обозначается звездочкой перед именем. В определении переменных списком звездочка должна стоять перед каждым указателем (см. выше: ip1 и ip2). В примере ниже lp – указатель на объект типа long, а lp2 – объект типа long: long *lp, lp2; В следующем случае fp интерпретируется как объект типа float, а fp2 – указатель на него: float fp, *fp2; Оператор разыменования (*) может отделяться пробелами от имени и даже непосредственно примыкать к ключевому слову типа. Поэтому приведенные определения синтаксически правильны и совершенно эквивалентны: string *ps; string* ps; Однако рекомендуется использовать первый вариант написания: второй способен ввести в заблуждение, если добавить к нему определение еще одной переменной через запятую:
//внимание: ps2 не указатель на строку! string* ps, ps2; Можно предположить, что и ps, и ps2 являются указателями, хотя указатель – только первый из них. Если значение указателя равно 0, значит, он не содержит никакого адреса объекта. Пусть задана переменная типа int: int ival = 1024; Ниже приводятся примеры определения и использования указателей на int pi и pi2: //pi инициализирован нулевым адресом int *pi = 0;
// pi2 инициализирован адресом ival int *pi2 = & ival;
// правильно: pi и pi2 содержат адрес ival pi = pi2;
// pi2 содержит нулевой адрес pi2 = 0; Указателю не может быть присвоена величина, не являющаяся адресом: // ошибка: pi не может принимать значение int pi = ival Точно так же нельзя присвоить указателю одного типа значение, являющееся адресом объекта другого типа. Если определены следующие переменные: double dval; double *ps = & dval; то оба выражения присваивания, приведенные ниже, вызовут ошибку компиляции: // ошибки компиляции // недопустимое присваивание типов данных: int* < == double* pi = pd pi = & dval; Дело не в том, что переменная pi не может содержать адреса объекта dval – адреса объектов разных типов имеют одну и ту же длину. Такие операции смешения адресов запрещены сознательно, потому что интерпретация объектов компилятором зависит от типа указателя на них. Конечно, бывают случаи, когда нас интересует само значение адреса, а не объект, на который он указывает (допустим, мы хотим сравнить этот адрес с каким-то другим). Для разрешения таких ситуаций введен специальный указатель void, который может указывать на любой тип данных, и следующие выражения будут правильны: // правильно: void* может содержать // адреса любого типа void *pv = pi; pv = pd; Тип объекта, на который указывает void*, неизвестен, и мы не можем манипулировать этим объектом. Все, что мы можем сделать с таким указателем, – присвоить его значение другому указателю или сравнить с какой-либо адресной величиной. (Более подробно мы расскажем об указателе типа void в разделе 4.14.) Для того чтобы обратиться к объекту, имея его адрес, нужно применить операцию разыменования, или косвенную адресацию, обозначаемую звездочкой (*). Имея следующие определения переменных: int ival = 1024;, ival2 = 2048; int *pi = & ival; мы можем читать и сохранять значение ival, применяя операцию разыменования к указателю pi: // косвенное присваивание переменной ival значения ival2 *pi = ival2;
// косвенное использование переменной ival как rvalue и lvalue *pi = abs(*pi); // ival = abs(ival); *pi = *pi + 1; // ival = ival + 1; Когда мы применяем операцию взятия адреса (& ) к объекту типа int, то получаем результат типа int* int *pi = & ival; Если ту же операцию применить к объекту типа int* (указатель на int), мы получим указатель на указатель на int, т.е. int**. int** – это адрес объекта, который содержит адрес объекта типа int. Разыменовывая ppi, мы получаем объект типа int*, содержащий адрес ival. Чтобы получить сам объект ival, операцию разыменования к ppi необходимо применить дважды. int **ppi = & pi; int *pi2 = *ppi;
cout < < " Значение ival\n" < < " явное значение: " < < ival < < " \n" < < " косвенная адресация: " < < *pi < < " \n" < < " дважды косвенная адресация: " < < **ppi < < " \n" < < endl; Указатели могут быть использованы в арифметических выражениях. Обратите внимание на следующий пример, где два выражения производят совершенно различные действия: int i, j, k; int *pi = & i;
// i = i + 2 *pi = *pi + 2;
// увеличение адреса, содержащегося в pi, на 2 pi = pi + 2; К указателю можно прибавлять целое значение, можно также вычитать из него. Прибавление к указателю 1 увеличивает содержащееся в нем значение на размер области памяти, отводимой объекту соответствующего типа. Если тип char занимает 1 байт, int – 4 и double – 8, то прибавление 2 к указателям на char, int и double увеличит их значение соответственно на 2, 8 и 16. Как это можно интерпретировать? Если объекты одного типа расположены в памяти друг за другом, то увеличение указателя на 1 приведет к тому, что он будет указывать на следующий объект. Поэтому арифметические действия с указателями чаще всего применяются при обработке массивов; в любых других случаях они вряд ли оправданы. Вот как выглядит типичный пример использования адресной арифметики при переборе элементов массива с помощью итератора: int ia[10]; int *iter = & ia[0]; int *iter_end = & ia[10];
while (iter! = iter_end) { do_something_with_value (*iter); ++iter; } Упражнение 3.8 Даны определения переменных:
int ival = 1024, ival2 = 2048; int *pi1 = & ival, *pi2 = & ival2, **pi3 = 0; Что происходит при выполнении нижеследующих операций присваивания? Допущены ли в данных примерах ошибки?
(a) ival = *pi3; (e) pi1 = *pi3; (b) *pi2 = *pi3; (f) ival = *pi1; (c) ival = pi2; (g) pi1 = ival; (d) pi2 = *pi1; (h) pi3 = & pi2; Упражнение 3.9 Работа с указателями – один из важнейших аспектов С и С++, однако в ней легко допустить ошибку. Например, код pi = & ival; pi = pi + 1024; почти наверняка приведет к тому, что pi будет указывать на случайную область памяти. Что делает этот оператор присваивания и в каком случае он не приведет к ошибке? Упражнение 3.10 Данная программа содержит ошибку, связанную с неправильным использованием указателей: int foobar(int *pi) { *pi = 1024; return *pi; }
int main() { int *pi2 = 0; int ival = foobar(pi2); return 0; } В чем состоит ошибка? Как можно ее исправить? Упражнение 3.11 Ошибки из предыдущих двух упражнений проявляются и приводят к фатальным последствиям из-за отсутствия в С++ проверки правильности значений указателей во время работы программы. Как вы думаете, почему такая проверка не была реализована? Можете ли вы предложить некоторые общие рекомендации для того, чтобы работа с указателями была более безопасной? Строковые типы В С++ поддерживаются два типа строк – встроенный тип, доставшийся от С, и класс string из стандартной библиотеки С++. Класс string предоставляет гораздо больше возможностей и поэтому удобней в применении, однако на практике нередки ситуации, когда необходимо пользоваться встроенным типом либо хорошо понимать, как он устроен. (Одним из примеров может являться разбор параметров командной строки, передаваемых в функцию main(). Мы рассмотрим это в главе 7.) Встроенный строковый тип Как уже было сказано, встроенный строковый тип перешел к С++ по наследству от С. Строка символов хранится в памяти как массив, и доступ к ней осуществляется при помощи указателя типа char*. Стандартная библиотека С предоставляет набор функций для манипулирования строками. Например: // возвращает длину строки int strlen( const char* );
// сравнивает две строки int strcmp( const char*, const char* );
// копирует одну строку в другую char* strcpy( char*, const char* ); Стандартная библиотека С является частью библиотеки С++. Для ее использования мы должны включить заголовочный файл: #include < cstring> Указатель на char, с помощью которого мы обращаемся к строке, указывает на соответствующий строке массив символов. Даже когда мы пишем строковый литерал, например const char *st = " Цена бутылки вина\n"; компилятор помещает все символы строки в массив и затем присваивает st адрес первого элемента массива. Как можно работать со строкой, используя такой указатель? Обычно для перебора символов строки применяется адресная арифметика. Поскольку строка всегда заканчивается нулевым символом, можно увеличивать указатель на 1, пока очередным символом не станет нуль. Например: while (*st++ ) {... } st разыменовывается, и получившееся значение проверяется на истинность. Любое отличное от нуля значение считается истинным, и, следовательно, цикл заканчивается, когда будет достигнут символ с кодом 0. Операция инкремента ++ прибавляет 1 к указателю st и таким образом сдвигает его к следующему символу. Вот как может выглядеть реализация функции, возвращающей длину строки. Отметим, что, поскольку указатель может содержать нулевое значение (ни на что не указывать), перед операцией разыменования его следует проверять:
int string_length( const char *st ) { int cnt = 0; if ( st ) while ( *st++ ) ++cnt; return cnt; } Строка встроенного типа может считаться пустой в двух случаях: если указатель на строку имеет нулевое значение (тогда у нас вообще нет никакой строки) или указывает на массив, состоящий из одного нулевого символа (то есть на строку, не содержащую ни одного значимого символа). // pc1 не адресует никакого массива символов char *pc1 = 0;
// pc2 адресует нулевой символ const char *pc2 = " "; Для начинающего программиста использование строк встроенного типа чревато ошибками из-за слишком низкого уровня реализации и невозможности обойтись без адресной арифметики. Ниже мы покажем некоторые типичные погрешности, допускаемые новичками. Задача проста: вычислить длину строки. Первая версия неверна. Исправьте ее. #include < iostream> const char *st = " Цена бутылки вина\n";
int main() { int len = 0; while ( st++ ) ++len;
cout < < len < < ": " < < st; return 0; } В этой версии указатель st не разыменовывается. Следовательно, на равенство 0 проверяется не символ, на который указывает st, а сам указатель. Поскольку изначально этот указатель имел ненулевое значение (адрес строки), то он никогда не станет равным нулю, и цикл будет выполняться бесконечно. Во второй версии программы эта погрешность устранена. Программа успешно заканчивается, однако полученный результат неправилен. Где мы не правы на этот раз? #include < iostream> const char *st = " Цена бутылки вина\n";
int main() { int len = 0; while ( *st++ ) ++len;
cout < < len < < ": " < < st < < endl; return 0; } Ошибка состоит в том, что после завершения цикла указатель st адресует не исходный символьный литерал, а символ, расположенный в памяти после завершающего нуля этого литерала. В этом месте может находиться что угодно, и выводом программы будет случайная последовательность символов. Можно попробовать исправить эту ошибку: st = st – len; cout < < len < < ": " < < st; Теперь наша программа выдает что-то осмысленное, но не до конца. Ответ выглядит так:
18: ена бутылки вина
Мы забыли учесть, что заключительный нулевой символ не был включен в подсчитанную длину. st должен быть смещен на длину строки плюс 1. Вот, наконец, правильный оператор: st = st – len - 1; а вот и и правильный результат:
18: Цена бутылки вина
Однако нельзя сказать, что наша программа выглядит элегантно. Оператор st = st – len - 1; добавлен для того, чтобы исправить ошибку, допущенную на раннем этапе проектирования программы, – непосредственное увеличение указателя st. Этот оператор не вписывается в логику программы, и код теперь трудно понять. Исправления такого рода часто называют заплатками – нечто, призванное заткнуть дыру в существующей программе. Гораздо лучшим решением было бы пересмотреть логику. Одним из вариантов в нашем случае может быть определение второго указателя, инициализированного значением st: const char *p = st; Теперь p можно использовать в цикле вычисления длины, оставив значение st неизменным: while ( *p++ ) Класс string Как мы только что видели, применение встроенного строкового типа чревато ошибками и не очень удобно из-за того, что он реализован на слишком низком уровне. Поэтому достаточно распространена разработка собственного класса или классов для представления строкового типа – чуть ли не каждая компания, отдел или индивидуальный проект имели свою собственную реализацию строки. Да что говорить, в предыдущих двух изданиях этой книги мы делали то же самое! Это порождало проблемы совместимости и переносимости программ. Реализация стандартного класса string стандартной библиотекой С++ призвана была положить конец этому изобретению велосипедов. Попробуем специфицировать минимальный набор операций, которыми должен обладать класс string: · инициализация массивом символов (строкой встроенного типа) или другим объектом типа string. Встроенный тип не обладает второй возможностью; · копирование одной строки в другую. Для встроенного типа приходится использовать функцию strcpy(); · доступ к отдельным символам строки для чтения и записи. Во встроенном массиве для этого применяется операция взятия индекса или косвенная адресация; · сравнение двух строк на равенство. Для встроенного типа используется функция strcmp(); · конкатенация двух строк, получая результат либо как третью строку, либо вместо одной из исходных. Для встроенного типа применяется функция strcat(), однако чтобы получить результат в новой строке, необходимо последовательно задействовать функции strcpy() и strcat(); · вычисление длины строки. Узнать длину строки встроенного типа можно с помощью функции strlen(); · возможность узнать, пуста ли строка. У встроенных строк для этой цели приходится проверять два условия:
Класс string стандартной библиотеки С++ реализует все перечисленные операции (и гораздо больше, как мы увидим в главе 6). В данном разделе мы научимся пользоваться основными операциями этого класса. Для того чтобы использовать объекты класса string, необходимо включить соответствующий заголовочный файл: #include < string> Вот пример строки из предыдущего раздела, представленной объектом типа string и инициализированной строкой символов: #include < string> string st( " Цена бутылки вина\n" );
Длину строки возвращает функция-член size() (длина не включает завершающий нулевой символ). Вторая форма определения строки задает пустую строку: string st2; // пустая строка Как мы узнаем, пуста ли строка? Конечно, можно сравнить ее длину с 0: if (! st.size() ) // правильно: пустая Однако есть и специальный метод empty(), возвращающий true для пустой строки и false для непустой: if ( st.empty() ) // правильно: пустая Третья форма конструктора инициализирует объект типа string другим объектом того же типа: string st3( st ); Строка st3 инициализируется строкой st. Как мы можем убедиться, что эти строки совпадают? Воспользуемся оператором сравнения (==): if ( st == st3 ) // инициализация сработала Как скопировать одну строку в другую? С помощью обычной операции присваивания: st2 = st3; // копируем st3 в st2 Для конкатенации строк используется операция сложения (+) или операция сложения с присваиванием (+=). Пусть даны две строки: string s1( " hello, " ); string s2( " world\n" ); Мы можем получить третью строку, состоящую из конкатенации первых двух, таким образом: string s3 = s1 + s2; Если же мы хотим добавить s2 в конец s1, мы должны написать: s1 += s2; Операция сложения может конкатенировать объекты класса string не только между собой, но и со строками встроенного типа. Можно переписать пример, приведенный выше, так, чтобы специальные символы и знаки препинания представлялись встроенным типом, а значимые слова – объектами класса string: string s1( " hello" ); const char *pc = ", "; string s2( " world" );
string s3 = s1 + pc + s2 + " \n"; Подобные выражения работают потому, что компилятор знает, как автоматически преобразовывать объекты встроенного типа в объекты класса string. Возможно и простое присваивание встроенной строки объекту string: string s1; const char *pc = " a character array";
s1 = pc; // правильно Обратное преобразование, однако, не работает. Попытка выполнить следующую инициализацию строки встроенного типа вызовет ошибку компиляции: char *str = s1; // ошибка компиляции Чтобы осуществить такое преобразование, необходимо явно вызвать функцию-член с несколько странным названием c_str(): char *str = s1.c_str(); // почти правильно Функция c_str() возвращает указатель на символьный массив, содержащий строку объекта string в том виде, в каком она находилась бы во встроенном строковом типе. Приведенный выше пример инициализации указателя char *str все еще не совсем корректен. c_str() возвращает указатель на константный массив, чтобы предотвратить возможность непосредственной модификации содержимого объекта через этот указатель, имеющий тип const char * (В следующем разделе мы расскажем о ключевом слове const). Правильный вариант инициализации выглядит так: const char *str = s1.c_str(); // правильно К отдельным символам объекта типа string, как и встроенного типа, можно обращаться с помощью операции взятия индекса. Вот, например, фрагмент кода, заменяющего все точки символами подчеркивания: string str( " fa.disney.com" );
int size = str.size(); for ( int ix = 0; ix < size; ++ix ) if ( str[ ix ] == '.' ) str[ ix ] = '_'; Вот и все, что мы хотели сказать о классе string прямо сейчас. На самом деле, этот класс обладает еще многими интересными свойствами и возможностями. Скажем, предыдущий пример реализуется также вызовом одной-единственной функции replace(): replace( str.begin(), str.end(), '.', '_' ); replace() – один из обобщенных алгоритмов, с которыми мы познакомились в разделе 2.8 и которые будут детально разобраны в главе 12. Эта функция пробегает диапазон от begin() до end(), которые возвращают указатели на начало и конец строки, и заменяет элементы, равные третьему своему параметру, на четвертый. Упражнение 3.12 Найдите ошибки в приведенных ниже операторах: (a) char ch = " The long and winding road"; (b) int ival = & ch; (c) char *pc = & ival; (d) string st( & ch );
(e) pc = 0; (i) pc = '0'; (f) st = pc; (j) st = & ival; (g) ch = pc[0]; (k) ch = *pc; (h) pc = st; (l) *pc = ival; Упражнение 3.13 Объясните разницу в поведении следующих операторов цикла: while ( st++ ) ++cnt;
while ( *st++ ) ++cnt; Упражнение 3.14 Даны две семантически эквивалентные программы. Первая использует встроенный строковый тип, вторая – класс string: // ***** Реализация с использованием C-строк *****
#include < iostream> #include < cstring>
int main() { int errors = 0; const char *pc = " a very long literal string";
for ( int ix = 0; ix < 1000000; ++ix ) { int len = strlen( pc ); char *pc2 = new char[ len + 1 ]; strcpy( pc2, pc ); if ( strcmp( pc2, pc )) ++errors;
delete [] pc2; } cout < < " C-строки: " < < errors < < " ошибок.\n"; }
// ***** Реализация с использованием класса string *****
#include < iostream> #include < string>
int main() { int errors = 0; string str( " a very long literal string" );
for ( int ix = 0; ix < 1000000; ++ix ) { int len = str.size(); string str2 = str; if ( str! = str2 ) } cout < < " класс string: " < < errors < < " ошибок.\n; } Что эти программы делают? Оказывается, вторая реализация выполняется в два раза быстрее первой. Ожидали ли вы такого результата? Как вы его объясните? Упражнение 3.15 Могли бы вы что-нибудь улучшить или дополнить в наборе операций класса string, приведенных в последнем разделе? Поясните свои предложения. Спецификатор const Возьмем следующий пример кода: for ( int index = 0; index < 512; ++index ) ...; С использованием литерала 512 связаны две проблемы. Первая состоит в легкости восприятия текста программы. Почему верхняя граница переменной цикла должна быть равна именно 512? Что скрывается за этой величиной? Она кажется случайной... Вторая проблема касается простоты модификации и сопровождения кода. Предположим, программа состоит из 10 000 строк, и литерал 512 встречается в 4% из них. Допустим, в 80% случаев число 512 должно быть изменено на 1024. Способны ли вы представить трудоемкость такой работы и количество ошибок, которые можно сделать, исправив не то значение? Обе эти проблемы решаются одновременно: нужно создать объект со значением 512. Присвоив ему осмысленное имя, например bufSize, мы сделаем программу гораздо более понятной: ясно, с чем именно сравнивается переменная цикла. index < bufSize В этом случае изменение размера bufSize не требует просмотра 400 строк кода для модификации 320 из них. Насколько уменьшается вероятность ошибок ценой добавления всего одного объекта! Теперь значение 512 локализовано. int bufSize = 512; // размер буфера ввода //...
for ( int index = 0; index < bufSize; ++index ) //... Остается одна маленькая проблема: переменная bufSize здесь является l-значением, которое можно случайно изменить в программе, что приведет к трудно отлавливаемой ошибке. Вот одна из распространенных ошибок – использование операции присваивания (=) вместо сравнения (==): // случайное изменение значения bufSize if ( bufSize = 1 ) //... В результате выполнения этого кода значение bufSize станет равным 1, что может привести к совершенно непредсказуемому поведению программы. Ошибки такого рода обычно очень тяжело обнаружить, поскольку они попросту не видны. Использование спецификатора const решает данную проблему. Объявив объект как const int bufSize = 512; // размер буфера ввода мы превращаем переменную в константу со значением 512, значение которой не может быть изменено: такие попытки пресекаются компилятором: неверное использование оператора присваивания вместо сравнения, как в приведенном примере, вызовет ошибку компиляции. // ошибка: попытка присваивания значения константе if ( bufSize = 0 )... Раз константе нельзя присвоить значение, она должна быть инициализирована в месте своего определения. Определение константы без ее инициализации также вызывает ошибку компиляции: const double pi; // ошибка: неинициализированная константа Давайте рассуждать дальше. Явная трансформация значения константы пресекается компилятором. Но как быть с косвенной адресацией? Можно ли присвоить адрес константы некоторому указателю? const double minWage = 9.60;
// правильно? ошибка? double *ptr = & minWage; Должен ли компилятор разрешить подобное присваивание? Поскольку minWage – константа, ей нельзя присвоить значение. С другой стороны, ничто не запрещает нам написать: *ptr += 1.40; // изменение объекта minWage! Как правило, компилятор не в состоянии уберечь от использования указателей и не сможет сигнализировать об ошибке в случае подобного их употребления. Для этого требуется слишком глубокий анализ логики программы. Поэтому компилятор просто запрещает присваивание адресов констант обычным указателям. Что же, мы лишены возможности использовать указатели на константы? Нет. Для этого существуют указатели, объявленные со спецификатором const: const double *cptr; где cptr – указатель на объект типа const double. Тонкость заключается в том, что сам указатель – не константа, а значит, мы можем изменять его значение. Например: const double *pc = 0; const double minWage = 9.60;
// правильно: не можем изменять minWage с помощью pc pc = & minWage;
double dval = 3.14;
// правильно: не можем изменять minWage с помощью pc // хотя dval и не константа pc = & dval; // правильно
dval = 3.14159; //правильно *pc = 3.14159; // ошибка Адрес константного объекта присваивается только указателю на константу. Вместе с тем, такому указателю может быть присвоен и адрес обычной переменной: pc = & dval; Константный указатель не позволяет изменять адресуемый им объект с помощью косвенной адресации. Хотя dval в примере выше и не является константой, компилятор не допустит изменения переменной dval через pc. (Опять-таки потому, что он не в состоянии определить, адрес какого объекта может содержать указатель в произвольный момент выполнения программы.) В реальных программах указатели на константы чаще всего употребляются как формальные параметры функций. Их использование дает гарантию, что объект, переданный в функцию в качестве фактического аргумента, не будет изменен этой функцией. Например: // В реальных программах указатели на константы чаще всего // употребляются как формальные параметры функций int strcmp( const char *str1, const char *str2 ); (Мы еще поговорим об указателях на константы в главе 7, когда речь пойдет о функциях.) Существуют и константные указатели. (Обратите внимание на разницу между константным указателем и указателем на константу! ). Константный указатель может адресовать как константу, так и переменную. Например: int errNumb = 0; int *const currErr = & errNumb; do_something();
errorHandler(); *curErr = 0; // правильно: обнулим значение errNumb Здесь curErr – константный указатель на неконстантный объект. Это значит, что мы не можем присвоить ему адрес другого объекта, хотя сам объект допускает модификацию. Вот как мог бы быть использован указатель curErr: if ( *curErr ) { } Попытка присвоить значение константному указателю вызовет ошибку компиляции: curErr = & myErNumb; // ошибка Константный указатель на константу является объединением двух рассмотренных случаев.
const double pi = 3.14159; const double *const pi_ptr = & pi; Ни значение объекта, на который указывает pi_ptr, ни значение самого указателя не может быть изменено в программе. Упражнение 3.16 Объясните значение следующих пяти определений. Есть ли среди них ошибочные? (a) int i; (d) int *const cpi; (b) const int ic; (e) const int *const cpic; (c) const int *pic; Упражнение 3.17 Какие из приведенных определений правильны? Почему? (a) int i = -1; (b) const int ic = i; (c) const int *pic = & ic; (d) int *const cpi = & ic; (e) const int *const cpic = & ic; Упражнение 3.18 Используя определения из предыдущего упражнения, укажите правильные операторы присваивания. Объясните. (a) i = ic; (d) pic = cpic; (b) pic = & ic; (i) cpic = & ic; (c) cpi = pic; (f) ic = *cpic; Ссылочный тип Ссылочный тип, иногда называемый псевдонимом, служит для задания объекту дополнительного имени. Ссылка позволяет косвенно манипулировать объектом, точно так же, как это делается с помощью указателя. Однако эта косвенная манипуляция не требует специального синтаксиса, необходимого для указателей. Обычно ссылки употребляются как формальные параметры функций. В этом разделе мы рассмотрим самостоятельное использование объектов ссылочного типа. Ссылочный тип обозначается указанием оператора взятия адреса (& ) перед именем переменной. Ссылка должна быть инициализирована. Например: int ival = 1024;
// правильно: refVal - ссылка на ival int & refVal = ival;
// ошибка: ссылка должна быть инициализирована int & refVal2; Хотя, как мы говорили, ссылка очень похожа на указатель, она должна быть инициализирована не адресом объекта, а его значением. Таким объектом может быть и указатель: int ival = 1024;
// ошибка: refVal имеет тип int, а не int* int & refVal = & ival;
int *pi = & ival;
// правильно: ptrVal - ссылка на указатель int *& ptrVal2 = pi; Определив ссылку, вы уже не сможете изменить ее так, чтобы работать с другим объектом (именно поэтому ссылка должна быть инициализирована в месте своего определения). В следующем примере оператор присваивания не меняет значения refVal, новое значение присваивается переменной ival – ту, которую адресует refVal. int min_val = 0;
// ival получает значение min_val, // а не refVal меняет значение на min_val refVal = min_val; Все операции со ссылками реально воздействуют на адресуемые ими объекты. В том числе и операция взятия адреса. Например: refVal += 2; прибавляет 2 к ival – переменной, на которую ссылается refVal. Аналогично int ii = refVal; присваивает ii текущее значение ival, int *pi = & refVal; инициализирует pi адресом ival. Если мы определяем ссылки в одной инструкции через запятую, перед каждым объектом типа ссылки должен стоять амперсанд (& ) – оператор взятия адреса (точно так же, как и для указателей). Например:
Константная ссылка может быть инициализирована объектом другого типа (если, конечно, существует возможность преобразования одного типа в другой), а также безадресной величиной – такой, как литеральная константа. Например: double dval = 3.14159;
// верно только для константных ссылок const int & ir = 1024; const int & ir2 = dval; const double & dr = dval + 1.0; Если бы мы не указали спецификатор const, все три определения ссылок вызвали бы ошибку компиляции. Однако, причина, по которой компилятор не пропускает таких определений, неясна. Попробуем разобраться. Для литералов это более или менее понятно: у нас не должно быть возможности косвенно поменять значение литерала, используя указатели или ссылки. Что касается объектов другого типа, то компилятор преобразует исходный объект в некоторый вспомогательный. Например, если мы пишем: double dval = 1024; const int & ri = dval; то компилятор преобразует это примерно так: int temp = dval; const int & ri = temp; Если бы мы могли присвоить новое значение ссылке ri, мы бы реально изменили не dval, а temp. Значение dval осталось бы тем же, что совершенно неочевидно для программиста. Поэтому компилятор запрещает такие действия, и единственная возможность проинициализировать ссылку объектом другого типа – объявить ее как const. Вот еще один пример ссылки, который трудно понять с первого раза. Мы хотим определить ссылку на адрес константного объекта, но наш первый вариант вызывает ошибку компиляции: const int ival = 1024;
// ошибка: нужна константная ссылка int *& pi_ref = & ival; Попытка исправить дело добавлением спецификатора const тоже не проходит: const int ival = 1024;
// все равно ошибка const int *& pi_ref = & ival; В чем причина? Внимательно прочитав определение, мы увидим, что pi_ref является ссылкой на константный указатель на объект типа int. А нам нужен неконстантный указатель на константный объект, поэтому правильной будет следующая запись: const int ival = 1024;
// правильно int *const & piref = & ival; Между ссылкой и указателем существуют два основных отличия. Во-первых, ссылка обязательно должна быть инициализирована в месте своего определения. Во-вторых, всякое изменение ссылки преобразует не ее, а тот объект, на который она ссылается. Рассмотрим на примерах. Если мы пишем: int *pi = 0; мы инициализируем указатель pi нулевым значением, а это значит, что pi не указывает ни на какой объект. В то же время запись const int & ri = 0; означает примерно следующее: int temp = 0; const int & ri = temp; Что касается операции присваивания, то в следующем примере: int ival = 1024, ival2 = 2048; int *pi = & ival, *pi2 = & ival2;
pi = pi2; переменная ival, на которую указывает pi, остается неизменной, а pi получает значение адреса переменной ival2. И pi, и pi2 и теперь указывают на один и тот же объект ival2. Если же мы работаем со ссылками: int & ri = ival, & ri2 = ival2;
ri = ri2; то само значение ival меняется, но ссылка ri по-прежнему адресует ival. В реальных С++ программах ссылки редко используются как самостоятельные объекты, обычно они употребляются в качестве формальных параметров функций. Например: // пример использования ссылок
// Значение возвращается в параметре next_value bool get_next_value( int & next_value );
// перегруженный оператор Matrix operator+( const Matrix&, const Matrix& ); Как соотносятся самостоятельные объекты-ссылки и ссылки-параметры? Если мы пишем: int ival; while (get_next_value( ival ))... это равносильно следующему определению ссылки внутри функции: int & next_value = ival; (Подробнее использование ссылок в качестве формальных параметров функций рассматривается в главе 7.) Упражнение 3.19 Есть ли ошибки в данных определениях? Поясните. Как бы вы их исправили? (a) int ival = 1.01; (b) int & rval1 = 1.01; (c) int & rval2 = ival; (d) int & rval3 = & ival; (e) int *pi = & ival; (f) int & rval4 = pi; (g) int & rval5 = pi*; (h) int & *prval1 = pi; (i) const int & ival2 = 1; (j) const int & *prval2 = & ival; Упражнение 3.20 Если ли среди нижеследующих операций присваивания ошибочные (используются определения из предыдущего упражнения)? (a) rval1 = 3.14159; (b) prval1 = prval2; (c) prval2 = rval1; (d) *prval2 = ival2; Упражнение 3.21 Найдите ошибки в приведенных инструкциях: (a) int ival = 0; const int *pi = 0; const int & ri = 0;
(b) pi = & ival; ri = & ival; pi = & rval; Тип bool Объект типа bool может принимать одно из двух значений: true и false. Например: // инициализация строки string search_word = get_word();
// инициализация переменной found bool found = false;
string next_word; while ( cin > > next_word ) if ( next_word == search_word ) found = true; //...
// сокращенная запись: if ( found == true ) if ( found ) cout < < " ok, мы нашли слово\n"; else cout < < " нет, наше слово не встретилось.\n"; Хотя bool относится к одному из целых типов, он не может быть объявлен как signed, unsigned, short или long, поэтому приведенное определение ошибочно: // ошибка short bool found = false; Объекты типа bool неявно преобразуются в тип int. Значение true превращается в 1, а false – в 0. Например:
bool found = false; int occurrence_count = 0;
while ( /* mumble */ ) { found = look_for( /* something */ );
// значение found преобразуется в 0 или 1 occurrence_count += found; } Таким же образом значения целых типов и указателей могут быть преобразованы в значения типа bool. При этом 0 интерпретируется как false, а все остальное как true: // возвращает количество вхождений extern int find( const string& ); bool found = false; if ( found = find( " rosebud" )) // правильно: found == true
// возвращает указатель на элемент extern int* find( int value );
if ( found = find( 1024 )) // правильно: found == true Перечисления Нередко приходится определять переменную, которая принимает значения из некоего набора. Скажем, файл открывают в любом из трех режимов: для чтения, для записи, для добавления. Конечно, можно определить три константы для обозначения этих режимов: const int input = 1; const int output = 2; const int append = 3; и пользоваться этими константами: bool open_file( string file_name, int open_mode);
//... open_file( " Phoenix_and_the_Crane", append ); Подобное решение допустимо, но не вполне приемлемо, поскольку мы не можем гарантировать, что аргумент, передаваемый в функцию open_file() равен только 1, 2 или 3. Использование перечислимого типа решает данную проблему. Когда мы пишем: enum open_modes{ input = 1, output, append }; мы определяем новый тип open_modes. Допустимые значения для объекта этого типа ограничены набором 1, 2 и 3, причем каждое из указанных значений имеет мнемоническое имя. Мы можем использовать имя этого нового типа для определения как объекта данного типа, так и типа формальных параметров функции: void open_file( string file_name, open_modes om ); input, output и append являются элементами перечисления. Набор элементов перечисления задает допустимое множество значений для объекта данного типа. Переменная типа open_modes (в нашем примере) инициализируется одним из этих значений, ей также может быть присвоено любое из них. Например: open_file( " Phoenix and the Crane", append ); Попытка присвоить переменной данного типа значение, отличное от одного из элементов перечисления (или передать его параметром в функцию), вызовет ошибку компиляции. Даже если попробовать передать целое значение, соответствующее одному из элементов перечисления, мы все равно получим ошибку: // ошибка: 1 не является элементом перечисления open_modes open_file( " Jonah", 1 ); Есть способ определить переменную типа open_modes, присвоить ей значение одного из элементов перечисления и передать параметром в функцию: open_modes om = input; //... om = append; open_file( " TailTell", om ); Однако получить имена таких элементов невозможно. Если мы напишем оператор вывода: cout < < input < < " " < < om < < endl; то все равно получим:
1 3
Эта проблема решается, если определить строковый массив, в котором элемент с индексом, равным значению элемента перечисления, будет содержать его имя. Имея такой массив, мы сможем написать: cout < < open_modes_table[ input ] < < " " < < open_modes_table[ om ] < < endl Будет выведено:
input append
Кроме того, нельзя перебрать все значения перечисления: // не поддерживается for ( open_modes iter = input; iter! = append; ++inter ) //... Для определения перечисления служит ключевое слово enum, а имена элементов задаются в фигурных скобках, через запятую. По умолчанию первый из них равен 0, следующий – 1 и так далее. С помощью оператора присваивания это правило можно изменить. При этом каждый следующий элемент без явно указанного значения будет на 1 больше, чем элемент, идущий перед ним в списке. В нашем примере мы явно указали значение 1 для input, при этом output и append будут равны 2 и 3. Вот еще один пример: // shape == 0, sphere == 1, cylinder == 2, polygon == 3 enum Forms{ share, spere, cylinder, polygon }; Целые значения, соответствующие разным элементам одного перечисления, не обязаны отличаться. Например: // point2d == 2, point2w == 3, point3d == 3, point3w == 4 enum Points { point2d=2, point2w, point3d=3, point3w=4 }; Объект, тип которого – перечисление, можно определять, использовать в выражениях и передавать в функцию как аргумент. Подобный объект инициализируется только значением одного из элементов перечисления, и только такое значение ему присваивается – явно или как значение другого объекта того же типа. Даже соответствующие допустимым элементам перечисления целые значения не могут быть ему присвоены:
Однако в арифметических выражениях перечисление может быть автоматически преобразовано в тип int. Например: const int array_size = 1024;
// правильно: pt2w преобразуется int int chunk_size = array_size * pt2w; 3.9. Тип “массив” Мы уже касались массивов в разделе 2.1. Массив – это набор элементов одного типа, доступ к которым производится по индексу – порядковому номеру элемента в массиве. Например: int ival; определяет ival как переменную типа int, а инструкция int ia[ 10 ]; задает массив из десяти объектов типа int. К каждому из этих объектов, или элементов массива, можно обратиться с помощью операции взятия индекса: ival = ia[ 2 ]; присваивает переменной ival значение элемента массива ia с индексом 2. Аналогично ia[ 7 ] = ival; присваивает элементу с индексом 7 значение ival. Определение массива состоит из спецификатора типа, имени массива и размера. Размер задает количество элементов массива (не менее 1) и заключается в квадратные скобки. Размер массива нужно знать уже на этапе компиляции, а следовательно, он должен быть константным выражением, хотя не обязательно задается литералом. Вот примеры правильных и неправильных определений массивов: extern int get_size();
// buf_size и max_files константы const int buf_size = 512, max_files = 20; int staff_size = 27;
// правильно: константа char input_buffer[ buf_size ];
// правильно: константное выражение: 20 - 3 char *fileTable[ max_files-3 ];
// ошибка: не константа double salaries[ staff_size ];
// ошибка: не константное выражение int test_scores[ get_size() ]; Объекты buf_size и max_files являются константами, поэтому определения массивов input_buffer и fileTable правильны. А вот staff_size – переменная (хотя и инициализированная константой 27), значит, salaries[staff_size] недопустимо. (Компилятор не в состоянии найти значение переменной staff_size в момент определения массива salaries.) Выражение max_files-3 может быть вычислено на этапе компиляции, следовательно, определение массива fileTable[max_files-3] синтаксически правильно. Нумерация элементов начинается с 0, поэтому для массива из 10 элементов правильным диапазоном индексов является не 1 – 10, а 0 – 9. Вот пример перебора всех элементов массива: int main() { const int array_size = 10; int ia[ array_size ];
for ( int ix = 0; ix < array_size; ++ ix ) ia[ ix ] = ix; } При определении массив можно явно инициализировать, перечислив значения его элементов в фигурных скобках, через запятую: const int array_size = 3; int ia[ array_size ] = { 0, 1, 2 }; Если мы явно указываем список значений, то можем не указывать размер массива: компилятор сам подсчитает количество элементов: // массив размера 3 int ia[] = { 0, 1, 2 }; Когда явно указаны и размер, и список значений, возможны три варианта. При совпадении размера и количества значений все очевидно. Если список значений короче, чем заданный размер, оставшиеся элементы массива инициализируются нулями. Если же в списке больше значений, компилятор выводит сообщение об ошибке: // ia ==> { 0, 1, 2, 0, 0 } const int array_size = 5; int ia[ array_size ] = { 0, 1, 2 }; Символьный массив может быть инициализирован не только списком символьных значений в фигурных скобках, но и строковым литералом. Однако между этими способами есть некоторая разница. Допустим, const char cal[] = {'C', '+', '+' }; const char cal2[] = " C++"; Размерность массива ca1 равна 3, массива ca2 – 4 (в строковых литералах учитывается завершающий нулевой символ). Следующее определение вызовет ошибку компиляции: // ошибка: строка " Daniel" состоит из 7 элементов const char ch3[ 6 ] = " Daniel"; Массиву не может быть присвоено значение другого массива, недопустима и инициализация одного массива другим. Кроме того, не разрешается использовать массив ссылок. Вот примеры правильного и неправильного употребления массивов:
Чтобы скопировать один массив в другой, придется проделать это для каждого элемента по отдельности: const int array_size = 7; int ia1[] = { 0, 1, 2, 3, 4, 5, 6 };
int main() { int ia3[ array_size ];
for ( int ix = 0; ix < array_size; ++ix ) ia2[ ix ] = ia1[ ix ];
return 0; } В качестве индекса массива может выступать любое выражение, дающее результат целого типа. Например: int someVal, get_index(); ia2[ get_index() ] = someVal; Подчеркнем, что язык С++ не обеспечивает контроля индексов массива – ни на этапе компиляции, ни на этапе выполнения. Программист сам должен следить за тем, чтобы индекс не вышел за границы массива. Ошибки при работе с индексом достаточно распространены. К сожалению, не так уж трудно встретить примеры программ, которые компилируются и даже работают, но тем не менее содержат фатальные ошибки, рано или поздно приводящие к краху. Упражнение 3.22 Какие из приведенных определений массивов содержат ошибки? Поясните. (a) int ia[ buf_size ]; (d) int ia[ 2 * 7 - 14 ] (b) int ia[ get_size() ]; (e) char st[ 11 ] = " fundamental"; (c) int ia[ 4 * 7 - 14 ]; Упражнение 3.23 Следующий фрагмент кода должен инициализировать каждый элемент массива значением индекса. Найдите допущенные ошибки: int main() { const int array_size = 10; int ia[ array_size ];
for ( int ix = 1; ix < = array_size; ++ix ) ia[ ia ] = ix;
//... } Многомерные массивы В С++ есть возможность использовать многомерные массивы, при объявлении которых необходимо указать правую границу каждого измерения в отдельных квадратных скобках. Вот определение двумерного массива: int ia[ 4 ][ 3 ]; Первая величина (4) задает количество строк, вторая (3) – количество столбцов. Объект ia определен как массив из четырех строк по три элемента в каждой. Многомерные массивы тоже могут быть инициализированы: int ia[ 4 ][ 3 ] = { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 }, { 9, 10, 11 } }; Внутренние фигурные скобки, разбивающие список значений на строки, необязательны и используются, как правило, для удобства чтения кода. Приведенная ниже инициализация в точности соответствует предыдущему примеру, хотя менее понятна: int ia[4][3] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; Следующее определение инициализирует только первые элементы каждой строки. Оставшиеся элементы будут равны нулю: int ia[ 4 ][ 3 ] = { {0}, {3}, {6}, {9} }; Если же опустить внутренние фигурные скобки, результат окажется совершенно иным. Все три элемента первой строки и первый элемент второй получат указанное значение, а остальные будут неявно инициализированы 0. int ia[ 4 ][ 3 ] = { 0, 3, 6, 9 }; При обращении к элементам многомерного массива необходимо использовать индексы для каждого измерения (они заключаются в квадратные скобки). Так выглядит инициализация двумерного массива с помощью вложенных циклов: int main() { const int rowSize = 4; const int colSize = 3; int ia[ rowSize ][ colSize ];
for ( int = 0; i < rowSize; ++i ) for ( int j = 0; j < colSize; ++j ) ia[ i ][ j ] = i + j j; } Конструкция ia[ 1, 2 ] является допустимой с точки зрения синтаксиса С++, однако означает совсем не то, чего ждет неопытный программист. Это отнюдь не объявление двумерного массива 1 на 2. Агрегат в квадратных скобках – это список выражений через запятую, результатом которого будет последнее значение 2 (см. оператор “запятая” в разделе 4.2). Поэтому объявление ia[1, 2] эквивалентно ia[2]. Это еще одна возможность допустить ошибку. |
Последнее изменение этой страницы: 2019-04-09; Просмотров: 322; Нарушение авторского права страницы