Семь основных элементов программирования

В разделе 2 вы написали две совершенно разные программы на С++, использующие несколько основных элементов программирования. Что это за элементы? Вы узнаете о них, прочитав следующий раздел.

Целью большинства программ является решение задач. Программа решает задачи, манипулируя информацией или данными. Вам необходимо научиться:

– вводить информацию в программу;

– выделять место для хранения информации;

– задавать инструкции по обработке информации;

– выводить информацию обратно из программы пользователю.

Можно организовать инструкции так, что:

– некоторые из них будут выполняться только тогда, когда специальное условие (или набор условий) истинно;

– другие будут повторяться несколько раз;

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

Мы описали семь основных элементов программирования: ввод, тип данных, операции, вывод, условное выполнение, циклы и подпрограммы. Этот список не полон, но он описывает те общие элементы, которые обычно включают программы.

Большинство языков программирования содержат все эти элементы; многие, включая С++, имеют также и дополнительные возможности. Однако, если вы хотите изучить новый язык быстро, вы можете определить, как этот язык реализует эти семь элементов, а затем двигаться дальше. Приведем обзорное описание каждого элемента:

– вывод означает запись информации на экран, на диск или в порт ввода-вывода;

– ввод означает чтение значений с клавиатуры, с диска или из порта ввода-вывода;

– типы данных – это константы, переменные и структуры, которые содержат числа (целые и вещественные), текст (символы и строки) или адреса (переменных и структур);

– операции присваивают одно значение другому, комбинируют значения (складывают, делят и т.д.) и сравнивают значения (равно, не равно и т.д.);

– условное выполнение относится к выполнению набора инструкций, если заданное условие истинно (и пропуску их, если оно ложно);

– циклы выполняют набор инструкций некоторое фиксированное количество раз, или пока истинно некоторое условие;

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

Теперь мы рассмотрим, как использовать эти элементы в С++.

 

Вывод

 

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

 

Функция printf

 

Мы уже использовали наиболее употребительную функцию вывода в С++ – подпрограмму printf. Ее целью является запись информации на экран. Ее формат как прост, так и гибок:

 

printf(<строка формата>, <объект>, <объект>,...);

 

Строка формата – это строка, которая начинается и заканчивается двойными кавычками (“как эта”); цель printf – запись этой строки на экран. Перед выводом printf заменяет все дополнительно перечисленные объекты в соответствии со спецификациями формата, указанными в самой строке. Например, во второй программе был следующий оператор printf:

 

printf("Сумма=%d\n", sum);

 

Символ %d в строке формата – это спецификация формата. Все спецификации формата начинаются с символа процента (%) и (обычно) сопровождаются одной буквой, обозначающей тип данных и способ их преобразования.

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

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

Общеиспользуемые спецификации формата:

%d – целое число;

%u – целое число без знака;

%p – значение указателя;

%f – число с плавающей точкой;

%e – число с плавающей точкой в экспоненциальной форме;

%c – символ;

%s – строка;

%x или %X – целое в шестнадцатеричном формате.

Вы можете задать ширину поля, помещая ее между % и буквой; например, десятичное поле шириной 4 задается, как %4d. Значение будет напечатано сдвинутым вправо (впереди пробелы) так, что общая ширина поля равна 4.

Если нужно напечатать знак %, то вставьте %%.

Символ \n в строке не является спецификацией формата, а употребляется (по историческим мотивам) как управляющая (escape) последовательность, и представляет специальный символ, вставляемый в строку. В этом случае \n вставляет символ в начале новой строки, поэтому после вывода строки курсор передвинется к началу новой строки.

Наиболее часто используемые управляющие последовательности:

\f – (перевод формата или очистка экрана);

\t – (табуляция);

\b – забой <;

\xhhh – (вставка символа с кодом ASCII hhh, где hhh содержит от одной до трех шестнадцатеричных цифр).

Если вам нужно напечатать обратную косую черту, то вставьте \\.

Маршрут MS-DOS в строке С++. Все знают, что обратный слеш (\) в MS DOS означает, что следующая далее строка есть имя каталога (справочника), однако в С++ слеш является ключевым словом в строке. Это противоречие является одной из проблем, в тех случаях, когда вам необходимо указать маршрут доступа к файлу в строке С++. Например, вы набираете:

 

"c:\new\tools.c"

 

При этом вы ожидаете, что задается файл tools.c в каталоге new на диске с. Это, однако, не совсем так. Вместо желаемого, комбинация \n, являющаяся подстрокой строки С++, указывающей маршрут доступа к файлу, представляет собой ключевую последовательность для перехода на новую строку (LF или символ перехода на новую строку), а \t есть ни что иное как изображение символа табуляции в С++-программе. Таким образом, возникла ситуация, когда в имя файла были встроены символы новой строки и табуляции. В результате, DOS воспринимает эту строку как неправильное имя файла, так как имя файла не должно включать символов табуляции или новой строки. Если же необходимость использования в имени файла комбинации символов, воспринимаемых как управляющие, велика, применяйте их экранирование путем удвоения обратного слеша для каждой из встречающихся комбинаций управляющих символов.

Правильная строка (с учетом экранирования управляющих последовательностей) будет иметь вид:

 

"c:\\new\\tools.c"

 

4.1.2. Другие функции вывода: puts и putchar

Имеются две другие функции вывода, которые могут вас заинтересовать: puts и putchar. Функция puts выводит строку на экран и завершает вывод символом новой строки, например, можно переписать HELLO.CPP следующим образом:

void main()

{

puts("Hello, world");

}

 

Заметим, что в конце строки опущен \n; это не нужно, так как puts сама добавляет этот символ.

Наоборот, функция putchar записывает единственный символ на экран и не добавляет \n. Оператор putchar(ch) эквивалентен printf("%c", ch).

Зачем же нужно использовать puts и /или putchar вместо printf? Одним из доводов является то, что программа, реализующая функцию printf, гораздо больше; если вы не нуждаетесь в ней (для числового вывода или специального форматирования), то, используя puts и putchar, можно сделать свою программу меньше и быстрее. Например, файл типа EXE, создаваемый компиляцией версии HELLO.CPP, использующий puts, значительно меньше, чем файл EXE для версии, использующей printf.

 

Ввод

 

В С++ имеется несколько функций ввода; некоторые производят ввод из файла или из входного потока, другие - с клавиатуры.

 

4.2.1. Функция scanf

 

Для интерактивного режима ввода можно использовать в большинстве случаев функцию scanf. Scanf – это функция ввода, по смыслу эквивалентная printf; ее формат выглядит так:

 

scanf(<строка формата>, <адрес>, <адрес>,...);

 

В scanf используются многие из тех же спецификаторов формата %<буква>, что и у функции printf: %d – для целых, %f – для чисел с плавающей точкой, %s – для строк и т.д.

Однако scanf имеет одно очень важное отличие: объекты, следующие за строкой формата, должны быть адресами, а не значениями. В второй программе SUM.C содержится следующий вызов:

 

scanf("%d %d", &a, &b);

 

Этот вызов сообщает программе, что она должна ожидать от вас ввода двух десятичных (целых) чисел, разделенных пробелом; первое будет присвоено a, а второе – b. Заметим, что здесь используется операция адреса (&) для передачи адресов a и b функции scanf.

 

Сейчас мы рассмотрим понятие белого поля. Промежуток между двумя командами формата %d фактически означает больше, чем просто промежуток. Он означает, что вы можете иметь любое количество “белых полей” между значениями.

Что такое белое поле? Это любая комбинация пробелов, табуляций и символов новой строки. В большинстве ситуаций компиляторы и программы С++ обычно игнорируют белое поле.

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

 

scanf("%d, %d", &a, &b);

 

Это позволяет вам ввести значения, разделенные запятой.

 

Передача адреса функции scanf. Что если вы хотите ввести строку? Наберите и выполните следующую программу:

 

void main ()

{

char name[30];

printf("Как Вас зовут: ");

scanf("%s", name);

printf("Привет, %s\n", name);

}

 

Поскольку name является массивом символов, значение name – это адрес самого массива. По этой же причине перед именем name не используется адресный оператор &, вы просто пишете scanf ("%s", name);.

Обратите внимание, что вы использовали массив символов (char name [30];), вместо указателя на символ (char *name;). Почему? Причиной этого служит тот факт, что объявление массива на самом деле резервирует память для хранения его элементов, а при объявлении ссылки этого не происходит. Если бы мы использовали объявление char *name;, тогда нам бы пришлось явным образом резервировать память для хранения переменной *name.

 

4.2.2. Использование gets и getch для ввода

Использование scanf, однако, порождает другую проблему. Снова выполните программу, но теперь введите ваше имя и фамилию. Заметьте, что программа использует в своем ответе только имя. Почему? Потому, что введенный вами после имени пробел сигнализирует scanf о конце вводимой строки.

Возможны два способа решения этой проблемы. Вот первый из них:

 

void main()

{

char first[20], middle[20], last[20];

printf("Как Вас зовут: ");

scanf("%s %s %s", first, middle, last);

printf("Дорогой %s, или %s?\n", last, first);

}

 

Это означает, что имеется три компоненты имени; в примере функция scanf не пойдет дальше, пока вы действительно не введете три строки. Но что, если необходимо прочитать полное имя, как одну строку, включая пробелы? Вот второй способ решения:

 

void main

{

char name [60];

printf("Как вас зовут: ");

gets(name);

printf("Привет, %s\n", name);

}

 

Функция gets читает все, что вы набираете, до тех пор пока не нажмете Enter. Она не помещает Enter в строку; однако в конец строки добавляет нулевой символ (\0).

Наконец, есть еще функция getch. Она читает единственный символ с клавиатуры, не выдавая его на экран (в отличии от scanf и gets). Заметим, что у нее нет параметра ch; getch является функцией типа char, ее значение может быть непосредственно присвоено ch.

 

Потоковый ввод-вывод

 

Вы научились использовать функции printf и scanf для ввода и вывода данных. Функция printf служит для форматированного вывода на устройство вывода вроде монито­ра, а scanf, в свою очередь, для форматированного ввода. Однако, эти функции не лишены недостатков.

Синтаксис использования этих функций примерно одинаков:

 

printf(<строка формата>, <объект>, <объект>,...);

scanf(<строка формата>, <адрес>, <адрес>,...);.

 

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

Строка формата может содержать литеры и параметры вроде %d (десятичный) и %s (строковый), помогающие функции разобраться в по­лученных аргументах. Точная информация о типах аргументов нужна компилятору для того, чтобы правильно извлекать переменные из стека (туда они помещаются при вызо­ве функции). Так как список переменных может иметь произвольную длину, то строка формата задает порядок, количество и тип аргументов.

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

Cin и cout. Как ни удивительно, операция потокового вывода (ostream) « и операция потокового ввода (istream)» изначально были реализованы как надстройка над printf и scanf. Это может показаться странным, но справедливости ради следует сказать, что, как бы ни были неудобны эти функции, их работоспособность проверялась годами.

Обозначения cin и cout – это не функции и не операции. Это объекты, или экземпляры класса. Чтобы можно было их использовать, включите в ваш модуль заголовок <iostream.h>:

 

#include <iostream.h>

 

После этого с объектами cin и cout можно работать.Они обеспечивают в точности те же возможности, что и функции printf и scanf, но их симмет­ричный синтаксис гораздо проще, удобнее и существенно легче усваивается.

Для записи в устройство вывода используйте cout:

 

int birthday = 1974;

char *greetings = "Здравствуй, мир!";

cout «greetings «"Я родился в" «birthday «

"году" «endl;

 

Обратите внимание на однородность синтаксиса вне зависимости от типа данных. Здесь присутствуют целое число, переменная char*, литерная строка и еще какое-то endl, и все совершенно одинаковым образом. Вообще гово­ря, данные любого базового типа можно отправить на вывод тем же самым образом. Синтаксис cin почти идентичен:

int a = 0;

cout «"Сколько вам лет?" «endl;

cin» a;

 

Обозначение endl в приведенном выше фрагменте – это манипулятор потока ввода-вывода. Он выполняет ту же функцию, что и символ \n в программах на С++. И endl, и \n (новая стро­ка) посылают на вывод комбинацию возврат каретки–перевод строки.

Первоначально сами объекты cin и cout для ввода и вывода использовали функции printf и scanf, которые из-за своих списков аргументов неопределенной длины работают достаточно медленно. Разумеется, если медленную функцию, вро­де printf, использовать для создания другой, то в результате получится функция еще более медленная. И действительно, поначалу ввод/вывод через cin и cout происходил с удручающей скоростью. Теперь cin и cout более не используют printf и scanf и работают гораздо эффективнее. Использование этих объектов в программах делает работу более эффективной, а процесс программирования и отладки – более легким и понятным.

 

 

Типы данных

 

При написании программы мы работаем с некоторым видом информации, большинство которой попадает в один из 4-х основных типов: целые числа, числа с плавающей точкой, текст и указатели.

Целые – это числа, которые используются для счета (например, 1, 2, 5, –21, 752).

Числа с плавающей точкой могут содержать дробные разряды и экспоненту (5,4567*10⁶⁵). Иногда их называют действительными (вещественными) числами (real).

Текст состоит из символов (a, Z,!, 3) и строк (“Это просто проверка”).

Указатели не хранят информацию; вместо этого каждый из них содержит адрес памяти ЭВМ, в которой хранится информация.

 

Числа с плавающей точкой

 

С++ поддерживает 4 основных типа данных в различных формах. Мы уже использовали 2 из них: целые (int) и символы (char). Сейчас мы будем модифицировать последнюю программу для использования 3-го типа данных: чисел с плавающей точкой (float). Имеется также версия типа float, известная как double. Как вы могли догадаться, переменная типа double в два раза больше переменной типа float. Это означает, что она может иметь больше значащих цифр и больший диапазон значений экспоненты.

Войдем в редактор С++ и преобразуем программу и следующему виду:

 

void main ()

{

int a, b;

float ratio;

printf ("Введите два числа:");

scanf ("%d %d",&a, &b);

ratio = a/b;

printf ("Отношение =%f\n", ratio);

}

 

Сохраним ее под именем RATIO.CPP. Введя два значения (такие, как 10 и 3), вы получите результат (3.000000). Вероятно, вы ожидали ответа 3.333333; почему же ответ оказался только 3? Потому, что a и b имеют тип int, отсюда и результат тоже типа int. Он был преобразован к типу float при присваивании его ratio, но преобразование имело место после, а не до деления. Вернитесь в редактор и измените тип a и b на float; измените также строку формата "%d %d" в scanf на "%f %f". Сохраните программу, затем компилируйте и выполняйте. Результат теперь 3.333333, как и ожидалось.

Есть и другое решение этой проблемы. В С++ предусмотрена возможность изменять тип переменной на время операции. Это может быть полезно, например, в приведенном выше примере. Для такого изменения необходимо добавить перед именем переменной заключенное в скобки имя типа, в который ее нужно преобразовать:

 

void main ()

{

int a, b;

float ratio;

printf ("Введите два числа:");

scanf ("%d %d",&a, &b);

ratio = (float)a/(float)b;

printf ("Отношение =%f\n", ratio);

}

 

Теперь при выполнении программы будет получен результат 3.333333, хотя переменные a и b определены как int. Такой прием полезно использовать в том случае, если требуется в одном или нескольких местах программы обращаться к переменным одного типа как к переменным другого типа.

Три типа целых

 

В дополнение к типу int, С++ поддерживает версии short int и long int, обычно сокращаемые до short и long. Фактические размеры short, int и long зависят от реализации; все, что гарантирует С++ – это то, что переменная типа short не будет больше (т.е. не займет больше байт), чем переменная типа long. В С++ эти типы занимают 16 битов (short), 16 битов (int) и 32 бита (long).

Беззнаковые типы. С++ позволяет вам объявлять некоторые типы (char, short, int и long) беззнаковыми (unsigned). Это означает, что вместо отрицательных значений эти типы имеют только неотрицательные (большие или равные нулю) значения. Переменные такого типа могут поэтому хранить бóльшие значения, чем знаковые типы. Например, в С++ переменная типа int может содержать значения от –32768 до 32767; переменная же типа unsigned int может содержать значения от 0 до 65535. Обе занимают одно и тоже место в памяти (16 бит в данном случае), но используют его по-разному.

Таблица 1 -Типы данных, размеры и диапазоны в С++

Тип	Размер (в битах)	Диапазон
unsigned char		0..255
char		–128…127
enum		–32768…32767
unsigned short		0…65535
short		–32768…32767
unsigned int		0…65535
int		–32768…32767
unsigned long		0…4294967295
long		–2147483648…2147483647
float		3.4E–38…3.4E+38
double		1.7E–308…1.7+308
long double		1.7E–308…1.7+308
pointer		(указатели near, _ cs, _ ds, _ es, _ ss)
pointer		(указатели far, huge)

Определение строки

 

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

Использование символьного массива. Загрузите программу HELLO.CPP снова в редактор. Теперь приведите ее к следующему виду:

 

void main ()

{

char msg [30];

strcpy(msg, "Hello, world");

puts(msg);

}

 

Запись [30] после msg предписывает компилятору выделить память для 29 символов, то есть для массива из 29 переменных типа char (30-е знакоместо будет заполнено нулевым символом – \0 – часто называемым в этом издании нулевым завершителем). Переменная msg не содержит символьное значение: она хранит адрес (некоторого места в памяти) первого из этих 29 переменных типа char.

Когда компилятор обнаруживает оператор strcpy(msg, "Hello, world");, он делает две вещи:

– создает строку “ Hello, world ”, сопровождаемую нулевым (\0) символом (с кодом ASCII 0), в некотором месте файла объектного кода;

– вызывает подпрограмму strcpy, которая копирует символы из этой строки по одному в участок памяти, указываемый переменной msg. Он делает это до тех пор, пока не будет скопирован нулевой символ в конце строки “ Hello, world ”.

Когда вы вызываете функцию puts(msg);, то ей передается значение msg – адрес первой буквы, на которую он указывает. Затем puts проверяет, не является ли символ по этому адресу нулевым. Если да, то puts заканчивает работу, иначе puts печатает этот символ, добавляет единицу (1) к адресу и делает проверку на нулевой символ снова.

Из-за этой зависимости от нулевого символа известно, что строки в Си называются “завершающиеся нулем”, т.е. они представляют из себя последовательности символов, заканчивающиеся нулевым символом. Этот подход позволяет снять ограничения с длины строк: строка может быть такой длины, какой позволяет память для ее хранения.

Использование указателя на символ. Второй метод, который можно использовать для определения строк, – это указатель на символы. Отредактируйте вашу программу к следующему виду:

 

void main ()

{

char *msg;

msg = "Hello, world";

puts(msg);

}

 

Звездочка (*) впереди msg указывает компилятору, что msg является указателем на символ; другими словами, msg может хранить адрес некоторого символа. Однако, при этом компилятор не выделяет никакого пространства для размещения символов и не инициализирует msg каким-либо конкретным значением.

Когда компилятор находит оператор msg = "Hello, world";, он делает две вещи:

– как и раньше, он создает строку “ Hello, world\n ”, сопровождаемую нулевым символом, где-то внутри файла объектного кода;

– присваивает начальный адрес этой строки – адрес символа H – переменной msg.

Команда puts(msg); работает так же, как и раньше, печатая символы до тех пор, пока она не встретит нулевой символ.

Строки можно объявить как указатели на тип данных char или как массивы данных типа char. Между ними существует лишь одно важное различие: если вы используете указатель на данные типа char, память для строки не резервируется; если вы используете массив данных, то память резервируется автоматически и переменная – имя массива – содержит адрес начала зарезервированной области памяти.

Недостаточное понимание этой разницы может привести к двум типам ошибок. Рассмотрим следующую программу:

 

void main()

{

char *name;

char msg[10];

printf("Назовите свое имя. ");

scanf("%s", name);

msg = "Здравствуйте, ";

printf ("%s %s: ", msg, name);

}

 

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

Первая ошибка содержится в выражении:

 

scanf (“%s”, name);

 

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

 

“ Possible use of ‘name’ before definition ”

(“ Возможно использование ‘name’ до ее определения ”)

 

Вторая ошибка содержится в операторе msg = “Здравствуйте, ”;. Компилятор считает, что вы пытаетесь заменить значение msg на адрес строковой константы “ Здравствуйте, ”. Это сделать невозможно, поскольку имена массивов являются константами, и не могут быть модифицированы (как, например, 7 является константой и нельзя записать “ 7 = i ”). Компилятор выдаст сообщение об ошибке:

 

“ Lvalue required ”

(“ Использование константы недопустимо ”)

 

Каково решение этой проблемы? Простейший выход – изменить способ описания переменных name и msg:

 

void main()

{

char name[10];

char *msg;

printf("Назовите свое имя. ");

scanf("%s", name);

msg = "Здравствуйте, ";

printf("%s %s", msg, name);

}

 

Эта программа безупречна. Переменной name выделяется память независимо от памяти, выделяемой для строки, которую вы вводите, тогда как в msg присваивается адрес строковой константы “ Здравствуйте, ”. Если, тем не менее, вы оставите старое описание, вам нужно изменить программу следующим образом:

 

#include <alloc.h>

void main()

{

char *name;

char msg[10];

name = (char*)malloc(10);

printf("Назовите свое имя. ");

scanf("%s", name);

strcpy(msg, "Здравствуйте, ");

printf("%s %s", msg, name);

}

 

Вызов функции malloc выделяет отдельно 10 байт памяти и присваивает адрес этого участка памяти name, решив нашу первую проблему. Функция strcpy производит посимвольное копирование из строковой константы string “ Здравствуйте, ” в массив msg.

Операции со строками. Рассмотрим несколько полезных функций для работы со строками. Их можно разбить на несколько групп:

– функции связывания (конкатенации):

 

char *strcat(char *dest, const char *src);

 

добавляет копию src в конец dest. Длина результирующей строки равна сумме длин исходных строк;

 

char *strncat(char *dest, const char *src,

size_t maxlen);

 

копирует maxlen символов строки scr в конце dest и затем добавляет нулевой символ;

 

– функции сравнения:

 

int strcmp(const char *s1, const char*s2);

 

сравнивает s1 и s2, возвращает значение, меньшее 0, если s1 < s2, равное 0, если s1 = s2, и большее нуля, если s1 > s2;

 

int stricmp(const char *s1, const char *s2);

 

сравнивает s1 и s2, не делая отличия между строчными и прописными буквами;

 

int strncmp (const char *s1, const char

*s2,

size_t maxlen);

 

производит такое же сравнение, как и strcmp, но просматривает не более maxlen символов;

 

– функции копирования:

 

char *strcpy(char *dest, const char *src);

 

копирует строку str в dest, завершая работу после копирования символа завершения строки;

 

char *strncpy(char *dest, const char *src, size_t maxlen);

 

копирует точно maxlen символов из scr в dest, усекая или заполняя нулями dest. Строка-приемник, dest, может не иметь символа конца строки, если длина строки-источника равна или больше maxlen;

 

– функции поиска:

 

char *strchr(const char *s, int c);

 

просматривает строку в прямом направлении для отыскания в ней заданного символа, ищет первое вхождение символа c в строку s. Символ конца строки (нулевой символ) считается частью строки, поэтому, например strchr(strs, 0); возвращает значение указателя на нулевой символ строки strs;

 

char *strpbrk(const char *s1, const char *s2);

 

осуществляет поиск в строке s1 первого вхождения любого из символов, определяемых строкой s2.

 

Описания других функций работы со строками доступны через систему помощи С++.

 

Идентификаторы

 

До сих пор мы давали имена переменным, не заботясь о том, какие на них накладываются ограничения.

Имена, которые вы даете константам, типам данных, переменным и функциям, называются идентификаторами. Некоторые из идентификаторов мы использовали ранее – это:

 

char, int, float main name, a, b, sum, msg, ratio scanf, printf, puts

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

 

В С++ имеется несколько правил об идентификаторах. Вот краткая их сводка:

– все идентификаторы должны начинаться с буквы (a...z, A...Z) или с подчеркивания (_);

– остальная часть идентификатора может состоять из букв, подчеркиваний и/или цифр (0...9). Никакие другие символы не разрешены;

– идентификаторы являются чувствительными к регистру букв. Это означает, что строчные буквы (a...z) отличаются от прописных букв (A...Z). Например, идентификаторы indx, Indx, INDX различны;

– значимыми являются первые 32 символа идентификатора.

 

4.4.5. Преобразования типов

 

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

Для преобразования строковых данных (тип string) используют следующие функции со сходным синтаксисом:

 

int atoi (const char *s); – в тип int;

long atol (const char *s); – в тип long;

double atof (const char *s); – в тип double.

 

Обратные преобразования выполняются таким образом:

 

char *itoa (int value, char *string, int radix); – из типа int;

char *ltoa (long value, char *string, int radix); – из типа long;

char *gcvt (double value, int ndec, char *buf); – из типа float,

 

где: radix определяет основание системы исчисления, в которой осуществляется перевод (в интервале от 2 до 36 включительно); ndec определяет количество значащих знаков после запятой.

 

Операции

Итак, вы научились получать данные в программу (и в ваши переменные); что же вы собираетесь делать с ними? Вероятно, как-то с ними манипулировать, используя допустимые операции. А С++ обладает большим количеством таких операций.

 

Операции присваивания

Самой общей операцией является присваивание, например,

 

ratio = a/b;

ch = getch();.

 

В С++ присваивание обозначается одним знаком равенства (=); при этом значение справа от знака равенства присваивается переменной слева.

Можно применять также последовательные присваивания, например:

 

sum = a = b;.

 

В таких случаях присваивание производится справа налево, то есть значение b будет присвоено переменной a, которая в свою очередь, будет присвоена sum, так что все три переменные получат одно и то же значение (а именно, начальное значение b).