Символьные константы с обратным слэшем

Код	Значение
\b	Забой
\f	Перевод формата
\n	Новая строка
\r	Возврат каретки
\t	Горизонтальная табуляция
\”	Двойная кавычка
\’	Одинарная кавычка
\0	Нулевой символ
\\	Обратный слэш
\v	Вертикальная табуляция
\a	Звонок
\N	Восьмеричная константа (N – значение)
\xN	Шестнадцатеричная константа (N – значение)

Символы с обратным слэшем следует использовать таким же образом, как и обычные символы.

12. Операторы

Оператор – это символ, который сообщает компилятору о необходимости выполнения некоторых математических или логических действий.

Арифметические операторы

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

высший +(унарный плюс) – (унарный минус) ++ -- * / %

низший + - (бинарные операторы)

Операторы, обладающие одним приоритетом, вычисляются компилятором слева направо. Круглые скобки в С устанавливают наивысший приоритет операций.

Операторы отношения и логические операторы

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

Операция	Значение	Пример
!	Логическое НЕ	!EOF
= =	Равно	value==0
!=	Не равно	value!=0
<	Меньше	i<count
>	Больше	i>count
> =	Больше или равно	i>=count
< =	Меньше или равно	i<=count
||	Логическое ИЛИ	!a || b
&&	Логическое И	a>8 && c<5

Таблица истинности для логических операторов образована с использованием на входах 1 и 0:

P	q	p&&q	p||q	!p

Как операторы отношения, так и логические операторы имеют более низкий приоритет по сравнению с арифметическими операторами.

Ниже показаны приоритеты выполнения операторов отношения и логических операторов

высший!

> >= < <=

==!=

&&

низший ||

Битовые операторы

С поддерживает все существующие битовые операторы. Битовые операции – это считывание, установка или сдвиг битов в байте или слове, которые соответствуют стандартным типам языка С char и int. Битовые операции не могут использоваться с float, double, long double, void и другими сложными типами.

Оператор	Действие
&	И
|	ИЛИ
^	Исключающее ИЛИ
~	Дополнение
>>	Сдвиг вправо
<<	Сдвиг влево

Битовые операторы И, ИЛИ, НЕ используют ту же таблицу истинности, что и их логические эквиваленты, за тем исключением, что они работают побитно. Исключающее ИЛИ имеет следующую таблицу истинности:

p q p^q

0 0 0

0 1 1

1 0 1

1 1 0

Битовое И чаще всего используется для обнуления битов. То есть любой бит установленный в 0, вызывает установку соответствующего бита в другом операнде в также в 0. Например, следующая функция читает символы из порта модема, используя функцию read_modem(), и сбрасывает бит чётности в 0.

char get_char_from_modem(void)

{

char ch;

ch = read_modem();

return (ch & 127);

}

 

Чётность отображается старшим битом, который устанавливается в 0 с помощью битового И, поскольку 7 младших бит равны 1.

13. Оператор?

С имеет очень мощный оператор, который можно использовать вместо if-else. Оператор? имеет следующий вид:

выражение1? выражение2: выражение3

Оператор? работает следующим образом: вычисляется выражение1, если оно истинно, то вычисляется выражение2 и всё выражение получает это значение, если ложно, то вычисляется выражение 3 и всё выражение получает это значение. Например:

x = 10;

y = x>9? 100: 200;

В данном примере y получает значение 100. Если бы х было меньше либо равно 9, то у получила бы значение 200.

14. Операторы указания & и *

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

-Предоставляют быстрое обращение к элементам массива.

-Позволяют функциям модифицировать передаваемые параметры.

-Поддерживают динамические структуры данных.

Первый оператор - &. Это унарный оператор, возвращающий адрес операнда в памяти. Например:

m = &count;

помещает в m адрес переменной count.

Второй оператор – это *, дополняющая &. Это унарный оператор, возвращающий значение переменной по указанному адресу. Например:

q = *m;

Переменные, содержащие адреса или указатели, должны объявляться путём помещения * перед именем переменной. Например, для объявления указателя ch на символ, следует написать

char *ch;

Здесь ch - это не символ, а указатель на символ. Тип данных, на который указывает указатель, называется базовым типом указателя.

Ниже операторы * и & используются для занесения числа 10 в переменную target:

#include <stdio.h>

int main(void)

{

int target, source;

int *m;

source = 10;

m = &source;

target = *m;

printf(“%d”, target);

return 0;

}

15. Оператор sizeof

sizeof – это унарный оператор, возвращающий длину в байтах переменной или типа, помещённого в скобки. Например:

float f;

printf(“%f ”, sizeof f);

printf(“%d”, sizeof(int));

выдаёт 4 4. (Предполагается использование 32-битных целых).

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

С поддерживает два типа оператора выбора: if и switch. Кроме того, оператор? является иногда альтернативой if.

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

Синтаксис полной формы условного оператора:

if (логическое выражение) оператор1;

else оператор2;

Если логическое выражение истинно, т.е. не равно нулю, то выполняется оператор1, иначе выполняется оператор2.

Синтаксис сокращенной формы условного оператора:

if (логическое выражение) оператор;

Оператор выполняется только в том случае, если логическое выражение не равно нулю, т.е. истинно.

Под логическим выражением понимается совокупность операций отношений и логических операций.

Часто, каждая из альтернативных возможностей оператора if требует выполнения более одного оператора. В этом случае необходимо заключить группу операторов в фигурные скобки { }.

Список операторов, заключенный в фигурные скобки, называется блоком.

Лесенка if-else-if

Типичной программной конструкцией является лесенка if-else-if. Она выглядит следующим образом:

if(выражение)

оператор;

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

оператор;

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

оператор;

…

else

оператор;

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

Switch

Синтаксис оператора switch:

switch (выражение)

{

case константное выражение: оператор или группа операторов;

break;

case константное выражение: оператор или группа операторов;

break;

case константное выражение: оператор или группа операторов;

break;

........

defaulf: оператор или группа операторов;

};

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

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

switch (выражение)

{

case константное выражение:

case константное выражение:

case константное выражение: оператор или группа операторов;

break;

};

17. Оператор «запятая»

Оператор «запятая» используется для связки нескольких выражений. Левая сторона оператора «запятая» вычисляется как не выдающая значения. Значение выражения, находящегося с правой стороны, станет значением разделенного запятыми выражения. Например:

x=(y=3, y+1);

Сначала присваивается 3 переменной y, а затем 4 переменной x. Скобки нужны, поскольку оператор «запятая» имеет более низкий приоритет, чем оператор присваивания.

18. Выражения

Выражения в С – это любая допустимая комбинация операторов, констант и переменных.

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

Компилятор преобразует все выражения к типу большего операнда.

1. Все переменные типа char short int преобразуются к типу int. Все переменные типа float – к типу double.

2. Если один из пары операндов имеет тип long double, другой операнд также преобразуется к типу long double. Иначе, если один из операндов имеет тип double, другой операнд также преобразуется к double. Иначе, если один из операндов имеет тип long, другой операнд также преобразуется к типу long. Иначе, если один из операторов имеет тип unsigned, другой операнд также преобразуется к типу unsigned.

20. Принудительные преобразования типов

Имеется возможность заставить выражение принять определённый тип с помощью оператора принудительных преобразований. Эта операция имеет следующий вид:

(тип) выражение;

где тип – это один из стандартных типов данных С или определяемый пользователем тип. Например, если необходимо, чтобы выражение x/2 имело тип float (частное со знаками после запятой), следует написать:

(float) x / 2

21. Циклы

Итерационный цикл for

Стандартный вид цикла for следующий:

for (инициализация_цикла; выражение-условие; список_выражений) оператор;

Оператор for имеет три главные части:

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

b. выражение-условие – это выражение, определяющее условие работы цикла.

c. список_выражений – это место где определяется характер изменения переменной цикла на каждой итерации.

Цикл for работает до тех пор, пока условие истинно. Когда условие становится ложным, выполнение программы продолжается с оператора, следующего за циклом for.

Пример:

#include <stdio.h>

int main(void)

{

int x;

for(x=1; x<=100; x++) printf(“%d ”,x);

return 0;

}

.

Ниже приведён пример цикла for, повторяющего несколько операторов:

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

Вариации цикла for

Одна из наиболее типичных вариаций достигается с использованием оператора «запятая», тем самым позволяя иметь две или более переменных цикла.

Бесконечный цикл

Поскольку не требуется ни одна из частей, можно создать бесконечный цикл путём удаления части проверки условия. Например:

for(;;) printf(“this loop will run forever.\n”);

while

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

тело цикла

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

Следующий пример показывает процедуру, обрабатывающую ввод с клавиатуры, работающую пока не будет введён символ ‘A’:

void wait_for_char(void)

{

char ch;

ch = ‘\0’;

while(ch!=’A’) ch = getchar();

}

Как и цикл for, цикл while сначала выполняет проверку, то есть тело цикла может вообще не выполняться.

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

void func1(void)

{

int working = 1;

while(working) {

working = procces1();

if (working)

working = process2();

if (working)

working = process3();

}

}

 

do/while

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

do {

последовательность операторов;

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

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

 

 

22. Оператор break

Оператор break имеет два назначения. Первое – это окончание работы оператора switch. Второе – это принудительное окончание цикла, минуя стандартную проверку условия.

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

Пример

#include <stdio.h>

int main(void)

{

int x;

for(x=1; x<100; x++) {

printf(“%d ”,x);

if(x==10) break;

}

return 0;

}

Данная программа выводит числа от 0 до 10 включительно и заканчивает работу, поскольку break вызывает немедленный выход из цикла, минуя условие x<100.

23. Оператор continue

Работа оператора continue чем-то похоже на работу оператора break. Но вместо форсированного окончания continue переходит к следующей итерации цикла, пропуская оставшийся код тела цикла. Например, следующая процедура выводит только положительные числа:

do{

scanf(“%d”, &x);

if(x<0) continue;

printf(“%d “, x);

} while(x!=100);

24. Метки и goto

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

Оператор goto имеет вид:

goto метка;

.

метка;

Метка находиться как до, так и после оператора goto. Например, используя оператор goto и метку, можно организовать цикл от 1 до 100.

x=1;

loop1:

x++;

if (x<100) goto loop;

25. Одномерный массив

Массив – это совокупность переменных одного типа, к которым обращаются с помощью общего имени. Доступ к отдельному элементу массива может осуществляться с помощью индекса. В С все массивы состоят из соприкасающихся участков памяти. Наименьший адрес соответствует первому элементу. Наибольший адрес соответствует последнему элементу. Массивы могут иметь одну или несколько размерностей.

Массивы тесно связаны с указателями.

Одномерный массив

Стандартный вид объявления одномерного массива следующий:

тип имя_переменной [ размер ];

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

общее число байт = sizeof (базовый тип)* число элементов

У всех массивов первый элемент имеет индекс 0. Поэтому, если написать

char p[10];

то будет объявлен массив символов из 10 элементов, причём эти элементы адресуются индексом от 0 до 9. Следующая программа загружает целочисленный массив числами от 0 до 9 и выводит его:

#include <stdio.h>

int main(void)

{

int x[10];

int t;

for(t=0; t<10; ++t) x[t] = t;

for(t=0; t<10; ++t) printf(“%d ”, x[t]);

return 0;

}

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

26. Создание указателя на массив

Можно создать указатель на первый элемент массива, указав имя массива без индекса. Пусть имеется int sample[10];

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

int *p;

int sample[10];

p = sample;

Можно также получить адрес первого элемента массива с помощью оператора &. Например, sample и &sample[0] приводят к одинаковому результату. Тем не менее в профессиональных программах нет почти нигде &sample[0].

27. Строки

Наиболее типичным представителем одномерного массива являются строки. Хотя С не определяет строкового типа, имеется поддержка строковых операций с помощью функций, имеющихся в любом языке. В С строка определяется как символьный массив произвольной длины, оканчивающийся нулевым символом. Нулевой символ определяется как '\0'. Поэтому необходимо объявлять символьные массивы на один символ больше, чем требуется для хранения самой длинной строки. Например, если необходимо объявить массив s, содержащий десятисимвольную строку, следует написать:

char s[11];

В результате этого выделяется место в конце строки для нулевого символа.

С поддерживает множество функций для работы со строками. Наиболее типичными являются strcpy(), strcat(), strlen(), strcmp() со следующими прототипами:

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

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

size_t strlen(const char *s1);

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

Все функции используют заголовочный файл string.h. Функция strcpy() копирует строку, на которую указывает s2, в строку на которую указывает s1. Функция возвращает s1. Функция strcat() выполняет конкатенацию строки, на которую указывает s1, и строки на которую указывает s2. Она также возвращает s1. Функция strlen() возвращает длину строки, на которую указывает s1. Тип данных size_t определён стандартом для адресов и в настоящее время для большинства машин определяется как беззнаковое длинное целое. Функция strcmp() сравнивает строки s1 и s2. Она возвращает 0, если две строки эквивалентны, значение меньше 0, если строка s1 при лексикографическом порядке идет раньше s2 и значение больше 0, если строка s1 при лексикографическом порядке идет после s2.

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

#include <string.h>

#include <stdio.h>

int main()

{

char s1[80], s2[80];

gets(s1); gets(s2);

printf(“lengths: %d %d\n“, strlen(s1), strlen(s2));

if(!strcmp(s1, s2)) printf(“The strings are equal\n”);

strcat(s1, s2);

printf(“%s\n”, s1);

return 0;

}

Если при запуске программы ввести строки “hello” и “hello”, в результате получится:

lengths: 5 5

The strings are equal

hellohello

28. Двумерные массивы

С позволяет создавать многомерные массивы. Простейшим видом многомерного массива является двумерный массив. Двумерный массив – это массив одномерных массивов. Двумерный массив объявляется следующим образом:

тип имя_массива [ размер второго измерения ][ размер первого измерения ];

В следующем примере в двумерный массив заносятся числа от 1 до 12, после этого массив выводится на экран.

#include <stdio.h>

int main()

{

int t, i, num[3][4];

/* загрузка чисел */

for(t=0; t<3; ++t)

for(i=0; i<4; ++i)

num[t][i] = (t*4)+i+1;

/* вывод чисел */

for(t=0; t<3; ++t) {

for(i=0; i<4; ++i)

printf(“%d “, num[t][i]);

printf(“\n”);

}

return 0;

}

В данном примере num[0][0] имеет значение 1, num[0][1] имеет значение 2, num[0][2] имеет значение 3 и так далее. num[2][3] имеет значение 12.

29. Массивы строк

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

char str_array [30] [80];

Доступ к отдельным строкам очень прост – необходимо написать имя массива только с левым индексом. Например:

gets(str_array[2]);

Данная строка эквивалентна

gets(&str_array[2][0]);

но предыдущий вариант более типичен при написании профессиональных программ.

Рассмотрим программу, использующую массив как основу простейшего текстового редактора.

#include <stdio.h>

#define MAX 100

#define LEN 255

char text[MAX][LEN];

/* простейший текстовый редактор*/

int main()

{

register int t, i, j;

for(t=0; t<MAX; t++) {

printf("%d: ", t);

gets(text[t]);

if(!*text[t]) break;/*выход по пустой строке*/

}

/*посимвольный вывод текста*/

for(i=0; i<t; i++) {

for(j=0; text[i][j]; j++)

printf("%c",text[i][j]);

printf("%c", '\n');

}

getchar();

return 0;

}

Данная программа осуществляет ввод текста, пока не встретится пустая строка. Затем она отображает каждую строку. В целях иллюстрации она выводит текст посимвольно, с использованием правого индекса.

30. Многомерные массивы

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

тип имя [ размерN ]…[ размер2 ][ размер1 ];

31. Индексация с помощью указателей

Указатели и массивы очень тесно связаны между собой. Имя массива без индекса – это указатель на первый элемент массива. Пусть имеется массив

char p[10];

тогда следующие значения идентичны:

p

&p[0]

Выражение

p == &p[0]

выдаёт истину, поскольку адрес первого элемента и адрес массива совпадают.

Справедливо и обратное. Любой указатель может быть проиндексирован, как будто это массив. Например,

int *p, i[10];

p = i;

p[5] = 1000;

*(p+5) = 1000;

Оба оператора присваивания помещают значение 1000 в шестой элемент i. Первый оператор использует индексацию с р, а второй – арифметику указателей. Результат одинаков.

Данные способы индексации совершенно справедливы для массивов размерности 2 и более. Предположим, что а – это целочисленный массив 10 на 10. Тогда нижеприведенные операторы эквивалентны:

(int *)a

&a[0][0]
К элементу 0, 4 массива а можно обратиться или с помощью индексации массива – a[0][4], или с помощью указателя - *((int *)a+4). Аналогично к элементу 1, 2 можно обратиться или с помощью индексации массива – a[1][2], или с помощью указателя - *((int *)a+12).

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

Двумерные массивы подобны массивам указателей на строки. Поэтому использование отдельных указателей является одним из лёгких способов доступа к элементам двумерного массива.

Следующая функция выводит содержимое указанной строки глобального целочисленного массива num:

int num[10][10];

…

void pr_row(int j)

{

int *p, t;

p = num[j];

for(t=0; t<10; ++t) printf(“%d “, *(p+t));

}

Данный код может быть обобщён, если передавать в качестве аргумента номер строки, длину строки и указатель на первый элемент массива:

void pr_row(int j, int row_dimension, int *p)

{

int t;

p = p + (j * row_dimension);

for(t=0; t< row_dimension; ++t)

printf(“%d “, *(p+t));

}

32. Размещение массивов

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

int *p;

try{ p = new int[100]; }

catch(…){ puts(“Cannot allocate”); exit(1); }

В дальнейшем доступ осуществляется, как при помощи указателя. Например, доступ к 6 элементу:

p[5]

Для освобождения памяти необходимо пользоваться оператором delete.

delete [] p;

Оператор delete должен освобождать память, только ранее выделенную оператором new, иначе это может привести к краху программы.

33. Функции

Функции – это базовые блоки С, в которых выполняются все операции. Стандартный вид функций следующий:

спецификатор_типа имя_функции (список параметров)

{

тело функции

}

Спецификатор_типа определяет тип возвращаемого функцией значения с помощью оператора return. Это может быть любой допустимый тип. Список параметров – это разделённый запятыми список переменных, получающих значения аргументов при вызове функции. Функция может быть без параметров и в таком случае список параметров состоит из ключевого слова void.

34. Оператор return

Оператор return имеет два назначения. Во-первых, немедленный выход из функции. То есть он осуществляет выход в вызывающий функцию код. Во-вторых, может использоваться для возврата значения. Рассмотрим оба назначения.

Выход из функции

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

 

void pr_reverse(char *s)

{

register int t;

 

for(t=strlen(s)-1; t>-1; t--) printf(“%c”, s[t]);

}

 

После отображения строки функция ничего не делает, поэтому управление передаётся вызвавшему её коду.

Большинство функций использует оператор return для окончания исполнения с целью возвращения значения или упрощения кода функции и увеличения его эффективности путём создания нескольких точек выхода. Например, функция, показанная ниже, возвращает или индекс первого появления подстроки, указываемой в s2, в строке, указываемой в s1, или -1, если не обнаружено совпадений:

 

int find_substr(char *s1, char *s2)

{

register int t;

char *p, *p2;

for(t=0; s1[t]; t++) {

p = &s1[t];

p2 = s2;

while(*p2 && *p2==*p) {

p++;

p2++;

}

if(!*p2) return t;

}

return -1;

}

Надо обратить внимание, как два оператора return упрощают функцию.

Возвращаемые значения

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

x = power(y);

if(max(x, y) > 100) printf(“greater”);

for(ch=getchar(); isdigit(ch);) …;

Функция не может стоять с левой стороны оператора присваивания. Оператор типа

swap(x, y) = 100;

неправилен. Компилятор выдаст ошибку.

Если функция определена как void, она не может использоваться в выражениях. Предположим, что f() объявлена как void. Следующие операторы не будут компилироваться:

int t;

t = f();

f() + f();

Если не указано, чему присваивается возвращаемое значение, то оно просто отбрасывается. Рассмотрим следующую программу, использующую mul():

#include <stdio.h>

int mul(int a, int b);

int main(void)

{

int x, y, z;

x = 10; y = 20;

z = mul(x, y); /* 1 */

printf(“%d “, mul(x, y)); /* 2 */

mul(x, y); /* 3 */

return 0;

}

int mul(int a, int b)

{

return a*b;

}

Строка 1 присваивает возвращаемое функцией mul() значение переменной z. В строке 2 возвращаемое значение используется функцией printf(). В строке 3 возвращаемое значение теряется

35. Правила видимости для функций

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

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

Все функции в С находятся на одном уровне видимости. То есть невозможно определить функцию в функции.

36. Аргументы функции. Передача по значению и передача по указателю

Аргументы функции

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