Как делать си

и получим 074 для j.
Другой важной группой операторов являются унарные операторы, каждый из которых принимает только один операнд. Как унарный оператор, амперсанд & получает адрес переменной.

Если p является указателем на целое число, а i является целым числом, оператор

вычисляет адрес i и сохраняет его в переменной p.
Противоположным взятию адреса является оператор, который принимает указатель в качестве входных данных и вычисляет значение, находящееся по этому адресу. Если мы только что присвоили адрес i указателю p, тогда *p имеет то же значение, что и i.

Другими словами, в качестве унарного оператора за звездочкой следует указатель (или
выражение, дающее указатель), и возвращает значение элемента, на который указывает. Если i имеет значение 6, то оператор

j = *р;

присвоит j число 6.
Оператор! (восклицательный знак – оператор отрицания) возвращает 0, если его операнд отличен от нуля, и 1, если его оператор равен 0.

Он в основном используется в операторах if, например

if (!x) k=0;

проверяет значение х. Если x равен нулю (false), то k присваивается значение 0. В действительности, оператор! отменяет условие, следующее за ним, так же, как оператор not в Паскаль.

Оператор ~ является побитовым оператором дополнения. Каждый 0 в своем операнде
становится 1, а каждый 1 становится 0.

Оператор sizeof сообщает размер его операнда в байтах. Применительно к
массиву из 20 целых чисел a на компьютере с 2-байтовыми целыми числами, например sizeof a будет иметь значение 40.

Последняя группа операторов — это операторы увеличения и уменьшения.

означает увеличение р. На сколько увеличится p, зависит от его типа.
Целые числа или символы увеличиваются на 1, но указатели увеличиваются на
размер объекта, на который указывает Таким образом, если а является массивом структур, а р указатель на одну из этих структур, и мы пишем

чтобы заставить p указать на одну из структур в массиве, то после увеличения p
будет указывать на a[4] независимо от того, насколько велики структуры. Оператор

аналогичен оператору p++, за исключением того, что он уменьшает, а не увеличивает значение операнда.

n = k++;

где обе переменные являются целыми числами, исходное значение k присваивается n и
только после этого происходит увеличение k. В операторе

n = ++ k;

сначала увеличивается k, затем его новое значение сохраняется в n.

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

Последний оператор – это? (знак вопроса), который выбирает одну из двух альтернатив
разделеных двоеточием. Например, оператор,

i = (x < y ? 6 : k + 1);

сравнивает х с у. Если x меньше y, тогда i получает значение 6; в противном случае переменная i получает значение k + 1. Скобки не обязательны.

А.6. Структура программы

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

Допускается объявлять переменные вне процедур, например, в начале файла перед первым объявлением процедуры. Эти переменные являются глобальными, и могут использоваться в любой процедуре во всей программе, если только ключевое слово static не предшествует объявлению. В этом случае эти переменные нельзя использовать в другом файле. Те же правила применяются к процедурам. Переменные, объявленные внутри процедуры, являются локальными для процедуры.
Процедура может обращаться к целочисленной переменной v, объявленной в другом файле (при условии, что переменная не является статической), объявляя ее у себя внешней:

extern int v;

Каждая глобальная переменная должна быть объявленным ровно один раз без атрибута extern, чтобы выделить память под нее.

Переменные могут быть инициализированы при объявлении:

int size = 100;

Массивы и структуры также могут быть инициализированы. Глобальные переменные, которые не инициализированы явно, получают значение по умолчанию, равное нулю.

А.7. Препроцессор Cи

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

1. Включение файлов.
2. Определение и замена макросов.
3. Условная компиляция.

Все директивы препроцессора начинаются со знака числа (#) в 1-ом столбце.
Когда директива вида

#include "prog.h"

встречается препроцессором, он включает файл prog.h, строка за строкой, в
программу, которая будет передана компилятору. Когда директива #include написана как

#include

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

#define BLOCK_SIZE 1024

определяет макрос BLOCK_SIZE и присваивает ему значение 1024. С этого момента
каждое вхождение строки из 10 символов «BLOCK_SIZE» в файле будет
заменяться 4-символьной строкой «1024» до того, как компилятор увидит файл с программой. По соглашению имена макросов пишутся в верхнем регистре. Макросы могут иметь параметры, но на практике немногие это делают.

Третья особенность препроцессора — условная компиляция. В MINIX есть несколько
мест, где код написан специально для процессора 8088, и этот код не должен включаться при компиляции для другого процессора. Эти разделы выглядят как так:

#ifdef i8088 #endif

Если символ i8088 определен, то операторы между двумя директивами препроцессора #ifdef i8088 и #endif включаются в выходные данные препроцессора; в противном случае они пропускаются. Вызывая компилятор с командой

cc -c -Di8088 prog.c

или включив в программу заявление

#define i8088

мы определяем символ i8088, поэтому весь зависимый код для 8088 быть включен. По мере развития MINIX он может приобрести специальный код для 68000s и других процессоров, которые будут обрабатываться также.

В качестве примера того, как работает препроцессор, рассмотрим программу рис. A-7 (a). Она включает в себя один файл prog.h, содержимое которого выглядит следующим образом:

int x; #define MAXAELEMENTS 100 

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

cc -E -Di8088 prog.c

После того, как файл прошел через препроцессор, вывод будет таким, как показано на Рис. A-7 (b).

Именно этот вывод, а не исходный файл, дается как вход в Cи компилятор.

#include prog.h int x; main () main (); < < int a[MAX_ELEMENTS]; int a [100]; х = 4; х = 4; a[x] = 6; а[х] = 6; #ifdef i8088 printf("8088. a[x]:% d\n", a[x]); printf ("8088. a[x]:% d\n", a[x]); #endif >#ifdef m68000 printf ("68000. x=%d\n", x); #endif > (а) (b) Рис. А-7. (a) Содержание файла prog.c. (b) Выход препроцессора.

Обратите внимание, что препроцессор выполнил свою работу и удалил все строки, начинающиеся со знаком #. Если компилятор был бы вызван так

cc -c -Dm68000 prog.c

то была бы включена другая печать. Если бы он был вызван вот так:

cc -c prog.c

то ни одна печать не была бы включена. (Читатель может поразмышлять о том, что случилось бы, если бы компилятор вызывался с обоими флагами -Dflags.)

А.8. Идиомы

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

while (n--) *p++ = *q++;

Переменные p и q обычно являются символьными указателями, а n является счетчиком. Цикл копирует n-символьную строку из места, на которое указывает q, в место, на которое указывает р. На каждой итерации цикла счетчик уменьшается, пока он не доходит до 0, и каждый из указателей увеличивается, поэтому они последовательно указывают на ячейки памяти с более высоким номером.

Еще одна распространенная конструкция:

for (i = 0; i < N; i++) a[i] = 0;

которая устанавливает первые N элементов а в 0. Альтернативный способ написания этого цикла выглядит так:

for (p = &a[0]; p < &a[N]; p++) *p = 0;

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

Операторы присвоения могут появляться в неожиданных местах. Например,

if (a = f (x)) < оператор >;

сначала вызывает функцию f, затем присваивает результат вызова функции a и
наконец, проверяет, является ли оно истинным (ненулевым) или ложным (нулевым). Если а не равно нулю, то условие выполнено. Оператор

if (a = b) < оператор >;

также сначало значение переменной b переменной a, а затем проверяет a, не является ли значение ненулевым. И этот оператор полностью отличается от

if (a == b) < оператор >;

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

Послесловие

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

• Open source
• Системное программирование
• C
• История IT
• Изучение языков

Арифметические действия в языке Си

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

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

Основные арифметические операторы языка Си.

+ оператор сложения
- оператор вычитания
* оператор умножения
% оператор взятия остатка от деления
/ оператор деления

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

#include int main(void)

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

Рис.5 Использование арифметических действий в Си.

Всё чётко и понятно. Никаких неожиданностей. А теперь попробуем получить частное двух чисел. Т.к. результат должен получиться 3.5, то res объявим как float .

#include int main(void)< int a=7, b=2; float res; res = a/b; printf("%d / %d = %f\n",a,b,res); return 0; >

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

При делении значение целого типа на значение целого типа результат тоже получается целого типа.

Так уж устроен язык Си. Поэкспериментируйте, попробуйте любые другие целые числа.

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

Пример: Как получить результат целочисленного деления

7/2 = 3.5 → 3
11/3 = 3.66 → 3
2/5 = 0.4 → 0

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

Посмотрим на нашем примере:

#include int main(void)< int a=7, b=2; float res; res = (float)a/b; printf("%d / %d = %f\n",a,b,res); return 0; >

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

Явное преобразование (приведение) типа.

Если какое-то значение нужно привести к другому типу, нужно перед этим значением в скобках написать название требуемого типа.

Листинг 4. Примеры явного преобразования типа

int a=7, b; float g= 9.81,v; b = (int) g; //приводим значение 9.81 к типу int, получим 9 v= (float)a; // приводим значение 7 к типу float, получим 7.0

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

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

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

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

Рис.2 Деление, целочисленное деление и остаток от деления.

Сохрани в закладки или поддержи проект.

Практика

Решите предложенные задачи:

Для удобства работы сразу переходите в полноэкранный режим

Исследовательские задачи для хакеров

1. Подумайте и приведите примеры, когда обычное деление не имеет смысла. Например, деление трёх лицензионных ключей от программы между двумя людьми. Зачем кому-то нужна половина лицензионного ключа? (если, конечно, он не занимается reverse engineering).
2. Что происходит при делении на ноль в вашей системе?

Дополнительные материалы

1. Дополнительные задачи с автоматической проверкой решения из курса " Введение в программирование (C++) " от компании Яндекс. не беспокойтесь, что курс по С++. Удаляйте заготовку из поля для решения и спокойно вставляйте код на Си. Проверяющая система его будет нормально воспринимать.

Операторы цикла в языке Си

Рассмотрим третью алгоритмическую структуру — цикл.
Циклом называется блок кода, который для решения задачи требуется повторить несколько раз.

Каждый цикл состоит из

• блока проверки условия повторения цикла
• тела цикла

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

В языке Си следующие виды циклов:

• while — цикл с предусловием;
• do…while — цикл с постусловием;
• for — параметрический цикл (цикл с заданным числом повторений).

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

Общая форма записи

while (Условие)
БлокОпераций;
>

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

Пример на Си : Посчитать сумму чисел от 1 до введенного k

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int main() int k; // объявляем целую переменную key
int i = 1;
int sum = 0; // начальное значение суммы равно 0
printf( "k = " );
scanf( "%d" , &k); // вводим значение переменной k
while (i sum = sum + i; // добавляем значение i к сумме
i++; // увеличиваем i на 1
>
printf( "sum = %d\n" , sum); // вывод значения суммы
getchar(); getchar();
return 0;
>

Результат выполнения

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

Пример бесконечного цикла

while (1)
БлокОпераций;
>

while — цикл с предусловием, поэтому вполне возможно, что тело цикла не будет выполнено ни разу если в момент первой проверки проверяемое условие окажется ложным.

Например, если в приведенном выше коде программы ввести k=-1, то получим результат

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

Общая форма записи

do <
БлокОпераций;
> while (Условие);

Цикл do. while — это цикл с постусловием, где истинность выражения, проверяющего Условие проверяется после выполнения Блока Операций , заключенного в фигурные скобки. Тело цикла выполняется до тех пор, пока выражение, проверяющее Условие , не станет ложным, то есть тело цикла с постусловием выполнится хотя бы один раз.

Использовать цикл do. while лучше в тех случаях, когда должна быть выполнена хотя бы одна итерация, либо когда инициализация объектов, участвующих в проверке условия, происходит внутри тела цикла.

Пример на Си . Проверка, что пользователь ввел число от 0 до 10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
#include // для использования функции system()
int main() int num; // объявляем целую переменную для числа
system( "chcp 1251" ); // переходим на русский язык в консоли
system( "cls" ); // очищаем экран
do printf( "Введите число от 0 до 10: " ); // приглашение пользователю
scanf( "%d" , &num); // ввод числа
> while ((num < 0) || (num >10)); // повторяем цикл пока num10
printf( "Вы ввели число %d" , num); // выводим введенное значение num - от 0 до 10
getchar(); getchar();
return 0;
>

Результат выполнения:

Параметрический цикл for

Общая форма записи

for (Инициализация; Условие; Модификация)
БлокОпераций;
>

for — параметрический цикл (цикл с фиксированным числом повторений). Для организации такого цикла необходимо осуществить три операции:

• Инициализация - присваивание параметру цикла начального значения;
• Условие - проверка условия повторения цикла, чаще всего - сравнение величины параметра с некоторым граничным значением;
• Модификация - изменение значения параметра для следующего прохождения тела цикла.

Эти три операции записываются в скобках и разделяются точкой с запятой ; ;. Как правило, параметром цикла является целочисленная переменная.
Инициализация параметра осуществляется только один раз — когда цикл for начинает выполняться.
Проверка Условия повторения цикла осуществляется перед каждым возможным выполнением тела цикла. Когда выражение, проверяющее Условие становится ложным (равным нулю), цикл завершается. Модификация параметра осуществляется в конце каждого выполнения тела цикла. Параметр может как увеличиваться, так и уменьшаться.

Пример на Си : Посчитать сумму чисел от 1 до введенного k

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int main() int k; // объявляем целую переменную key
int sum = 0; // начальное значение суммы равно 0
printf( "k = " );
scanf( "%d" , &k); // вводим значение переменной k
for ( int i=1; i sum = sum + i; // добавляем значение i к сумме
>
printf( "sum = %d\n" , sum); // вывод значения суммы
getchar(); getchar();
return 0;
>

Результат выполнения

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int main() int k; // объявляем целую переменную key
int sum = 0; // начальное значение суммы равно 0
printf( "k = " );
scanf( "%d" , &k); // вводим значение переменной k
int i=1;
for (; i sum = sum + i; // добавляем значение i к сумме
>
printf( "sum = %d\n" , sum); // вывод значения суммы
getchar(); getchar();
return 0;
>

Параметры, находящиеся в выражениях в заголовке цикла можно изменить при выполнении операции в теле цикла, например

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int main() int k; // объявляем целую переменную key
int sum = 0; // начальное значение суммы равно 0
printf( "k = " );
scanf( "%d" , &k); // вводим значение переменной k
for ( int i=1; i sum = sum + i; // добавляем значение i к сумме
i++; // добавляем 1 к значению i

>
printf( "sum = %d\n" , sum); // вывод значения суммы
getchar(); getchar();
return 0;
>

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

1
2
3
4
5
6
7
8
9
10
11
12
13

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int main() int k; // объявляем целую переменную key
printf( "k = " );
scanf( "%d" , &k); // вводим значение переменной k
for ( int i=1, j=2; i < // (i от 1 до k с шагом 1) и (j от 2 с шагом 2)
printf( "i = %d j = %d\n" , i, j); // выводим значения i и j
>
getchar(); getchar();
return 0;
>

Результат выполнения

Вложенные циклы

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

for (i = 0; i <
for (j = 0; j ; // блок операций Цикла2
>
// блок операций Цикла1;
>

Пример : Вывести числа от 0 до 99, по 10 в каждой строке

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int main() for ( int i=0; i <
for ( int j = 0; j < 10; j++) // цикл для единиц
printf( "%2d " , i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел
>
printf( "\n" ); // во внешнем цикле переводим строку
>
getchar(); // scanf() не использовался,
return 0; // поэтому консоль можно удержать одним вызовом getchar()
>

Результат выполнения

Рекомендации по выбору цикла

При выборе цикла необходимо оценить необходимость проверки условия при входе в цикл или по завершении прохождения цикла.
Цикл с постусловием удобно применять в случаях, когда для проверки условия требуется вычислить значение выражения, которое затем будет размещено в теле цикла (см. выше пример ввода числа от 0 до 10).
Цикл c предусловием используется в случае если все переменные, участвующие в выражении, проверяющем условие, проинициализированы заранее, но точное число повторений цикла неизвестно или предполагается сложная модификация переменных, участвующих в формировании условия повторения цикла.
Если цикл ориентирован на работу с параметром, для которого заранее известно число повторений и шаг изменения, то более предпочтительным является параметрический цикл. Очень удобно использовать параметрический цикл при работе с массивами для перебора элементов.

Операторы прерывания и продолжения цикла break и continue

В теле любого цикла можно использовать операторы прерывания цикла - break и продолжения цикла - continue .

Оператор break позволяет выйти из цикла, не завершая его.
Оператор continue позволяет пропустить часть операторов тела цикла и начать новую итерацию.

Пример на Си : Вывести числа от 0 до 99 ниже главной диагонали

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int main() for ( int i=0; i <
for ( int j = 0; j < 10; j++) // цикл для единиц
if (j > i) // если число единиц больше числа десятков в числе
break ; // выходим из вложенного цикла и переходим к новой строке
printf( "%2d " , i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел
>
printf( "\n" ); // во внешнем цикле переводим строку
>
getchar(); // scanf() не использовался,
return 0; // поэтому консоль можно удержать одним вызовом getchar()
>

Результат выполнения

Пример на Си : Вывести числа от 0 до 99 исключая числа, оканчивающиеся на 5 или 8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int main() for ( int i=0; i <
for ( int j = 0; j < 10; j++) // цикл для единиц
if ((j == 5) || (j == 8)) // если число единиц в числе равно 5 или 8,
continue; // переходим к следующей итерации цикла
printf( "%2d " , i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел
>
printf( "\n" ); // во внешнем цикле переводим строку
>
getchar(); // scanf() не использовался,
return 0; // поэтому консоль можно удержать одним вызовом getchar()
>

Результат выполнения

При вложенных циклах действия операторов break и continue распространяется только на самую внутреннюю структуру, в которой они содержатся.

Оператор безусловного перехода goto

Общая форма записи

goto Метка;
. . .
Метка : Операция;

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

Пример на Си : Вывести все целые числа от 5 до 0.

1
2
3
4
5
6
7
8
9
10
11
12

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int main() int k = 5;
M1: if (k < 0) // если kgoto M2; // переходим на метку M2 (выходим из программы)
printf( "%d " , k); // выводим значение k
k--; // уменьшаем k на 1
goto M1; // переходим на метку M1 (повторяем операции выше)
M2: getchar();
return 0;
>

Результат выполнения

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

Комментариев к записи: 26

Функции в языке Си

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

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

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

Определение функции

Каждая функция в языке Си должна быть определена, то есть должны быть указаны:

• тип возвращаемого значения;
• имя функции;
• информация о формальных аргументах;
• тело функции.

Определение функции имеет следующий синтаксис:

ТипВозвращаемогоЗначения ИмяФункции(СписокФормальныхАргументов)
ТелоФункции;
.
return (ВозвращаемоеЗначение);
>

Пример : Функция сложения двух вещественных чисел

float function( float x, float z)
float y;
y=x+z;
return (y);
>

В указанном примере возвращаемое значение имеет тип float . В качестве возвращаемого значения в вызывающую функцию передается значение переменной y . Формальными аргументами являются значения переменных x и z .

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

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

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

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

Разбиение программ на функции дает следующие преимущества:

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

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

Вызов функции

Общий вид вызова функции

Переменная = ИмяФункции(СписокФактическихАргументов);

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

Возврат в вызывающую функцию

По окончании выполнения вызываемой функции осуществляется возврат значения в точку ее вызова. Это значение присваивается переменной, тип которой должен соответствовать типу возвращаемого значения функции. Функция может передать в вызывающую программу только одно значение. Для передачи возвращаемого значения в вызывающую функцию используется оператор return в одной из форм:

return (ВозвращаемоеЗначение);
return ВозвращаемоеЗначение;

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

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

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

Пример : Посчитать сумму двух чисел.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
// Функция вычисления суммы двух чисел
int sum( int x, int y) // в функцию передаются два целых числа
int k = x + y; // вычисляем сумму чисел и сохраняем в k
return k; // возвращаем значение k
>
int main()
int a, r; // описание двух целых переменных
printf( "a= " );
scanf( "%d" , &a); // вводим a
r = sum(a, 5); // вызов функции: x=a, y=5
printf( "%d + 5 = %d" , a, r); // вывод: a + 5 = r
getchar(); getchar(); // мы использовали scanf(),
return 0; // поэтому getchar() вызываем дважжы
>

Результат выполнения

В языке Си нельзя определять одну функцию внутри другой.

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int sum( int , int ); // сигнатура
int main()
int a, r;
printf( "a= " );
scanf( "%d" , &a);
r = sum(a, 5); // вызов функции: x=a, y=5
printf( "%d + 5 = %d" , a, r);
getchar(); getchar();
return 0;
>
int sum( int x, int y) // семантика
int k;
k = x + y;
return (k);
>

Рекурсивные функции

Функция, которая вызывает сама себя, называется рекурсивной функцией .

Рекурсия — вызов функции из самой функции.

Пример рекурсивной функции — функция вычисления факториала.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
int fact( int num) // вычисление факториала числа num
if (num else return num*fact(num - 1); // рекурсивный вызов для числа на 1 меньше
>
// Главная функция
int main()
int a, r;
printf( "a= " );
scanf( "%d" , &a);
r = fact(a); // вызов функции: num=a
printf( "%d! = %d" , a, r);
getchar(); getchar();
return 0;
>

Результат выполнения

Более подробно рекурсивные функции рассмотрены в этой статье.

Математические функции

Математические функции хранятся в стандартной библиотеке math.h . Аргументы большинства математических функций имеют тип double . Возвращаемое значение также имеет тип double .
Углы в тригонометрических функциях задаются в радианах.

Основные математические функции стандартной библиотеки.

Особенности использования функций в языке C++ рассмотрены в этой статье.

Комментариев к записи: 107

Помогите решить мою проблему, я новичок в программировании и не могу понять почему у меня подчеркивает FILE* st

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

struct FIO
char f[20];
char i[20];
char o[20];
int ng;
char bg[1];
int s;
>;
typedef struct FIO fio;

int main()
system( "chcp 1251 > null" );
int count = -1, probels = 0, n = 0; //создали переменную для подсчета строк
int * num = calloc(0, sizeof ( int )); //массив, записывающий номера правильных строк
FILE* st = fopen( "st.txt", "r" ); //открыли файл на чтение
while (!feof(st)) //проверяеем строки
char * str = calloc(100, sizeof ( char ));
fgets(str, 100, st); //считываем из файла
count++; //счетчик строк
//Проверяем символы строки
for ( int i = 0; i < strlen(str) - 1; i++) //strlen(str) cчитает вместе с \n ПОЭТОМУ ВАЖНО -1
if (str[i] == ' ')
probels++; //подсчет пробелов в строке (должно быть 5)
>
>
if (probels == 5) //записываем номер строки в массив
n++; //счетчик элементов массива
num = realloc(num, n * sizeof ( int ));
num[n - 1] = count; // n-1 = 0
>
free(str); //очищаем буфер
probels = 0;
>
fclose(st);
fio* array = calloc(n, sizeof (fio)); //выделяем память под структуру правильных строк (n - колич правильных строк)
int s = 0; // для массива num
st = fopen( "st.txt", "r" );
for ( int t = 0, s = 0; t if (t == num[s]) //номер строки = номеру правильной строки
fscanf(st, "%s %s %s %d %s %d\n" , array[s].f, array[s].i, array[s].o, &array[s].ng, array[s].bg, &array[s].s);
s++;
>
else
char * str = calloc(100, sizeof ( char ));
fgets(str, 100, st); //считываем из файла
>
>
fclose(st);
for ( int i = 0; i < n; i++)
printf( "%s %s %s %d %s %d\n" , array[i].f, array[i].i, array[i].o, array[i].ng, array[i].bg, array[i].s);
>
return 0;
>

#include
#include
#include

Добрый вечер! При изучении языка Си в колледже преподаватель задал такую задачку: по введенным в текстовый файл трем координатам, которые нужно считать из файла в консоль, необходимо определить существует ли данный треугольник, определить длину сторон, периметр и площадь, данную информацию нужно вывести в консоль и записать в другой текстовый файл. Задачу я решила, но одно из требований - нужно обязательно использовать модальность, то бишь выделить функции. Это у меня не получается от слова совсем((. Обидно, что задача решена, но я не могу вынести ничего в функции, не знаю какие значения в них передавать, мне кажется, что данный код вообще неделим и прекрасен таким какой он есть. Но преподаватель другого мнения(

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include
#define PATH "1.txt"

struct coordinata
float x1;
float y1;
float x2;
float y2;
float x3;
float y3;

>;
typedef struct coordinata treug;

int main( void )
system( "chcp 1251>nul" );
treug* buffer = malloc(1);
FILE* mf = fopen(PATH, "r" );
char * str = calloc(100, 4);
int count = 0;
for (size_t i = 0; !feof(mf); i++) //читаем строки из файла и записываем в экземпляр структуры
buffer = realloc(buffer, sizeof (treug) * (i + 1));
fgets(str, 100, mf);
sscanf(str, "%f%f%f%f%f%f" , &buffer[i].x1, &buffer[i].y1, &buffer[i].x2, &buffer[i].y2, &buffer[i].x3, &buffer[i].y3);
count++;
>
int n = count;
free(str);
fclose(mf);
FILE* myfile = fopen( "2.txt", "w" );
int status = 0;
float a, b, c,P,S,p=0;
float d1, d2, d3, d4, d5, d6;
for (size_t i = 0; i < n; i++) //выводим экземпляр структуры
printf( "\nКоординаты %d треугольника:\n" , i + 1);
printf( "%f %f %f %f %f %f\n" , buffer[i].x1, buffer[i].y1, buffer[i].x2, buffer[i].y2, buffer[i].x3, buffer[i].y3);

a = sqrt(pow((buffer[i].x2 - buffer[i].x1),2) + pow((buffer[i].y2 - buffer[i].y1), 2));
b = sqrt(pow((buffer[i].x3 - buffer[i].x2),2) + pow((buffer[i].y3 - buffer[i].y2), 2));
c = sqrt(pow((buffer[i].x1 - buffer[i].x3),2) + pow((buffer[i].y1 - buffer[i].y3), 2));
P = a + b + c;
p = P / 2;
S = sqrt(p * (p - a) * (p - b) * (p - c));
if (a + b > c && a + c > b && c + b > a && a > 0 && b > 0 && c > 0)
printf( "Данный треугольник существует\n" );
printf( "Сторона а = %f, сторона b = %f, сторона c = %f,\nПериметр треугольника равен %f\nПлощадь треугольника равна %f\n" ,a,b,c, P,S);
fprintf(myfile, "Сторона а = %f, сторона b = %f, сторона c = %f,\nПериметр треугольника равен %f\nПлощадь треугольника равна %f\n" , a, b, c, P, S);
fprintf(myfile, " % f % f % f % f % f % f\n" , buffer[i].x1, buffer[i].y1, buffer[i].x2, buffer[i].y2, buffer[i].x3, buffer[i].y3);
>
else printf( "Данный треугольник не существует" );