Характеристика скалярных типов для 16-разрядного процессора

СТРУКТУРНОЕ

ПРОГРАММИРОВАНИЕ НА С++

(Конспект лекций)

 

 

 

Рыбинск 2007

Структурное программирование на C++

Общие сведения о языке C++. 4

Типы данных в C++. 5

Скалярные типы.. 5

Перечисляемый тип. 7

Определение типа пользователя. 8

Комментарии. 8

Константы и переменные. 8

Объявление переменных и констант. 9

Переменные. 9

Именованные константы.. 9

Блоки. Область видимости переменных. 10

Выражения. 10

Преобразование типов в выражениях. 13

Операторы C++. 13

Оператор (операция) присваивания. 13

Ввод-вывод в Си++. 14

Ввод с клавиатуры.. 15

Вывод на дисплей. 15

Условный оператор. 15

Оператор выбора. 17

Операторы цикла. 18

Цикл с предусловием.. 18

Цикл с постусловием.. 19

Цикл с параметром (цикл for ) 20

Структура программы на C++. Функции. 21

Структурированные типы данных в C++. 22

Массивы. 22

Символьные строки. 24

Структуры. 25

Передача параметров функции. Перегрузка функций. 26

Текстовые файлы в C++. Файловые потоки ввода-вывода. 28

Создание потока ввода-вывода. 29

Открытие и закрытие файла. 29

Обработка ошибок. 30

Чтение-запись символов в файл. 30

Ввод-вывод с преобразованием типов. 31

Чтение символьных строк из потока ввода. 33

Указатели. 33

Объявление указателей. 34

Операции над указателями. 34

Динамические переменные. 35

Указатели и массивы.. 37

Передача массивов в качестве параметров функции. 37

Связь указателей и массивов. Операции над указателями. 39

Динамические массивы.. 40

Работа со списочными структурами. 41

Линейный однонаправленный список. 41

Динамический стек. 44

Оценка алгоритмов. 46

Рекурсия. 47

Поиск. 49

Линейный поиск. 49

Двоичный поиск (дихотомия) 50

Сортировка. 51

 

 

Общие сведения о языке C++

Прямым предшественником языка C++ является структурный язык программирования C, который был предложен Дэнисом Ритчи (Dennis Ritchie) в начале 70-х годов ХХ века для операционной системы Unix. Впервые детальное описание языка C было выполнено в 1978 году в книге Брайана Кернигана (Brian Kernighan) и Дэниса Ритчи, в 1998 году вышел первый стандарт языка. Особенность языка C состоит в том, что он соединил в себе все основные признаки структурного языка высокого уровня (блок, переменная, операторы присваивания, ветвления, цикла) с низкоуровневыми средствами манипулирования с битами, байтами, адресами. Таким образом, язык C представляет собой мощный инструмент, который позволяет программисту иметь практически полную власть над компьютером. Однако следствием этого является невозможность поддерживать жесткий контроль за корректностью действий, инициируемых программным кодом, поэтому ответственность за последствия выполняемых программой действий возлагается на программиста.

К концу 70-х годов прошлого века стала ощущаться ограниченность структурных языков и структурной технологии программирования при работе над крупными проектами. Одним из новых технологических направлений, призванных разрешить эту проблему, явилось объектно-ориентированное программирование. В 1979 году Бьерн Страуструп (Bjarne Stroustrup) предложил объектно-ориентированное расширение расширение языка C – язык программирования, который сначала получил название «C с классами» (класс – одно из базовых понятий объектно-ориентированного программирования), а с 1983 года стал называться C++. Страуструп в качестве прямых предшественников созданного им языка называет язык C и объектно-ориентированный язык программирования Simula67. Язык C++ - высокоуровневое расширение C, объектно-ориентированный язык высокого уровня, сохранивший все основные структурные и низкоуровневые возможности языка С. С одной стороны объектно-ориентированные средства существенно расширили возможности языка при реализации крупных программных проектов, с другой стороны наличие низкоуровневых средств сохраняет за программистом основную долю ответственности за корректность программного кода. Первый стандарт языка C++, который существенно упорядочил и улучшил язык, был принят в 1998 году.

В настоящее время C++ сохраняет статус основного языка профессионального программирования, который является наиболее гибким и мощным инструментом при реализации крупных программных проектов. В свою очередь C++ может считаться родительским языком для таких популярных современных языков программирования как Java и C#, ориентированных на программирование в распределенной гетерогенной вычислительной среде.

 

Типы данных в C++

 

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

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

 

Скалярные типы

Основные скалярные типы C++:

char – символьный,

int – целый,

float – вещественный,

double – вещественный с двойной точностью,

bool – логический.

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

Спецификаторы длины:

short – короткий,

long – длинный.

Спецификаторы знака:

signed – знаковый (положительные и отрицательные значения),

unsigned –беззнаковый (только положительные значения).

Кроме того, в C++ определяется тип void – скалярный тип, множество значений которого пусто.

По умолчанию используются спецификаторы short и signed, т.е. отсутствие спецификатора длины соответствует значению «короткий», отсутствие спецификатора знака – значению «знаковый».

Особенность типа char в C++ состоит в двойственности трактовки. Значения этого типа могут рассматриваться как целые числа, над которыми могут выполняться соответствующие операции, или как байтовый код символов. Значения типа char (символьные константы) заключаются в апострофы: ‘g’, ‘a’; к типу char относятся и некоторые двухсимвольные значения (спецсимволы), например, ‘\n’ - переход к следующей строке.

Замечание: в C++ строковые константы заключаются в двойные кавычки, например, “stroka”. Поэтому ‘a’ – это символьное значение (литерал), а “a” – строковое значение, строка, состоящая из одного символа.

Размер типа int стандартом не определен и зависит от разрядности процессора и особенностей компилятора. Спецификатор short независимо от разрядности процессора устанавливает размер памяти для целого типа 2 байта, спецификатор long – 4 байта.

Объем памяти, соответствующий типу данных, можно определить с помощью функции sizeof:

sizeof (<имя типа>) – размер в байтах значения указанного типа,

sizeof < имя переменной> – размер в байтах типа, соответствующего указанной переменной.

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

sizeof (char) <= sizeof (short) <= sizeof (int) <= sizeof (long),

sizeof (float) <= sizeof (double) <= sizeof (long double).

 

Перечисляемый тип

Перечисляемый тип вводится непосредственным перечислением списка значений определяемого типа. Значение перечисляемого типа представляет собой идентификатор (имя). Определение перечисляемого типа выглядит следующим образом:

enum [имя типа] {<список значений>};

Примеры:

enum {spr, sum, aut, win};

или

enum season {spr, sum, aut, win};

Здесь season - имя определяемого перечисляемого типа. Значения перечисляемого типа считаются упорядоченными в соответствии с их последовательностью при определении типа. При этом каждому значению по умолчанию ставится в соответствие целое число – его порядковый номер в списке значений (нумерация значений начинается с нуля, а не с единицы).

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

enum season {spr, sum, aut, win};

равносильно

enum season {spr=0, sum=1, aut=2, win=3};

Можно нумеровать и не с нуля, при этом

enum season {spr=5, sum, aut, win};

равносильно

enum season {spr=5, sum=6, aut=7, win=8};

а

enum season {spr, sum, aut=4, win};

равносильно

enum season {spr=0, sum=1, aut=4, win=5};

 

Комментарии

В программе на C++ могут использоваться комментарии двух видов:

// - это комментарий к одной строке, помещается в конце строки,

/*это комментарий, размещаемый в нескольких строках*/.

 

Константы и переменные

Константы могут использоваться как константа-значение или просто значение соответствующего типа (литеральная константа) и как именованная константа. Именованные константы и переменные идентифицируются по именам. Имя константы и переменной представляет собой идентификатор, при этом необходимо иметь в виду, что в отличие, скажем, от Паскаля в C++ строчные и прописные буквы различаются. Так, если в Паскале имена temp и Temp идентичны и ссылаются на одну и ту же переменную, то в C++ - это два различных имени, которые могут обозначать две различные переменные с совершенно разными свойствами.

Тип константы-значения определяется по ее виду. По умолчанию для целых значений используется тип int, long или unsigned long в зависимости от значения, для вещественных - double. Кроме того, тип значения можно задать с помощью суффиксов L, l, U, u, F, f. При этом суффиксы L, l соответствуют спецификатору длины long; U, u – спецификатору unsigned; F, f – типу float.

Примеры: 56l, 56L, 341u, 5.l,.34L.

 

Переменные

Переменные объявляются с помощью инструкции следующего вида:

[спецификатор длины] [спецификатор знака] <тип> <список переменных>;

При объявлении переменной можно инициализировать ее значение, поместив в список переменных инициализатор - элемент вида

<имя переменной>=<значение>

или

<имя переменной> (<значение >).

Примеры:

short a, c=65, r(18), g;

signed char u=’t’, y, p;

unsigned short int a, f, i=1;

long double z(3.54), k=12., n, m(.25);

Замечание: в C++ точка с запятой не является разделителем, она завершает конструкцию и считается ее частью (например, частью оператора).

Именованные константы

При объявлении именованных констант перед указанием типа записывается спецификатор const и обязательно инициализируется значение, которое в процессе работы программы не может изменяться.

Примеры:

const long int a=4, d=562;

const double r=.24, pi=3.1415;

можно и так:

const long int a(4), d(562);

Выражения

Выражение задает правило вычисления некоторого значения. В зависимости от числа операндов входящие в выражение операции делятся на унарные (один операнд), бинарные (два операнда) и тернарные (три операнда). Операндами могут быть константы, переменные, функции и выражения. При записи в выражении функции список ее аргументов заключается в круглые скобки, например, sin(a) или NOD(m,n).

Примером унарной операции является операция изменения знака -5.24, бинарной – операция сложения 4+7.

Ввод с клавиатуры

Операция ввода значения обозначается знаком >>. Ввод с клавиатуры (поток ввода cin) выполняется следующим оператором:

cin >>переменная >> переменная … >> переменная >>;

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

Вывод на дисплей

Операция вывода значений обозначается знаком <<. Вывод на дисплей (поток вывода cout) выполняется следующим оператором:

cout <<выражение <<выражение …<<выражение;

Здесь следует напомнить, что частным случаем выражения является переменная, константа или значение. Необходимо учитывать, что никакие разделители выводимых на экран значений автоматически в поток вывода не помещается, поэтому их надо включать в список выводимых значений (например, пробел ‘ ‘ или переход к началу следующей строки ‘\n’).

Примеры:

cout <<"\ninpute symbol: ";

cin >>symbol;

cout <<"number of symbol " <<symbol <<" is " <<number;

cout <<"input a b:"; cin >>a >>b;

cout <<"/ninput next chislo: "; cin >> cur;

Здесь наличие символа ‘/n’ в потоке вывода означает переход на следующую строку.

 

Условный оператор

Общий вид условного оператора:

if (<выражение-условие >)

<оператор_1>;

Else

<оператор_2>;

Если выражение-условие истинно (не равно нулю), выполняется оператор_1, в противном случае выполняется оператор_2.

Если после if или else необходимо выполнить несколько операторов, то аналогично Паскалю необходимо заключить их в фигурные скобки, т.е. использовать конструкцию «составной оператор» или «блок», при этом конструкция вида {…} обладает всеми правами простого оператора. Все операторы, входящие в конструкцию {…}, включая последний оператор, должны заканчиваться точкой с запятой, однако после самой конструкции точка с запятой не ставится, поскольку ограничителем для блока и составного оператора является закрывающаяся фигурная скобка. Заметим, что блок отличается от составного оператора наличием в нем объявлений или описаний локальных объектов (переменных, констант и т.д.).

В этом случае условный оператор будет выглядеть так:

if (<выражение-условие>)

{<оператор>; <оператор>; …;}

Else

{<оператор>; <оператор>; …;}

Пример (вычисление наибольшего из двух чисел):

if(x<y)

max=y;

Else

max=x;

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

max=(x<y)? y: x

Как и в Паскале допускается сокращенная форма условного оператора без else:

if (<выражение-условие>)

<оператор>;

В отличие от Паскаля, где в качестве выражения-условия может использоваться только логическое выражение, в C++ им может быть кроме логического любое арифметическое выражение целого типа или символьное. В этом случае значению «ложь» ставится в соответствие нулевое значение, а любое ненулевое трактуется как «истина».

Допускается вложение условных операторов. В конструкции с вложенным условным оператором вида

if (a<b)

{++x; y+=h;}

else if (a>b)

y*=5;

Else

{y=x+h; x++;}

действует правило: «каждое else относится к ближайшему предшествующему ему if».

В качестве примера использования в условном операторе выражения-условия числового типа, значение которого может трактоваться как false (нулевое значение) или true (ненулевое значение) можно привести алгоритм деления двух целых чисел:

int a,b;

cin >>a >>b;// ввод чисел a и b

if (b)

y=a/b;// b не равно нулю

Else

cout << “\nделение на нуль”;// b равно нулю

 

Оператор выбора

Условный оператор осуществляет ветвление на два направления. Во многих случаях приходится сталкиваться с ситуацией, когда необходимо выбирать один вариант из нескольких возможных, т.е. осуществлять множественное ветвление. Использование в таких случаях вложенного условного оператора зачастую приводит к весьма громоздким конструкциям. В Паскале для более компактного описания такого множественного ветвления имеется оператор выбора case. Аналогичный оператор множественного ветвления в C++ имеет вид:

switch (<выражение-селектор>)

{

case <константа>: <оператор>; <оператор>; …; break;

case <константа>: <оператор>; <оператор>; …; break;

case <константа>: <оператор>; <оператор>;

default: <оператор>; <оператор>; …;

}

Здесь выражение-селектор (или переменная-селектор) может быть любого скалярного типа, кроме вещественного. Сначала вычисляется выражение-селектор, затем полученное значение этого выражения ищется среди констант целого типа, стоящих после case. Если вычисленное значение найдено, выполняются операторы, начиная с соответствующего case, и до default; в противном случае выполняются операторы, идущие после default.

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

Ветвь default не является обязательной, однако, из соображений безопасности ее не рекомендуется опускать.

Пример 1:

Switch (x)

{

case 0: y+=h; break;

case 1: y*=3; z++; break;

case 2: y/=2; d=(h+y)/5;

default: y++;

}

Пример 2 (вычисление оценки в четырехбалльной системе по заданному значению стобалльного рейтинга):

int k;

cout <<”\nвведите ваш рейтинг: “; cin >> k;

k/=10;

Switch (k)

{

case 0:

case 1:

case 2:

case 3:

case 4: cout <<”\nВаша оценка – неудовлетворительно”; break;

case 5:

case 6: cout <<”\nВаша оценка – удовлетворительно”; break;

case 7:

case 8: cout <<”\nВаша оценка – хорошо”; break;

case 9:

case 10: cout <<”\nВаша оценка – отлично”;

default: cout <<”недопустимое значение рейтинга”;

}

Операторы цикла

Оператор цикла используется для описания повторяющихся (циклических) вычислений.

Как и в Паскале в Си++ можно использовать 3 формы оператора цикла: с предусловием, с постусловием и с параметром (цикл for).

Цикл с предусловием

while (<выражение-условие>)

<оператор>;

Оператор - тело цикла повторяется до тех пор, пока выражение-условие сохраняет значение «истина». Таким образом, выражение-условие формулируется как условие продолжения цикла. При этом каждый шаг цикла начинается с вычисления выражения-условия, поэтому, если уже на первом шаге оно приняло значение «ложь», тело цикла не выполняется ни разу. В теле цикла должны входить конструкции, изменяющие хотя бы одну переменную, входящую в выражение-условие. В противном случае выполнение оператора цикла никогда не закончится (зацикливание).

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

Пример (вычисление суммы последовательности целых чисел с числом нуль в качестве признака конца последовательности):

int S=0;

cout << “\ninput a: ”; cin >> a;

while (a!=0)

{

S+=a;

cout << “input a: ”; cin >> a;

}

Цикл с постусловием

do

<оператор>

while (<выражение-условие>);

Цикл с постусловием отличается от цикла с предусловием только тем, что на каждом шаге сначала выполняется оператор-тело цикла, а затем вычисляется выражение-условие и если оно принимает значение «ложь», выполнение оператора цикла завершается. Таким образом, в отличие от цикла с предусловием здесь оператор-тело цикла всегда выполняется хотя бы один раз.

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

Пример (вычисление суммы последовательности целых чисел, последнее из которых равно нулю):

int S=0;

do

{

cout << “input a: ”; cin >> a;

S+=a;

}

while (a!=0);

Принципиальное отличие этого оператора в C++ от Паскаля состоит в том, что и в цикле с предусловием, и в цикле с постусловием итерации продолжаются до тех пор, пока выражение-условие сохраняет значение «истина», т.е. отлично от нуля. Таким образом, это выражение должно быть сформулировано как условие продолжения цикла.

Цикл с параметром (цикл for )

for (<инициализация>; <выражение-условие>; <модификатор>)

<оператор>;

Модификатор – это выражение, которое изменяет модифицируемую переменную цикла.

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

Пример (вычисление суммы последовательности n целых чисел):

S=0;

for (i=1; i<=n; i++)

{

cout << “input a: ”; cin >> a;

S+=a;

}

Здесь модификатором является постфиксное выражение i++, согласно которому на каждом шаге значение переменной цикла i увеличивается на 1.

Можно инициализировать в цикле и переменную S:

for (S=0, i=1; i<=n; i++)

{

cout << “input a: ”; cin >> a;

S+=a;

}

Более того, внутри цикла можно и описать тип переменной, необходимо лишь помнить, что это описание будет действовать только в теле цикла.

for (S=0, int i=1; i<=n; i++)

{

cout << “input a: ”; cin >> a;

S+=a;

}

Оператор for может использоваться и без любого из разделов, т.е. может отсутствовать любая из конструкций: инициализатор- условие-модификатор.

Замечание: в отличие от Паскаля в теле цикла разрешается изменять параметр цикла и после завершения цикла значение параметра считается определенным.

Оператор break выполняет выход из цикла (досрочное завершение оператора), а оператор continue - досрочное завершение очередного шага цикла (досрочный переход к следующему шагу).

 

Структура программы на C++. Функции.

Программа на языке C++ состоит из функций, описаний и директив препроцессора. Одна из функций должна иметь имя main, программа начинает выполняться с первого оператора этой функции. Тело функции является блоком. В отличие от Паскаля функции не могут быть вложенными.

Простейшее определение функции выглядит так:

<тип> <имя функции> (<спецификация формальных параметров>)

{

<операторы>

}

Функция может не возвращать никакого значения, в этом случае в качестве ее типа указывается void (например, функция main).

Возврат вычисленного значения функции осуществляется оператором

return <выражение>;

Если функция имеет тип void, оператор return может отсутствовать.

При вызове функции вместо списка формальных параметров помещается список фактических параметров:

<имя функции> (<список фактических параметров>);

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

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

Замечание: в прототипе могут отсутствовать имена формальных параметров, достаточно лишь указать их типы.

Пример 1: Вычислить сумму последовательности отличных от нуля целых чисел, после которой следует число нуль (признак конца последовательности).

#include <iostream.h>

Void main()

{

int a, S=0;

cout << “\nВведите a: ”; cin >> a;

while (a!=0)

{

S+=a;

cout << “\nВведите a: ”; cin >> a;

}

cout << “Сумма=” <<S <<’\n’;

}

 

Пример 2: В последовательности из n целых чисел вычислить произведение чисел, попадающих в отрезок [b, c].

#include <iostream.h>

Void main()

{

int n, a, b, c, P=1;

cout << “\nВведите n: ”; cin >> n;

cout << “\nВведите b c: ”; cin >> b >>c;

for (int i=1; i<=n; i++)

{

cout << “Введите a: ”; cin >> a;

if ((a>=b)&&(a<=c)) P*=a;

}

cout << “Произведение=” <<P <<’\n’;

}

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

 

Структурированные типы данных в C++

Массивы.

Как и в Паскале, массив представляет собой упорядоченную последовательность данных одного типа, занимающих последовательные ячейки памяти. Для упорядочивания используется индексация элементов массива, т.е. приписывание каждому элементу значения индекса. В отличие от Паскаля, где для выбора индексного типа имеется значительная свобода, в C++ индекс представляет собой целое положительное число или ноль. Таким образом, элементы массива упорядочиваются приписыванием каждому из них порядкового номера, причем нумерация начинается с нуля, а не с единицы, т.е. первый элемент массива имеет индекс ноль. Общий вид описания массива:

<базовый тип> <имя массива> [<целая константа>];

Пример:

long int a, b[5], c;

const int n=10;

double s[n];

Здесь определен массив b, состоящий из 5 элементов типа long int: b[0] b[1] b[2] b[3] b[4] и массив s из 10 элементов типа double: s[0] s[1] … s[9].

При определении массив может быть инициализирован:

int a[5]={2, -3, 5, 4, 38};

Во многих случаях удобно бывает определить новый тип-массив:

typedef long int mas[10];

mas a,b;

В программе элементы массива представляют собой переменные с индексами.

Пример (ввод и суммирование массива).

#include <iostream.h>

Void main()

{

const int n=10;

int a[n], S=0;

cout << “\ninput array: ”;

for (int i=0; i<n; i++)

{

cin >> a[i];

S+=a[i];

}

cout << “Summa=” <<S <<’\n’;

}

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

Двумерные массивы определяются так:

int a [5][3];

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

Пример:

int a [2][3]={{1, 6, -3}, // первая строка

{5, 24, 0}}; // вторая строка

Все операции над массивами, включая ввод-вывод и присваивание, выполняются поэлементно.

Пример (ввод двумерного массива):

for (int i=0; i<5; i++)

for (int j=0; j<3; j++)

cin >>a[i][j];

 

Символьные строки.

Символьная строка является аналогом типа string Паскаля. В C++ она объявляется как массив символов, но при этом дополняется нуль-символом ‘\0’, что позволяет определять текущую длину строки:

char str[10]=”alfa”; // str[0]=’a’ str[1]=’l’ str[2]=’f’ str[3]=’a’ str[4]=’\0’

При инициализации можно было бы опустить длину строки:

char str[]=”alfa”;

но при этом под нее было бы выделено не 10 байт, а только 5.

Строки можно использовать в операторах ввода (cin) и вывода (cout), однако при вводе строки с клавиатуры необходимо учитывать, что оператор >> в качестве признака конца строки рассматривает символы пробела, табуляции или Enter и, встретив один из этих символов, завершает ввод строки. Поэтому, если в ответ на запрос

Введите строку

следующего фрагмента программы:

char text[50];

cout <<”/nВведите строку”;

cin >> text;

cout <<’Вы ввели/n’ <<text;

вы введете

Иван Петров

на экран будет выведено

Вы ввели

Иван

Эта проблема может быть разрешена использованием библиотечной функции

gets(<имя массива>)

стандартной библиотеки stdio.h, которая должна быть подключена инструкцией #include <stdio.h>.

Поскольку строка является массивом, для нее не определены операции присваивания и сравнения. Эти операции могут выполняться поэлементно или с помощью функций стандартной библиотеки string.h, которая должна быть подключена инструкцией #include <string.h>:

strcpy(str1, str2) // копирование строки str2 в строку str1,

strlen(str) // длина строки без ноль-символа,

strcmp(str1, str2) // сравнение строк: совпадают – false(0), иначе – true(1),

strcat(str1, str2) // конкатенация строк (str1+str2).

В операции копирования длина строки str1 должна быть на один символ больше,чем str2.

 

Структуры.

Структура (struct) в C++ является аналогом типа record в Паскале. Структура позволяет группировать данные разных типов. Определение типа struct выглядит так:

struct <имя типа> {

<тип поля> <имя поля>;

<тип поля> <имя поля>;

……………..

<тип поля> <имя поля>;

}

Пример:

struct anketa {

char name[20];

enum {man, woman} pol;

int born;

}

anketa a[5], b;

Можно определять переменные типа struct, не определяя новое имя типа, т.е. используя анонимный тип. Соответствующее описание переменных типа struct будет выглядеть так:

struct {

<тип поля> <имя поля>;

<тип поля> <имя поля>;

……………..

<тип поля> <имя поля>;

} <список переменных>;

Пример:

struct {

char name[20];

enum {man, woman} pol;

int born;

} a[5], b;

Здесь, как и в предыдущем примере определен массив a[5] из 5 элементов структурного типа и простая переменная b того же структурного типа. Одновременно с определением структурного типа можно описать и переменные этого типа, например:

struct anketa {

char name[20];

enum {man, woman} pol;

int born;

} a[5], b;

Обращение к элементам структуры, аналогично Паскалю выглядит так:

<имя переменной типа struct >.<имя поля>

Пример:

a[2].name=”Petrov”;

a[2].pol=man;

a[2].born=1985;

b.name=”Orlova”;

b.pol=woman;

b.born=1990;

Переменные типа struct можно использовать в операторе присваивания, но при этом действует правило именной эквивалентности типов.

 

Void main()

{

int a,b;

get_dim(a,b); // ввод длины и ширины

cout <<"\nlen=" <<a <<" wid=" <<b;

cout <<"\narea=" <<area(a,b); // вывод площади

}

void get_dim(int& len, int& wid) // определение функции get_dim

{

cout <<"\ninput len win: "; cin >>len >>wid;

}

int area(int len, int win) // определение функции area

{

return len*win;

}

Одним из характерных свойств объектно-ориентированного языка, в том числе и C++, является полиморфизм – использование одного имени для выполнения различных действий над различными объектами. Применительно к функциям это называется перегрузкой. Со свойством перегрузки мы уже сталкивались при рассмотрении основных операций C++, например, у деления существует только одно имя, "/", но его можно применять для деления как целых, так и вещественных значений.

Перегруженные функции имеют одинаковые имена, но разные списки параметров и возвращаемые значения.

 

Пример: (вычисление площади прямоугольника и объема параллелепипеда - полиморфизм):

#include <iostream.h>

void get_dim(int& len, int& wid); // прототип-1 функции get_dim

void get_dim(int& len, int& wid, int& hig); // прототип-2 функции get_dim

int ar_vol(int len, int wid); // прототип-1 функции ar_vol

int ar_vol(int len, int wid, int hig); // прототип-2 функции ar_vol

Void main()

{

int a,b,c;

get_dim(a,b); // вызов-1 функции get_dim

cout <<"\nlen=" <<a <<" wid=" <<b;

cout <<"\narea=" <<ar_vol(a,b); // вызов-1 функции ar_vol

get_dim(a,b,c); // вызов-2 функции get_dim

cout <<"\nlen=" <<a <<" wid=" <<b <<" hig=" <<c;

cout <<"\nvolume=" <<ar_vol(a,b,c); // вызов-2 функции ar_vol

}

void get_dim(int& len, int& wid) // определение-1 функции get_dim

{

cout <<"\ninput len win: "; cin >>len >>wid;

}

void get_dim(int& len, int& wid, int& hig) // определение-2 функции get_dim

{

cout <<"\ninput len wid hig: "; cin >>len >>wid >>hig;

}

int ar_vol(int len, int win) // определение-1 функции ar_vol

{

return len*win;

}

int ar_vol(int len, int wid, int hig) // определение-2 функции ar_vol

{

return len*wid*hig;

}

 

Текстовые файлы в C++. Файловые потоки ввода-вывода.

Поток – это последовательный логический интерфейс, который используется для чтения (ввода) данных из файла и записи (вывода) данных в файл.

Мы уже имели дело со стандартными потоками ввода-вывода cin и cout при вводе данных с клавиатуры и выводе на экран дисплея. Важным свойством потока является последовательное помещение элементов в поток. При этом потоки ввода cin и вывода cout являются однонаправленными: получить (прочитать) данные в программе можно из потока ввода, отправить (записать) данные из программы можно в поток вывода. Стандартные потоки ввода cin и в