Теория для зачёта (Teoria_po_C++)

Посмотреть архив целиком

Список вопросов:

1. Алфавит С++, объекты, характеристики, идентификаторы.
2. Типы, размер в байтах, экстремальные значения.
3. Константы.
4. Описание переменных.
5. Инициализация. Выражения.
6. Порядок, приоритет и правила вычислений. Преобразование типов.
7. Арифметические операции. Особенности использования операций ++ и --.
8. Логические операции и отношения.
9. Побитовые операции.
10. Операции присваивания и их виды.
11. Понятие блока. Операторы return, goto, метки.
12. Условный оператор if.
13. Оператор цикла while и do ... while.
14. Оператор цикла for.
15. Оператор-переключатель switch. Сравнение с Паскалем.
16. Роль и особенности использования управляющих операторов break и continue.
17. Функции форматного вывода: printf, fprintf, sprintf.
18. Спецификации преобразования данных при вводе/выводе.
19. Функции форматного ввода: scanf, fscanf, sscanf.
20. Функции ввода/вывода литер и строк. Управляющие символы.
21. Функции обработки строк.



2. Типы, размер в байтах, экстремальные значения.


С каждым именем (идентификатором) в программе связан тип. Он задает те операции, которые могут применяться к имени (т.е. к объекту, который обозначает имя), а также интерпретацию этих операций.
Некоторые имена являются именами типов. Обычно имя типа нужно, чтобы задать в описании типа некоторое другое имя. Кроме того, имя типа может использоваться в качестве операнда в операциях sizeof (с ее помощью определяют размер памяти, необходимый для объектов этого типа) и new (с ее помощью можно разместить в свободной памяти объект этого типа).
Еще имя типа может использоваться в операции явного преобразования одного типа к другому.
Основные типы С++ представляют самые распространенные единицы памяти машин и все основные способы работы с ними. Это:

char
short int
int
long int

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

float
double
long double

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

unsigned char
unsigned short int
unsigned int
unsigned long int

Ниже приведены типы, которые используются для явного задания знаковых типов:

signed char
signed short int
signed int
signed long int

Поскольку по умолчанию значения типа int считаются знаковыми, то соответствующие типы с signed являются синонимами типов без этого служебного слова.
Но тип signed char представляет особый интерес: все 3 типа - unsigned char, signed char и просто char считаются различными.
Для краткости (и это не влечет никаких последствий) слово int можно не указывать в многословных типах, т.е. long означает long int, unsigned - unsigned int. Вообще, если в описании не указан тип, то предполагается, что это int. Все же обычно пропуск типа в описании в надежде, что по умолчанию это будет тип int, считается дурным стилем. Он может вызвать тонкий и нежелательный эффект.
Для хранения символов и работы с ними наиболее подходит тип char. Обычно он представляет байт из 8 разрядов. Размеры всех объектов в С++ кратны размеру char, и по определению значение sizeof(char) тождественно 1. В зависимости от машины значение типа char может быть знаковым или беззнаковым целым. Конечно, значение типа unsigned char всегда беззнаковое, и, задавая явно этот тип, мы улучшаем переносимость программы. Однако, использование unsigned char вместо char может снизить скорость выполнения программы. Естественно, значение типа signed char всегда знаковое.
В язык введено несколько целых, несколько беззнаковых типов и несколько типов с плавающей точкой, чтобы программист мог полнее использовать возможности системы команд. У многих машин значительно различаются размеры выделяемой памяти, время доступа и скорость вычислений для значений различных основных типов. Как правило, зная особенности конкретной машины, легко выбрать оптимальный основной тип (например, один из типов int) для данной переменной. Однако, написать действительно переносимую программу, использующую такие возможности низкого уровня, непросто.
Для размеров основных типов выполняются следующие соотношения:

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

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

sizeof(I)==sizeof(signed I)==sizeof(unsigned I)

Здесь I может быть типа char, short, int или long. Помимо этого гарантируется, что char представлен не менее, чем 8 разрядами, short - не менее, чем 16 разрядами и long - не менее, чем 32 разрядами. Тип char достаточен для представления любого символа из набора символов данной машины. Но это означает только то, что тип char может представлять целые в диапазоне 0..127. Предположить большее - рискованно.
Типы беззнаковых целых больше всего подходят для таких программ, в которых память рассматривается как массив разрядов. Но, как правило, использование unsigned вместо int, не дает ничего хорошего, хотя таким образом рассчитывали выиграть еще один разряд для представления положительных целых. Описывая переменную как unsigned, нельзя гарантировать, что она будет только положительной, поскольку допустимы неявные преобразования типа, например:

unsigned surprise = -1;

Это определение допустимо (хотя компилятор может выдать предупреждение о нем).
_________________
ты хочешь поговорить об этом?

4. Описание переменных.


Описание вводит в программу имя, указав его тип и, возможно, начальное значение.
Имя (идентификатор) следует описать прежде, чем оно будет использоваться в программе на С++. Это означает, что нужно указать его тип, чтобы транслятор знал, к какого вида объектам относится имя. Ниже приведены несколько примеров, иллюстрирующих все разнообразие описаний:

char ch;
int count = 1;
char* name = "Njal";
complex cvar;
const double pi = 3.1415926535897932385;

Из этих примеров видно, что роль описаний не сводится лишь к привязке типа к имени. Большинство указанных описаний одновременно являются определениями, т.е. они создают объект, на который ссылается имя. Для ch, count, name и cvar таким объектом является элемент памяти соответствующего размера. Этот элемент будет использоваться как переменная, и говорят, что для него отведена память. Для real подобным объектом будет заданная функция. Для константы pi объектом будет число 3.1415926535897932385. Для complex объектом будет новый тип. Следующие описания уже не являются определениями:

extern complex sqrt(complex);
extern int error_number;
struct user;

Это означает, что объекты, введенные ими, должны быть определены где-то в другом месте программы. Тело функции sqrt должно быть указано в каком-то другом описании. Память для переменной error_number типа int должна выделяться в результате другого описания error_number. Должно быть и какое-то другое описание типа user, из которого можно понять, что это за тип. В программе на языке С++ должно быть только одно определение каждого имени, но описаний может быть много. Однако все описания должны быть согласованы по типу вводимого в них объекта.
В некоторых описаниях указываются "значения" объектов, которые они определяют:

const double pi = 3.1415926535897932385;

Для типов, функций и констант "значение" остается неизменным; для данных, не являющихся константами, начальное значение может впоследствии изменяться:

int count = 1;
char* name = "Bjarne";
//...
count = 2;
name = "Marian";

Всякое описание, которое задает значение, является определением.


5. Инициализация. Выражения.

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

int a; //означает int a = 0;
double d; //означает double d = 0.0;

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

void f()
{
int x; // x не имеет надежно определенного значения
//…
}

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

int a[] = {1, 2};
Point z(1, 2);
int f();
_________________
ты хочешь поговорить об этом?


6. Порядок, приоритет и правила вычислений. Преобразование типов.


Порядок применения унарных операций и операций присваивания "справа налево", а всех остальных операций - "слева направо". То есть, a=b=c означает a=(b=c), a+b+c означает (a+b)+c, и *p++ означает *(p++), а не (*p)++.

____________________________________________________________
Операции С++
======================================================
++ Постфиксный инкремент lvalue ++
++ Префиксный инкремент ++ lvalue
-- Постфиксный декремент lvalue --
-- Префиксный декремент -- lvalue
- Унарный минус - expr
+ Унарный плюс + expr
____________________________________________________________
* Умножение expr * expr
/ Деление expr / expr
% Остаток от деления expr % expr
____________________________________________________________
+ Сложение (плюс) expr + expr
- Вычитание (минус) expr - expr
____________________________________________________________

Все операции таблицы, находящиеся между двумя ближайшими друг к другу горизонтальными чертами, имеют одинаковый приоритет. Приоритет операций уменьшается при движении "сверху вниз". Например, a+b*c означает a+(b*c), так как * имеет приоритет выше, чем +; а выражение a+b-c означает (a+b)-c, поскольку + и - имеют одинаковый приоритет, и операции + и - применяются "слева направо".
Синтаксис языка С++ перегружен скобками, и разнообразие их применений способно сбить с толку. Они выделяют фактические параметры при вызове функций, имена типов, задающих функции, а также служат для разрешения конфликтов между операциями с одинаковым приоритетом. К счастью, последнее встречается не слишком часто, поскольку приоритеты и порядок применения операций определены так, чтобы выражения вычислялись "естественным образом" (т.е. наиболее распространенным образом).
Тем не менее, порядок вычислений подвыражений, входящих в выражение, не всегда определен и здесь скобки могут помочь.
Скобки могут принудительно задать порядок вычисления. Например, a*(b/c) может вычисляться как (a*b)/c (если только пользователь видит в этом какое-то различие). Заметим, что для значений с плавающей точкой результаты вычисления выражений a*(b/c) и (a*b)/c могут различаться весьма значительно.


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

complex a = complex ( 1 );
complex b = 1; // неявно: 1 -> complex ( 1 )
a = b + complex ( 2 );
a = b + 2; // неявно: 2 -> complex ( 2)

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


8. Логические операции и отношения.

Операторы отношений оценивают по «двубальной системе» (ИСТИНА\ЛОЖЬ) отношения между двумя значениями.
____________________________________________________________
Операции С++ (отношения)
======================================================
< Меньше expr < expr
<= Меньше или равно expr <= expr
> Больше expr > expr
>= Больше или равно expr >= expr
____________________________________________________________
== Равно expr == expr
!= Не равно expr != expr
------------------------------------------------------------------------------------------

Логические операторы определяют различные сочетания истинных и ложных значений.
____________________________________________________________
Операции С++ (логические)
======================================================
& Поразрядное И expr & expr Л, если хотя бы одно Л
____________________________________________________________
^ Поразрядное исключающее ИЛИ expr ^ expr И, если различны
____________________________________________________________
| Поразрядное включающее ИЛИ expr | expr И, если хотя бы одно И
____________________________________________________________
&& Логическое И expr && expr
____________________________________________________________
|| Логическое ИЛИ expr || expr
____________________________________________________________
! НЕ !expr Отрицание
-------------------------------------------------------------------------------------------

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


10. Операции присваивания и их виды.

Общая форма записи оператора присваивания:

переменная = выражение

Здесь тип элемента переменная должен быть совместим с типом элемента выражение.
Оператор присваивания в С++ позволяет создавать целую цепочку присвоений:

int x,y,z;
x = y = z = 100;

Эта инструкция успешно работает благодаря тому, что оператор присваивания генерирует значение правостороннего выражения (т.е. сначала z присваивает значение 100, потом y значение z, а потом x значение y).
В С++ предусмотрены так же специальные составные операторы присваивания, которые упрощают программирование отдельных инструкций присваивания. Например:

x = x+10;
эквивалентно записи
x += 10;

Пара операторов += служит указанием компилятору присвоить переменной x сумму текущего значения переменной x и числа 10.
Составные версии операторов присваивания существуют для всех бинарных операторов (работающих с двумя операндами). Общий вид их записи таков:

переменная op= выражение

Здесь op конкретный оператор, объединяемый с оператором присваивания. Возможны следующие варианты объединения операторов:

+= -= *= /= %= &= |= ^= <<= >>=

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


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


Оператор if относится к инструкциям выбора. Синтаксис его таков:

if ( выражение ) оператор
if ( выражение ) оператор else оператор

В языке С++ среди основных типов нет отдельного булевского (тип со значениями истина, ложь). Все операции отношений: == != < > <= >= - дают в результате целое 1, если отношение выполняется, и 0 в противном случае. Обычно определяют константы TRUE как 1 и FALSE как 0.
В операторе if, если выражение имеет ненулевое значение выполняется первый оператор, а иначе выполняется второй (если он указан). Логические операции: && || ! - обычно используются в условиях. В операциях && и || второй операнд не вычисляется, если результат определяется значением первого операнда.
Некоторые простые операторы if удобно заменять выражениями условия. Например, вместо оператора

if (a <= b)
max = b;
else
max = a;

лучше использовать выражение

max = (a<=b) ? b : a;

Условие в выражении условия не обязательно окружать скобками, но если их использовать, то выражение становится понятнее.
Более глобальный вид инструкции if-else-if:
if (условие)
инструкция;
else if (условие)
инструкция;
else if (условие)
инструкция;

else
инструкция;


14. Оператор цикла for.


Общий формат записи цикла for для повторного выполнения инструкций:

for (инициализация; условие; итерация)
{
последовательность инструкций
}

Элемент инициализация обычно представляет собой инструкцию присваивания, которая устанавливает управляющую переменную цикла равной начальному значению (объявление это переменной может происходить прямо на месте, но тогда управляющая переменна будет существовать только на время существования цикла). Эта переменная действует в качестве счетчика, который управляет работой цикла.
Элемент условие представляет собой выражение типа bool, в котором тестируется значение управляющей переменной цикла (вообще говоря, здесь можно написать любое условное выражение). Результат этого тестирования определяет, выполнится цикл for еще раз или нет.
Элемент итерация – это выражение, которое определяет, как изменяется значение управляющей переменной цикла после каждой итерации.
Для управление циклом for можно использовать две или более управляющих переменных (в инициализации указываются несколько переменных, отделенные запятой, условие тоже может быть несколько (через запятую) и итерация может быть указана для нескольких переменных (через запятую)).
Разрешает опустить любой элемент заголовка цикла (инициализация, условие, итерация) или даже все сразу (for(;). Цикл так же может не иметь тела (так как много полезных вещей можно выполнить внутри инструкции for, без использования тела).


16. Роль и особенности использования управляющих операторов break и continue.


С помощью инструкции break можно организовать немедленный выход из цикла, опустив выполнение кода, оставшегося в его теле, и проверку условного выражения. При обнаружении внутри цикла инструкции break цикл завершается, а управление передается инструкции, следующей после цикла. Разумеется глупо втыкать данную инструкцию в тело цикла лишено смысла, но инструкция может быть полезна в некоторых случаях. Чаще всего она используется совместно с условной инструкции if (если на каком-то шаге цикла условие выполнилось, осуществляется немедленный выход из этого цикла). Если break написан во внутреннем цикле, то она оказывает воздействие только на него, не трогая цикл внешний.
Данная инструкция так же используется в условной инструкции switch (завершает выполнение инструкции switch, но не оказывает никакого воздействия на внешний для switch-инструкции цикл).

Помимо средства досрочного выхода из цикла, существует средство досрочного выхода из текущей его итерации. Это инструкция continue. Она принудительно выполняет переход к следующей итерации, опуская выполнение оставшегося кода в текущей.
В циклах while и do-while инструкция continue передает управление непосредственно инструкции, проверяющей условное выражение, после чего циклический процесс продолжает идти своим чередом. А в цикле for после выполнения инструкции continue сначала вычисляется итерационное выражение, а затем – условное. И только после этого циклический процесс будет продолжен.
Опять же, continue обычно используется с условной инструкцией if (если условие выполнилось, то осуществляется досрочный переход к следующему шагу цикла).
(привести пример ситуаций, где использование инструкций полезно)


18. Спецификации преобразования данных при вводе/выводе.


Основная функция вывода С есть:

int printf(const char* format, ...)

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

printf("there were %d members present.",no_of_members);

Здесь %d указывает, что no_of_members следует считать целым и печатать как соответствующую последовательность десятичных цифр. Если no_of_members==127, то будет напечатано

there were 127 members present.

Набор спецификаций преобразований достаточно большой и обеспечивает большую гибкость печати. За символом % может следовать:

- необязательный знак минус, задающий выравнивание влево в указанном
поле для преобразованного значения;
d необязательная строка цифр, задающая ширину поля; если в
преобразованном значении меньше символов, чем ширина строки, то оно
дополнится до ширины поля пробелами слева (или справа, если дана
спецификация выравнивания влево); если строка ширины поля начинается
с нуля, то дополнение будет проводится нулями, а не пробелами;
. необязательный символ точка служит для отделения ширины поля от
последующей строки цифр;
d необязательная строка цифр, задающая точность, которая определяет
число цифр после десятичной точки для значений в спецификациях
e или f, или же задает максимальное число печатаемых символов
строки;
* для задания ширины поля или точности может использоваться * вместо
строки цифр. В этом случае должен быть параметр целого типа, который
содержит значение ширины поля или точности;
h необязательный символ h указывает, что последующая спецификация d,
o, x или u относится к параметру типа короткое целое;
l необязательный символ l указывает, что последующая спецификация d,
o, x или u относится к параметру типа длинное целое;
% обозначает, что нужно напечатать сам символ %; параметр не нужен;
c символ, указывающий тип требуемого преобразования. Символы
преобразования и их смысл следующие:
d Целый параметр выдается в десятичной записи;
o Целый параметр выдается в восьмеричной записи;
x Целый параметр выдается в шестнадцатеричной записи;
f Вещественный или с двойной точностью параметр выдается в
десятичной записи вида [-]ddd.ddd, где число цифр после
точки равно спецификации точности для параметра. Если точность
не задана, печатается шесть цифр; если явно задана точность 0,
точка и цифры после нее не печатаются;
e Вещественный или с двойной точностью параметр выдается в
десятичной записи вида [-]d.ddde+dd; здесь одна цифра перед
точкой, а число цифр после точки равно спецификации точности
для параметра; если она не задана печатается шесть цифр;
g Вещественный или с двойной точностью параметр печатается по той
спецификации d, f или e, которая дает большую точность при
меньшей ширине поля;
c Символьный параметр печатается. Нулевые символы игнорируются;
s Параметр считается строкой (символьный указатель), и печатаются
символы из строки до нулевого символа или до достижения числа
символов, равного спецификации точности; но, если точность
равна 0 или не указана, печатаются все символы до нулевого;
p Параметр считается указателем и его вид на печати зависит от
реализации;
u Беззнаковый целый параметр печатается в десятичной записи.

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



17. Функции форматного вывода: printf, fprintf, sprintf.

Синтаксис:

#include
int fprintf(FILE *fp,char *format,...); /* ANSI */
int printf(char *format,...); /* ANSI */
int sprintf(char *buffer,char *format,...); /* ANSI */

Файл stdio.h, содержит прототип функций, поэтому его необходимо подключить для работы с функциями.
Функция printf направляет данные в стандартный поток вывода stdin. Функция fprintf направляет данные в поток вывода, заданный аргументом stream. Функция sprintf направляет данные, заканчивающиеся пустым символом (\0), в массив s; пользователь должен позаботиться о выделении достаточного количества памяти для массива. Каждая функция возвращает число переданных символов (не считая пустого в случае sprintf), или отрицательное число, если при выводе обнаружилась ошибка.
Каждая из перечисленных функций преобразует, форматирует и печатает выводимые значения val под управлением формата, заданного аргументом format. Формат - это цепочка символов, содержащая объекты двух категорий: обычные символы, которые просто копируются в выходной поток, и спецификаторы преобразований, каждому из которых соответствует одно, несколько или ни одного из выводимых значений. Если выводимых значений val недостаточно, результат непредсказуем; если их слишком много, избыточные игнорируются.
Каждый спецификатор преобразования начинается символом %, после которого последовательно записываются:
1) флаги (один, несколько или ни одного), которые уточняют смысл спецификации преобразования;
2) необязательная последовательность десятичных цифр, задающая минимальную ширину поля, в котором изображается результат преобразования. Если результат может быть изображен меньшим количеством символов, то поле дополняется слева (или справа, если задан флаг выравнивания по левой границе) пробелами до минимальной ширины; если последовательность, задающая ширину поля, начинается нулем, то для дополнения используются нули.
3) Точность, задающая минимальное количество цифр в изображении результата преобразования типа d, i, o, u, x, X, количество цифр после десятичной точки в изображении результата преобразования типа e, E, f, максимальное количество значащих цифр в изображении результата преобразования типа g, G, или максимальное количество символов в изображении результата преобразования типа s. Точность записывается в виде точки (.), за которой следует несколько десятичных цифр; отсутствие цифр интерпретируется как ноль. Дополнение результата символами, обусловленное точностью, подавляет дополнение, обусловленное шириной поля.
4) Необязательный символ l, означающий, что относящиеся к нему преобразования d, i, o, u, x, X применяются к целым выводимым значениям типа long. Для остальных преобразований символ l игнорируется.
5) Символ, обозначающий тип преобразования.
Вместо последовательности цифр ширину поля и точность можно обозначить звездочкой. Это означает, что в качестве ширины поля (или точности) используется целое значение val из списка аргументов; оно должно предшествовать соответствующему выводимому значению. Если значение, задающее ширину поля, отрицательно, то считается, что задан флаг -, а в качестве ширины поля берется абсолютная величина значения. Если отрицательно значение, задающее точность, она принимается равной нулю.
Функции возвращают количество напечатанных литер. Если имела место ошибка, возвращаемое значение отрицательно.
_________________



19.Функции форматного ввода: scanf, fscanf, sscanf.

Синтаксис:

#include
int scanf(char *format,...); /* ANSI */
int fscanf(FILE *fp, char *format,...); /* ANSI */
int sscanf(char *buffer, char *format,...); /* ANSI */

Это процедуры форматного ввода. Многоточия обозначают аргументы (от 0 и более), которые являются указателями на переменные для ввода информации. fscanf - читает из входного потока fp, scanf - читает из stdin, sscanf читает из указанного буфера buffer. Считываемые литеры преобразуются в соответствии с форматной строкой, и эти преобразованные значения размещаются по аргументам-указателям. Аргументы должны быть указателями на то, куда будут записываться значения.
Форматная строка состоит из:
1. Пробелов, литер табуляции и новой строки, ко-
торые вызывают пропуск ввода до следующей, не
'белой' (whitespace) литеры.
2. Других литер, кроме литеры %, которые "один в
один" переправляются во ввод.
3. Спецификаций преобразования, которые выглядят
следующим образом: _ '%'['*'][ширина поля][точность]литера преобразования_
Эта строка определяет, каким образом вводимые символы должны преобразовываться и записываться по соответствующим аргументам-указателям. Преобразование продолжается до первой неподходящей входной литеры или исчерпания ширины поля. Символ '*' является флагом подавления присваивания. Он вызывает выполнение преобразования, но результат игнорируется и для него не нужен соответствующий аргумент-указатель. Если число аргументов-указателей меньше спецификаций преобразования, результат непредсказуем. Если же число аргументов-указателей больше, лишние указатели игнорируются.
Ширина поля (field_width – это последовательность десятичных цифр, определяющая максимальное число литер в поле ввода.
Точность (precision) - L или l (Нижний регистр L). Если 'l' используется с одной из (d, i, o, u, x) литер преобразования, то она означает, что аргумент является указателем на long, а не на int. L или L флаг, при использовании (e) или (f) литер преобразования, означает, что аргумент является указателем на double, а не на float. h Аргумент является указателем на short.
Функции возвращают число присвоенных элементов ввода, исключая преобразования с подавленным присваиванием. Если встречается конец файла до того, как были выполнены какие-либо присваивания и возникли какие-либо конфликты (формата и ввода), возвращается значение EOF. Scanf() обычно завершает работу, когда достигает конца строки формата. fscanf возвращает количество успешно проведенных преобразований. Процесс заканчивается при встрече первой неподходящей литеры или признака конца файла (EOF). Ноль на выходе означает, что не обработано ни одного поля.
_________________
ты хочешь поговорить об этом?







2. Типы, размер в байтах, экстремальные значения.

С каждым именем (идентификатором) в программе связан тип. Он задает те операции, которые могут применяться к имени (т.е. к объекту, который обозначает имя), а также интерпретацию этих операций.
Некоторые имена являются именами типов. Обычно имя типа нужно, чтобы задать в описании типа некоторое другое имя. Кроме того, имя типа может использоваться в качестве операнда в операциях sizeof (с ее помощью определяют размер памяти, необходимый для объектов этого типа) и new (с ее помощью можно разместить в свободной памяти объект этого типа).
Еще имя типа может использоваться в операции явного преобразования одного типа к другому.
Основные типы С++ представляют самые распространенные единицы памяти машин и все основные способы работы с ними. Это:

char
short int
int
long int

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

float
double
long double

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

unsigned char
unsigned short int
unsigned int
unsigned long int

Ниже приведены типы, которые используются для явного задания знаковых типов:

signed char
signed short int
signed int
signed long int

Поскольку по умолчанию значения типа int считаются знаковыми, то соответствующие типы с signed являются синонимами типов без этого служебного слова.
Но тип signed char представляет особый интерес: все 3 типа - unsigned char, signed char и просто char считаются различными.
Для краткости (и это не влечет никаких последствий) слово int можно не указывать в многословных типах, т.е. long означает long int, unsigned - unsigned int. Вообще, если в описании не указан тип, то предполагается, что это int. Все же обычно пропуск типа в описании в надежде, что по умолчанию это будет тип int, считается дурным стилем. Он может вызвать тонкий и нежелательный эффект.
Для хранения символов и работы с ними наиболее подходит тип char. Обычно он представляет байт из 8 разрядов. Размеры всех объектов в С++ кратны размеру char, и по определению значение sizeof(char) тождественно 1. В зависимости от машины значение типа char может быть знаковым или беззнаковым целым. Конечно, значение типа unsigned char всегда беззнаковое, и, задавая явно этот тип, мы улучшаем переносимость программы. Однако, использование unsigned char вместо char может снизить скорость выполнения программы. Естественно, значение типа signed char всегда знаковое.
В язык введено несколько целых, несколько беззнаковых типов и несколько типов с плавающей точкой, чтобы программист мог полнее использовать возможности системы команд. У многих машин значительно различаются размеры выделяемой памяти, время доступа и скорость вычислений для значений различных основных типов. Как правило, зная особенности конкретной машины, легко выбрать оптимальный основной тип (например, один из типов int) для данной переменной. Однако, написать действительно переносимую программу, использующую такие возможности низкого уровня, непросто.
Для размеров основных типов выполняются следующие соотношения:

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

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

sizeof(I)==sizeof(signed I)==sizeof(unsigned I)

Здесь I может быть типа char, short, int или long. Помимо этого гарантируется, что char представлен не менее, чем 8 разрядами, short - не менее, чем 16 разрядами и long - не менее, чем 32 разрядами. Тип char достаточен для представления любого символа из набора символов данной машины. Но это означает только то, что тип char может представлять целые в диапазоне 0..127. Предположить большее - рискованно.
Типы беззнаковых целых больше всего подходят для таких программ, в которых память рассматривается как массив разрядов. Но, как правило, использование unsigned вместо int, не дает ничего хорошего, хотя таким образом рассчитывали выиграть еще один разряд для представления положительных целых. Описывая переменную как unsigned, нельзя гарантировать, что она будет только положительной, поскольку допустимы неявные преобразования типа, например:

unsigned surprise = -1;

Это определение допустимо (хотя компилятор может выдать предупреждение о нем).



3. Константы.

Целые константы предстают в четырех обличьях: десятичные, восьмеричные, шестнадцатеричные и символьные константы. Десятичные используются чаще всего и выглядят так, как можно было бы ожидать: 0 1234 976 12345678901234567890
Десятичная константа имеет тип int, при условии, что она влезает в int, в противном случае ее тип long. Компилятор должен предупреждать о константах, которые слишком длинны для представления в машине.
Константа, которая начинается нулем, за которым идет x (0x), является шестнадцатеричным числом, а константа, которая начинается нулем за которым идет цифра, является восьмеричным числом. Вот примеры восьмеричных констант: 0 02 077 0123
В шестнадцатеричной записи эти константы выглядят так: 0x0 0x2 0x3f 0x53
Для того чтобы сделать объект константой, а не переменной, нужно добавить ключевое слово const. Например:

const int model = 145;
const int v[] = { 1, 2, 3, 4 };

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

model = 145; // ошибка
model++; // ошибка

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

const char* peek(int i)
{
return private[i];
}

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



4. Описание переменных.

Описание вводит в программу имя, указав его тип и, возможно, начальное значение.
Имя (идентификатор) следует описать прежде, чем оно будет использоваться в программе на С++. Это означает, что нужно указать его тип, чтобы транслятор знал, к какого вида объектам относится имя. Ниже приведены несколько примеров, иллюстрирующих все разнообразие описаний:

char ch;
int count = 1;
char* name = "Njal";
complex cvar;
const double pi = 3.1415926535897932385;

Из этих примеров видно, что роль описаний не сводится лишь к привязке типа к имени. Большинство указанных описаний одновременно являются определениями, т.е. они создают объект, на который ссылается имя. Для ch, count, name и cvar таким объектом является элемент памяти соответствующего размера. Этот элемент будет использоваться как переменная, и говорят, что для него отведена память. Для real подобным объектом будет заданная функция. Для константы pi объектом будет число 3.1415926535897932385. Для complex объектом будет новый тип. Следующие описания уже не являются определениями:

extern complex sqrt(complex);
extern int error_number;
struct user;

Это означает, что объекты, введенные ими, должны быть определены где-то в другом месте программы. Тело функции sqrt должно быть указано в каком-то другом описании. Память для переменной error_number типа int должна выделяться в результате другого описания error_number. Должно быть и какое-то другое описание типа user, из которого можно понять, что это за тип. В программе на языке С++ должно быть только одно определение каждого имени, но описаний может быть много. Однако все описания должны быть согласованы по типу вводимого в них объекта.
В некоторых описаниях указываются "значения" объектов, которые они определяют:

const double pi = 3.1415926535897932385;

Для типов, функций и констант "значение" остается неизменным; для данных, не являющихся константами, начальное значение может впоследствии изменяться:

int count = 1;
char* name = "Bjarne";
//...
count = 2;
name = "Marian";

Всякое описание, которое задает значение, является определением.



5. Инициализация. Выражения.

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

int a; //означает int a = 0;
double d; //означает double d = 0.0;

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

void f()
{
int x; // x не имеет надежно определенного значения
//…
}

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

int a[] = {1, 2};
Point z(1, 2);
int f();

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


6. Порядок, приоритет и правила вычислений. Преобразование типов.

Порядок применения унарных операций и операций присваивания "справа налево", а всех остальных операций - "слева направо". То есть, a=b=c означает a=(b=c), a+b+c означает (a+b)+c, и *p++ означает *(p++).
____________________________________________________________
Операции С++
======================================================
++ Постфиксный инкремент lvalue ++
++ Префиксный инкремент ++ lvalue
-- Постфиксный декремент lvalue --
-- Префиксный декремент -- lvalue
- Унарный минус - expr
+ Унарный плюс + expr
____________________________________________________________
* Умножение expr * expr
/ Деление expr / expr
% Остаток от деления expr % expr
____________________________________________________________
+ Сложение (плюс) expr + expr
- Вычитание (минус) expr - expr
____________________________________________________________

Все операции таблицы, находящиеся между двумя ближайшими друг к другу горизонтальными чертами, имеют одинаковый приоритет. Приоритет операций уменьшается при движении "сверху вниз".
Синтаксис языка С++ перегружен скобками, и разнообразие их применений способно сбить с толку. Они выделяют фактические параметры при вызове функций, имена типов, задающих функции, а также служат для разрешения конфликтов между операциями с одинаковым приоритетом. К счастью, последнее встречается не слишком часто, поскольку приоритеты и порядок применения операций определены так, чтобы выражения вычислялись "естественным образом" (т.е. наиболее распространенным образом). Тем не менее, порядок вычислений подвыражений, входящих в выражение, не всегда определен и здесь скобки могут помочь. Скобки могут принудительно задать порядок вычисления. Например, a*(b/c) может вычисляться как (a*b)/c (если только пользователь видит в этом какое-то различие). Заметим, что для значений с плавающей точкой результаты вычисления выражений a*(b/c) и (a*b)/c могут различаться весьма значительно.

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

complex a = complex ( 1 );
complex b = 1; // неявно: 1 -> complex ( 1 )
a = b + complex ( 2 );
a = b + 2; // неявно: 2 -> complex ( 2)

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



7. Арифметические операции. Особенности использования операций ++ и --.

________________________________________
Операции С++ (арифметические)
===========================================
++ инкремент lvalue ++ или ++ lvalue
-- декремент lvalue -– или -- lvalue
* Умножение expr * expr
/ Деление expr / expr
% Остаток от деления expr % expr
+ Сложение (плюс) expr + expr
- Вычитание (минус) expr - expr
________________________________________________


Действие операторов +,-,/,* совпадает с действием аналогичных операторов в любом другом языке программирования (да и в алгебре, если на то пошло). Их можно применять к данным любого встроенного числового типа.
После применения оператора / в переменную записывается целая часть результата (если переменная типа int). Чтобы получить остаток от деления необходимо применить оператор %. Этот оператор можно применять как к целочисленным типам, так и к типам с плавающей точкой.
Операторы инкремента (++) и декремента (--) увеличивают и уменьшают значение операнда на единицу, соответственно. Операторы инкремента и декремента могут стоять как перед так и после операнда. Если эти операторы используются как часть большого выражения, то способ записи (перед или после) очень важен. Если такой оператор применен в префиксной форме, то С++ сначала выполнит эту операцию, чтобы операнд получил значение, которое затем будет использовано остальной частью выражения. Если же оператор применен в постфиксной форме, то С++ использует в выражение его старое значение, а затем выполнит операцию, в результате которой операнд обретет новое значение.
Использование этих операторов не только удобно, но и ускоряет работу программы.



8. Логические операции и отношения.

Операторы отношений оценивают по «двубальной системе» (ИСТИНА\ЛОЖЬ) отношения между двумя значениями.
____________________________________________________________
Операции С++ (отношения)
======================================================
< Меньше expr < expr
<= Меньше или равно expr <= expr
> Больше expr > expr
>= Больше или равно expr >= expr
____________________________________________________________
== Равно expr == expr
!= Не равно expr != expr
------------------------------------------------------------------------------------------

Логические операторы определяют различные сочетания истинных и ложных значений.

____________________________________________________________
Операции С++ (логические)
======================================================
&& Логическое И expr && expr Л, если хотя бы одно Л
____________________________________________________________
|| Логическое ИЛИ expr || expr И, если хотя бы одно И
____________________________________________________________
! НЕ !expr Отрицание
-------------------------------------------------------------------------------------------

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



9. Побитовые операции.
____________________________________________________________
Операции С++ (побитовые)
======================================================
<< Сдвиг влево expr << expr
>> Сдвиг вправо expr >> expr
____________________________________________________________
& Поразрядное И expr & expr Л, если хотя бы одно Л
____________________________________________________________
^ Поразрядное исключающее ИЛИ expr ^ expr И, если различны
____________________________________________________________
| Поразрядное включающее ИЛИ expr | expr И, если хотя бы одно И
____________________________________________________________


~ Поразрядное НЕ ~expr НЕ
____________________________________________________________

Побитовые операции работают с битами числа. То есть, если имеются два числа: 01001 и 10010 – то операция будет произведена с каждым битом (то есть, 0 с 1, 1 с 0 и так далее).
Операторы сдвига (<< и >>). Они сдвигает число на определенное количество разрядов (указывается) влево или вправо, соответственно. При сдвиге, допустим, на одну позицию в лево, все биты сдвигаются в лево на один разряд, а в младшей разряд записывается 0. При сдвиге вправо все биты сдвигаются, соответственно, вправо. Если сдвигу вправо подвергается значение со знаком, то знак сохраняется (без знака – в старший разряд 0). При сдвиге как вправо, так и влево крайние биты теряются.



10. Операции присваивания и их виды.

Общая форма записи оператора присваивания:

переменная = выражение

Здесь тип элемента переменная должен быть совместим с типом элемента выражение.
Оператор присваивания в С++ позволяет создавать целую цепочку присвоений:

int x,y,z;
x = y = z = 100;

Эта инструкция успешно работает благодаря тому, что оператор присваивания генерирует значение правостороннего выражения (т.е. сначала z присваивает значение 100, потом y значение z, а потом x значение y).
В С++ предусмотрены так же специальные составные операторы присваивания, которые упрощают программирование отдельных инструкций присваивания. Например:

x = x+10;
эквивалентно записи
x += 10;

Пара операторов += служит указанием компилятору присвоить переменной x сумму текущего значения переменной x и числа 10.
Составные версии операторов присваивания существуют для всех бинарных операторов (работающих с двумя операндами). Общий вид их записи таков:

переменная op= выражение

Здесь op конкретный оператор, объединяемый с оператором присваивания. Возможны следующие варианты объединения операторов:

+= -= *= /= %= &= |= ^= <<= >>=

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



11.Понятие блока. Операторы return, goto, метки.

Если функция не описана как void, она должна возвращать значение. Например:

int f() { } // ошибка
void g() { } // нормально

Возвращаемое значение указывается в операторе return в теле функции. Говоря проще, оператор return обеспечивает возврат из функции. В теле функции может быть несколько операторов return:

int fac(int n)
{
if (n > 1)
return n*fac(n-1);
else
return 1;
}

Подобно передаче параметров, операция возвращения значения функции эквивалентна инициализации. Считается, что оператор return инициализирует переменную, имеющую тип возвращаемого значения. Тип выражения в операторе return сверяется с типом функции, и производятся все стандартные и пользовательские преобразования типа. Например:

double f()
{
// ...
return 1; // неявно преобразуется в double(1)
}

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

int* f()
{
int local = 1;
// ...
return &local; // ошибка
}

Эта ошибка не столь типична, как сходная ошибка, когда тип функции - ссылка:

int& f()
{
int local = 1;
// ...
return local; // ошибка
}

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

int& f() { return 1; } // ошибка


Презираемый оператор goto (презираемый потому что способствуют написанию так называемого «спагетти-кода», она вносит в программу беспорядок и делает ее практически нечитабельной) все-таки есть в С++:

goto идентификатор;

идентификатор: оператор

Инструкция goto – это инструкция безусловного перехода. При ее выполнение управление программой передается инструкции, указанной с помощью метки. Метка – это действительный в С++ идентификатор, за которым поставлено двоеточие.
Вообще говоря, оператор goto мало используется в языках высокого уровня, но может быть очень полезен, если текст на С++ создается не человеком, а автоматически, т.е. с помощью программы. Например, операторы goto используются при создании анализатора по заданной грамматике языка с помощью программных средств. Кроме того, операторы goto могут пригодиться в тех случаях, когда на первый план выходит скорость работы программы. Один из них - когда в реальном времени происходят какие-то вычисления во внутреннем цикле программы.
Есть немногие ситуации и в обычных программах, когда применение goto оправдано. Одна из них - выход из вложенного цикла или переключателя. Дело в том, что оператор break во вложенных циклах или переключателях позволяет перейти только на один уровень выше.



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

Оператор if относится к инструкциям выбора. Синтаксис его таков:

if ( выражение ) оператор
if ( выражение ) оператор else оператор

В языке С++ среди основных типов нет отдельного булевского (тип со значениями истина, ложь). Все операции отношений: == != < > <= >= - дают в результате целое 1, если отношение выполняется, и 0 в противном случае. Обычно определяют константы TRUE как 1 и FALSE как 0.
В операторе if, если выражение имеет ненулевое значение выполняется первый оператор, а иначе выполняется второй (если он указан). Логические операции: && || ! - обычно используются в условиях. В операциях && и || второй операнд не вычисляется, если результат определяется значением первого операнда.
Некоторые простые операторы if удобно заменять выражениями условия. Например, вместо оператора

if (a <= b)
max = b;
else
max = a;

лучше использовать выражение

max = (a<=b) ? b : a;

Условие в выражении условия не обязательно окружать скобками, но если их использовать, то выражение становится понятнее.
Более глобальный вид инструкции if-else-if:

if (условие)
инструкция;
else if (условие)
инструкция;
else if (условие)
инструкция;

else
инструкция;



13. Оператор цикла while и do ... while.

Общие формы записи циклов while и do…while:

while (условие) инструкция
do инструкция while (условие)

Работой цикла управляет элемент условие, который представляет собой любое допустимое выражение типа bool. Элемент инструкция выполняется до тех пор, пока условное выражение возвращает ИСТИНА. Как только это условие становится ложным управление передается инструкции, которая следует за этим циклом.
В цикле while условное выражение проверяется при входе в цикл, а это значит, что тело цикла может не выполнится ни разу. В цикле же do…while условие проверяется при выходе из цикла. Это значит, что этот цикл всегда выполняется хотя бы один раз.



14. Оператор цикла for.

Общий формат записи цикла for для повторного выполнения инструкций:

for (инициализация; условие; итерация)
{
последовательность инструкций
}

Элемент инициализация обычно представляет собой инструкцию присваивания, которая устанавливает управляющую переменную цикла равной начальному значению (объявление это переменной может происходить прямо на месте, но тогда управляющая переменна будет существовать только на время существования цикла). Эта переменная действует в качестве счетчика, который управляет работой цикла.
Элемент условие представляет собой выражение типа bool, в котором тестируется значение управляющей переменной цикла (вообще говоря, здесь можно написать любое условное выражение). Результат этого тестирования определяет, выполнится цикл for еще раз или нет.
Элемент итерация – это выражение, которое определяет, как изменяется значение управляющей переменной цикла после каждой итерации.
Для управление циклом for можно использовать две или более управляющих переменных (в инициализации указываются несколько переменных, отделенные запятой, условие тоже может быть несколько (через запятую) и итерация может быть указана для нескольких переменных (через запятую)).
Разрешает опустить любой элемент заголовка цикла (инициализация, условие, итерация) или даже все сразу (for(;). Цикл так же может не иметь тела (так как много полезных вещей можно выполнить внутри инструкции for, без использования тела).



15. Оператор-переключатель switch. Сравнение с Паскалем.

Оператор switch относится к выбирающим оператором и его синтаксис выглядит так:

switch (выражение) {
case константа1:
последовательность инструкций
break;
case константа2:
последовательность инструкций
break;
.
.
.
default:
последовательность инструкций
break;
}

Инструкция switch обеспечивает многонаправленное ветвление. Она позволяет делать выбор одной из множества альтернатив. Хотя многонаправленное тестирование можно реализовать с помощью последовательности вложенных if-инструкций, для многих ситуаций инструкция switch оказывается более эффективным решением. Она работает следующим образом. Значение выражения последовательно сравнивается с константами из заданного списка. При обнаружении совпадения для одного из условий сравнения выполняется последовательность инструкций, связанная с этим условие.
Элемент выражение инструкции должен иметь целочисленный тип (например, char, byte, short, int) или тип string. Выражения, имеющие тип с плавающей точкой не разрешены. Очень часто в качестве управляющего switch-выражения используется просто переменная. Case-константы должны быть литералами, тип которых совместим с типом заданного выражения. При этом никакие две case-константы в одной switch-инструкции не могут иметь идентичных значений.
Последовательность инструкций default-ветви (эта ветвь, вообще говоря, не обязательна) выполняется в том случае, если ни одна из заданных case-констант не совпадает с результатом вычисления switch-выражения.
Последовательность инструкций выполняется до тех пор, пока не встретится инструкция break.
Эта инструкция используется, чтобы не было, так называемых «провалов» (передачи управления вниз – последовательность инструкций, относящихся к одной ветви, переходят в последовательность инструкций, относящихся к следующей). Провалов можно избежать и другими способами (например, с помощью инструкции goto), но использование break – самый распространенный способ. Правда, иногда вариант с провалом бывает полезен. Например:

Switch(i) {
case 1:
case 2:
case 3: инструкция
break;
}

Здесь при равенстве i единице, двойке или тройке выполнится одна и та же инструкция.
(сравнить с Паскалем)



16. Роль и особенности использования управляющих операторов break и continue.

С помощью инструкции break можно организовать немедленный выход из цикла, опустив выполнение кода, оставшегося в его теле, и проверку условного выражения. При обнаружении внутри цикла инструкции break цикл завершается, а управление передается инструкции, следующей после цикла. Разумеется глупо втыкать данную инструкцию в тело цикла лишено смысла, но инструкция может быть полезна в некоторых случаях. Чаще всего она используется совместно с условной инструкции if (если на каком-то шаге цикла условие выполнилось, осуществляется немедленный выход из этого цикла). Если break написан во внутреннем цикле, то она оказывает воздействие только на него, не трогая цикл внешний.
Данная инструкция так же используется в условной инструкции switch (завершает выполнение инструкции switch, но не оказывает никакого воздействия на внешний для switch-инструкции цикл).

Помимо средства досрочного выхода из цикла, существует средство досрочного выхода из текущей его итерации. Это инструкция continue. Она принудительно выполняет переход к следующей итерации, опуская выполнение оставшегося кода в текущей.
В циклах while и do-while инструкция continue передает управление непосредственно инструкции, проверяющей условное выражение, после чего циклический процесс продолжает идти своим чередом. А в цикле for после выполнения инструкции continue сначала вычисляется итерационное выражение, а затем – условное. И только после этого циклический процесс будет продолжен.
Опять же, continue обычно используется с условной инструкцией if (если условие выполнилось, то осуществляется досрочный переход к следующему шагу цикла).
(привести пример ситуаций, где использование инструкций полезно)



17. Функции форматного вывода: printf, fprintf, sprintf.

Синтаксис:

#include
int fprintf(FILE *fp,char *format,...); /* ANSI */
int printf(char *format,...); /* ANSI */
int sprintf(char *buffer,char *format,...); /* ANSI */

Файл stdio.h, содержит прототип функций, поэтому его необходимо подключить для работы с ними.
Функция printf направляет данные в стандартный поток вывода stdin. Функция fprintf направляет данные в поток вывода, заданный аргументом stream. Функция sprintf направляет данные, заканчивающиеся пустым символом (\0), в массив s (пользователь должен позаботиться о выделении достаточного количества памяти для массива). Каждая функция возвращает число переданных символов (не считая пустого в случае sprintf), или отрицательное число, если при выводе обнаружилась ошибка.
Каждая из перечисленных функций преобразует, форматирует и печатает выводимые значения val под управлением формата, заданного форматной строкой.
Форматная строка состоит из:
1. Других литер, кроме литеры %, которые "один в один" переправляются во ввод.
2. Спецификаций преобразования, которые выглядят следующим образом:

_ '%'['*'][ширина поля][точность]литера преобразования_

Эта строка определяет, каким образом выводимые символы должны преобразовываться.



18. Спецификации преобразования данных при вводе/выводе.

Основная функция вывода С есть:

int printf(const char* format, ...)

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

printf("there were %d members present.",no_of_members);

Здесь %d указывает, что no_of_members следует считать целым и печатать как соответствующую последовательность десятичных цифр. Если no_of_members==127, то будет напечатано

there were 127 members present.

Набор спецификаций преобразований достаточно большой и обеспечивает большую гибкость печати.

_ '%'['*'][ширина поля][точность]литера преобразования_

За символом % может следовать:

- необязательный знак минус, задающий выравнивание влево в указанном
поле для преобразованного значения;
d необязательная строка цифр, задающая ширину поля; если в
преобразованном значении меньше символов, чем ширина строки, то оно
дополнится до ширины поля пробелами слева (или справа, если дана
спецификация выравнивания влево); если строка ширины поля начинается
с нуля, то дополнение будет проводится нулями, а не пробелами;


Случайные файлы

Файл
30164.rtf
128965.rtf
122992.rtf
86429.rtf
24937.rtf




Чтобы не видеть здесь видео-рекламу достаточно стать зарегистрированным пользователем.
Чтобы не видеть никакую рекламу на сайте, нужно стать VIP-пользователем.
Это можно сделать совершенно бесплатно. Читайте подробности тут.