/*АРГУМЕНТЫ ФУНКЦИИ*/
/*ФУНКЦИЯ - это самодостаточная единица кода программы, спроектировання для выполнения отдельной задачи.
Структура функции и способы ее возможного использования определяюяются синтаксическими правилами.
Функция, подпрограммы, процедуры.
Функции избавляют от многократного написания кода.
ФУНКЦИЯ - "черный ящик" в терминах информации, которая в него поступает (его ввода), и значение или действия
которое он производит (его вывод). Вас не забоит о том что происходит внутри черного ящика, если вы только вы сами
не разработчик функций*/
/*Объявление аргумента создает ПЕРЕМЕННУЮ, которая называется ФОРМАЛЬНЫМ АРГУМЕНТОМ или ФОРМАЛЬНЫМ ПАРАМЕТРОМ*/
/*ПРОТОТИП - ЭТО ОБЪЯВЛЕНИЕ ФУНКЦИИ, В КОТОРОМ ДАЕТСЯ ОПИСАНИЕ ВОЗВРАЩАЕМОГО ЗНАЧЕНИЯ ФУНЦИИ И ВСЕХ ЕЕ АРГУМЕНТОВ*/
/*АРГУМЕНТ - ЭЛЕМЕНТЫ ИНФОРМАЦИИ, ПЕРЕДАВАЕМОЙ ФУНКЦИИ.
ФУНКЦИИ printf() и scanf() не ограничены конкретным количеством аргументов.
Аргументы отделяются друг от друга запятыми. */
-----------------------------------------------------------------------------------------------------------------
/*ЧТО НУЖНО ЗНАТЬ О ФУНКЦИЯХ
- КАК ИХ ПРАВИЛЬНО ОПРЕДЕЛЯТЬ
- ВЫЗЫВАТЬ
- ОБЕСПЕЧИВАТЬ ВЗАИМОДЕЙСТВИЕ МЕЖДУ НИМИ*/
#include <stdio.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
#include <string.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Для strlen()
#define NAME "GIGATHINK, INC."
//СИМВОЛИЧЕСКАЯ КОНСТАНАТА
#define ADDRESS "101 Megabuck Plaza"
//СИМВОЛИЧЕСКАЯ КОНСТАНАТА
#define PLACE "megapolis, CA 94904"
#define WIDTH 40
#define SPACE '*'
/*ОПРЕДЕЛЕНИЕ ФУНКЦИИ*/
void show_n_char (char ch, int num); //ОПРЕДЕЛЕНИЕ ФУНКЦИИ show_n_char() (разновидность функции), первое void - говорит, что функция show_n_char() не возвращает никакого
//значения, функция принимает два аргумента (ФОРМАЛЬНЫЕ ПАРАМЕТРЫ - являются ЛОКАЛЬНЫМИ ПЕРЕМЕННЫМИ определены внутри ф-ции)->
//переменная с типом данных строка ch, переменная типом данных целые числа int
int main(void)
//ОБЯВЛЕНИЕ ФУНКЦИИ с именем main() - главная функция, каркас программы на С
{
int spaces;
//ОБЪЯВЛЕНИЕ ПЕРЕМЕННОЙ с именем spaces, тип данных -> целые числа
show_n_char('*', WIDTH);
//оператор вызова функции, ИСПОЛЬЗОВАНИЕ КОНСТАНТ В КАЧЕСТВЕ АРГУМЕНТОВ
putchar("\n");
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем putchar() имеет один аргумент -> управляющая строка
show_n_char(SPACE, 12);
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ, использование констант в качестве аргументов
printf("%s\n", NAME);
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет два аргумента -> управляющая строка "" и список переменных
spaces = (WIDHT - strlen(ADDRESS))/2; //позволить программе вычислить, сколько пробелов нужно вывести
show_n_char(SPACE, spaces);
//оператор вызова функции, ИСПОЛЬЗОВАНИЕ ПЕРЕМЕННОЙ В КАЧЕСТВЕ АРГУМЕНТОВ
printf("%s\n", ADDRESS);
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет два аргумента -> управляющая строка "" и список переменных
show_n_char(SPACE, (WIDTH - strlen(PLACE)) / 2);
//Оператор вызова функции, ИСПОЛЬЗОВАНИЕ ВЫРАЖЕНИЯ В КАЧЕСТВЕ АРГУМЕНТА
printf("%s\n", PLACE);
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет два аргумента -> управляющая строка "" и список переменных
show_n_char('*', WIDTH);
//оператор вызова функции, ИСПОЛЬЗОВАНИЕ КОНСТАНТ В КАЧЕСТВЕ АРГУМЕНТОВ
putchar("\n");
return 0;
}
/*ОПРЕДЕЛЕНИЕ ФУНКЦИИ show_n_char()*/
void show_n_char(char ch, int num)
//ОПРЕДЕЛЕНИЕ (ЧТО ДЕЛАЕТ ФУНКЦИЯ) - ВЫВОДИТ '*' НА ЭКРАН, первое void - говорит, что функция show_n_char()
//не возвращает никакого значения, функция принимает аргументы show_n_char(char ch, int num)
{
int count;
//ИНИЦИАЛИЗАЦИЯ ПЕРЕМЕННОЙ c имененм count, тип данных целочисленный Данная переменная ЛОКАЛЬНАЯ
for (count = 1; count <= num; count++)
//ЦИКЛ. ИНИЦИАЛИЗАЦИЯ ЦИКЛА
putchar(ch);
//ОПЕРАТОР ФУНКЦИИ putchar();
}
ВЫВОД НА ЭКРАН
****************************************0
GIGATHINK, INC.
101 Megabuck Plaza
megapolis, CA 94904
****************************************0
void show_n_char (char ch, int num);
/*Эта строка обозначает, что функция show_n_char() принимает ДВА АРГУМЕНТА с именем ch -> тип char, и с именем num -> тип int
Эти переменные называются ФОРМАЛЬНЫМИ ПАРАМЕТРАМИ. Эти переменные определены ВНУТРИ ФУНКЦИИ, и ФОРМАЛЬНЫЕ ПАРАМЕТРЫ ЯВЛЯЮТСЯ ЛОКАЛЬНЫМИ
ПЕРЕМЕННЫМИ
КОГДА ФУНКЦИЯ ПРИНИМАЕТ АРГУМЕНТЫ, ПРОТОТИП ОТРАЖАЕТ ИХ КОЛИЧЕСТВО И ТИПЫ.
*/
show_n_char (SPACE, 12);
/*ФАКТИЧЕСКИЕ АРГУМЕНТЫ -> SPACE, 12
ФОРМАЛЬНЫЙ ПАРАМЕТР - это ПЕРЕМЕННАЯ в вызванной ФУНКЦИИ
ФАКТИЧЕСКИЙ АРГУМЕНТ - это конкретное значение, которое вызывающая функция присваивает переменной внутри вызванной функции. Фактическим
аргументом может может быть константа, переменная, выражение. Фактический аргумент представляет собой конкретное значение, которое
присваивается переменной, известной как формальный параметр.
*/
int main(void)
//Фактический аргумент - это значение 25, переданное main() в функцию space() и присвоенное number
{
space(25);
//Фактический аргумент - это выражение, указанное в круглых скобках при вызове функции.
}
void space (int number)
//Формальный параметр - это имя, созданное определением функции
{
//Формальный параметр - это переменная, объявленная в заголовке определения функции. Локальная переменная
}
double klink(int a, int b);
//ОПРЕДЕЛЕНИЕ ФУНКЦИИ, КОТОРАЯ ПРИНИМАЕТ ДВА АРГУМЕНТА int, НО ВОЗВРАЩАЕТ ЗНАЧЕНИЕ ТИПА double
double sqrt(double);
//ФУНКЦИЯ sqrt() ПРИНИМАЕТ ПАРАМЕТР ТИПА double и ВОЗВРАЩАЕТ ЗНАЧЕНИЕ ТИПА double
spaces = (WIDHT - strlen(ADDRESS))/2; //ОПЕРАТОР ПРИСВАИВАНИЯ - получить значение константы WIDTH, вычесть результат работы функции
//strlen(ADDRESS), разделить на два и ПРИСВОИТЬ РЕЗУЛЬТАТ ВЫЧИСЛЕНИЯ ПЕРЕМЕННОЙ spaces
int main(void) //имя функции (объявление функции с именем main
/*Программа на С состоит из одной или большего числа функций - базовых
модулей программ на С.
Круглые скобки показывают, что main() есть имя функции,
int - указывает на то, что функция main() ВОЗВРАЩАЕТ ЦЕЛОЕ ЧИСЛО,
void - говорит о том, что функция main() НЕ ПРИНИМАЕТ НИКАКИХ АРГУМЕНТОВ.
/*СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ определяет каким образом данные преобразутся в отображаемую форму*/
%d //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком
%f
//число с плавающей запятой, десятичное представление
%c
//одиночный символ
%s
//интерпретирует введенные данные как строку
/*ОПЕРАТОР ОБЪЯВЛЕНИЯ - назначает переменной имя и определяет тип данных, которые будут храниться в этой переменной.
Имя переменной может служить идентификатором.
ОПЕРАТОР ПРИСВАИВАНИЯ - устанавливает значение переменной или область хранения.
ОПЕРАТОР ВЫЗОВА ФУНКЦИИ - запускает на выполнение функцию с указанным именем.
ПЕРЕМЕННАЯ ЭТО ВСЕГО ЛИШЬ ИМЯ ВЫДЕЛЕННОЙ ЯЧЕЙКИ ПАМЯТИ КОМПЬЮТЕРА, КОТОРОЕ МОЖНО ИЗМЕНИТЬ, ПОЭТОМУ НАЗЫВАЕТСЯ ПЕРЕМЕННОЙ
КОНСТАНТА - ДАННЫЕ КОТОРЫЕ ХРАНЯТЬСЯ В ЯЧЕЙКЕ.*/
/*ЧТО НУЖНО ЗНАТЬ О ФУНКЦИЯХ
- КАК ИХ ПРАВИЛЬНО ОПРЕДЕЛЯТЬ
- ВЫЗЫВАТЬ
- ОБЕСПЕЧИВАТЬ ВЗАИМОДЕЙСТВИЕ МЕЖДУ НИМИ*/
------------------------------------------------------------------------------------------------------------------
//EXAMPLE
#include <stdio.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
#include <string.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Для strlen()
#define NAME "MY HOME"
//СИМВОЛИЧЕСКАЯ КОНСТАНАТА
#define ADDRESS "DOMODEDOVSKAYA"
//СИМВОЛИЧЕСКАЯ КОНСТАНАТА
#define PLACE "MOSCOW"
#define WIDTH 40
/*ОПРЕДЕЛЕНИЕ ФУНКЦИИ*/
void starbar (void);
//ОПРЕДЕЛЕНИЕ ФУНКЦИИ void starbar(void) (разновидность функции), первое void - говорит, что функция starbar() не возвращает никакого
//значения, функция не принимает аргументы
int main(void)
//ОБЯВЛЕНИЕ ФУНКЦИИ с именем main() - главная функция, каркас программы на С
{
starbar();
//ВЫЗОВ ФУНКЦИИ
printf("%s \n", NAME);
printf("%s \n", ADDRESS);
printf("%s \n", PLACE);
starbar();
//ИСПОЛЬЗОВАНИЕ ФУНКЦИИ
return 0;
}
/*ОПРЕДЕЛЕНИЕ ФУНКЦИИ void starbar (void)*/
void starbar (void)
//ОПРЕДЕЛЕНИЕ ФУНКЦИИ (ЧТО ДЕЛАЕТ ФУНКЦИЯ)? Функция выводит звездочки
{
int count;
//ИНИЦИАЛИЗАЦИЯ ПЕРЕМЕННОЙ c имененм count, тип данных целочисленный Данная переменная ЛОКАЛЬНАЯ только для ф-ции starbar()
for (count = 1; count <= WIDTH; count++)
//ЦИКЛ. Вызывается функция void starbar (void) который печатает '*'
putchar('*');
//ОПЕРАТОР ФУНКЦИИ putchar();
putchar('\n');
}
ВЫВОД НА ЭКРАН
MY HOME
DOMODEDOVSKAYA
MOSCOW
****************************************
void show_n_char (char ch, int num);
/*Эта строка обозначает, что функция show_n_char() принимает ДВА АРГУМЕНТА с именем ch -> тип char, и с именем num -> тип int
Эти переменные называются ФОРМАЛЬНЫМИ ПАРАМЕТРАМИ. Эти переменные определены ВНУТРИ ФУНКЦИИ, и ФОРМАЛЬНЫЕ ПАРАМЕТРЫ ЯВЛЯЮТСЯ ЛОКАЛЬНЫМИ
ПЕРЕМЕННЫМИ*/
spaces = (WIDHT - strlen(ADDRESS))/2; //ОПЕРАТОР ПРИСВАИВАНИЯ - получить значение константы WIDTH, вычесть результат работы функции
//strlen(ADDRESS), разделить на два и ПРИСВОИТЬ РЕЗУЛЬТАТ ВЫЧИСЛЕНИЯ ПЕРЕМЕННОЙ spaces
int main(void) //имя функции (объявление функции с именем main
/*Программа на С состоит из одной или большего числа функций - базовых
модулей программ на С.
Круглые скобки показывают, что main() есть имя функции,
int - указывает на то, что функция main() ВОЗВРАЩАЕТ ЦЕЛОЕ ЧИСЛО,
void - говорит о том, что функция main() НЕ ПРИНИМАЕТ НИКАКИХ АРГУМЕНТОВ.
/*СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ определяет каким образом данные преобразутся в отображаемую форму*/
%d //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком
%f
//число с плавающей запятой, десятичное представление
%c
//одиночный символ
%s
//интерпретирует введенные данные как строку
%e
//Экспонициальная форма
%a
//Двоично-экспонициальное представление
&
//спецификатор где можно найти переменную
/*ОПЕРАТОР ОБЪЯВЛЕНИЯ - назначает переменной имя и определяет тип данных, которые будут храниться в этой переменной.
Имя переменной может служить идентификатором.
ОПЕРАТОР ПРИСВАИВАНИЯ - устанавливает значение переменной или область хранения.
ОПЕРАТОР ВЫЗОВА ФУНКЦИИ - запускает на выполнение функцию с указанным именем.
ПЕРЕМЕННАЯ ЭТО ВСЕГО ЛИШЬ ИМЯ ВЫДЕЛЕННОЙ ЯЧЕЙКИ ПАМЯТИ КОМПЬЮТЕРА, КОТОРОЕ МОЖНО ИЗМЕНИТЬ, ПОЭТОМУ НАЗЫВАЕТСЯ ПЕРЕМЕННОЙ
КОНСТАНТА - ДАННЫЕ КОТОРЫЕ ХРАНЯТЬСЯ В ЯЧЕЙКЕ.
СТЕК - Сегмент который содержит величины, данные проходящиее через функции и процедуры внутри программы
РЕГИСТРЫ - хранят элементы данных без доступа к памяти. */
--------------------------------------------------------------------------------------------------------------------------
/*СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ определяет каким образом данные преобразутся в отображаемую форму*/
%d //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком
%ld //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком для типа long
&
//СПЕЦИФИКАТОР чтения типов из одного базового элемента
%p
//спецификатор для адресов
//Проверка для выяснения где храняться переменные
#include <stdio.h>
void mikado(int);
//объявление функции, которая принимает агрумент типа int, и ничего не возвращает
int main(void)
{
int pooh = 2, bah = 5;
//локальные переменные для main()
printf("Внутри main() pooh = %d и &pooh = %p \n", pooh, &pooh);
printf("Внутри main() bah = %d и &bah = %p \n", bah, &bah);
mikado(pooh);
return 0;
}
void mikado(int bah)
//определение функции, что функция делает - вычисляет где хранятся переменная bah
{
int pooh = 10;
//локальная для mikado()
printf("Внутри mikado() pooh = %d и &pooh = %p \n", pooh, &pooh);
printf("Внутри mikado() bah = %d и &bah = %p \n", bah, &bah);
}
ВЫВОД НА ЭКРАН
Внутри main() pooh = 2 и &pooh = 0xffffcc0c
Внутри main() bah = 5 и &bah = 0xffffcc08
Внутри mikado() pooh = 10 и &pooh = 0xffffcbcc
Внутри mikado() bah = 2 и &bah = 0xffffcbe0
---------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------------------
//ПРИМЕР 14 Inverted half pyramid
#include <stdio.h> //КОМАНДА ПРЕПРОЦЕССОРА - подключение файла стандартной библиотеки С stdio.h содержит библиотеку функций ввода-вывода
void figure(void);
//объявление прототипа функции
int main(void)
{
int i, j, rows;
//объявление переменных, тип данных целочслен. значения
printf("Enter the number of rows: \n");
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() - функция вывода на экран.
/*получить входные данные от пользователя*/
scanf("%d", &rows);
//(& амперсанд) для указания на то, где можно найти переменную
printf("Поучить фигуру \n");
return 0;
void figure(void)
//определение функции, что функция делает
for (i=rows; i>= 1; --i)
//ВНЕШНИЙ ЦИКЛ - условие для рядов rows - ряд
{
for (j=1; j<=i; ++j)
//ВНУТРЕНИИЙ ЦИКЛ - для рспечатывания всех колонок каждого ряда
{
printf("* ");
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() - функция ВЫВОДА НА ЭКРАН - управляющая строка и переменная
}
printf("\n");
}
}
-----------------------------------------------------------------------------------------------------------------
/*Объявление аргумента создает ПЕРЕМЕННУЮ, которая называется ФОРМАЛЬНЫМ АРГУМЕНТОМ или ФОРМАЛЬНЫМ ПАРАМЕТРОМ*/
/*ПРОТОТИП - ЭТО ОБЪЯВЛЕНИЕ ФУНКЦИИ, В КОТОРОМ ДАЕТСЯ ОПИСАНИЕ ВОЗВРАЩАЕМОГО ЗНАЧЕНИЯ ФУНЦИИ И ВСЕХ ЕЕ АРГУМЕНТОВ*/
/*ЧТО НУЖНО ЗНАТЬ О ФУНКЦИЯХ
- КАК ИХ ПРАВИЛЬНО ОПРЕДЕЛЯТЬ
- ВЫЗЫВАТЬ
- ОБЕСПЕЧИВАТЬ ВЗАИМОДЕЙСТВИЕ МЕЖДУ НИМИ*/
//ПРИМЕР
#include <stdio.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
void pound(int n);
//ОБЪЯВЛЕНИЕ ПРОТОТИПА ФУНКЦИИ, функция pound() принимает один аргумент int (целое число)
int main(void)
//ИМЯ ФУНКЦИИ С АРГУМЕНТАМИ. Имя функции - main(). Функция которая всегда присуствует в программе на С.
//void - говорит о том, что функция main() не принимает никаких аргументов
{
int times = 5;
//ОПЕРАТОРА ОБЪЯВЛЕНИЯ ПЕРЕМЕННОЙ с именем times и уведомляет, что ей приствоено целочислен.знач константа 5.
char ch = '!';
//ОПЕРАТОРА ОБЪЯВЛЕНИЯ ПЕРЕМЕННОЙ с именами ch -> символьный тип
float f = 6.0f;
//ОПЕРАТОР ПРИСВАИВАНИЯ переменной f -> вещественное число
pound(times);
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ pound(), аргумент типа int. ПРИСВАИВАНИЕ ПЕРЕМЕННОЙ n ЗНАЧЕНИЯ times
pound(ch);
//Эквивалентно pound((int)ch); ПРЕОБРАЗОВАНИЕ АРГУМЕНТА В тип int с помощью ПРОТОТИПА void pound(int n)
pound(f);
//Эквивалентно pound((int)f); ПРЕОБРАЗОВАНИЕ АРГУМЕНТА В тип int с помощью ПРОТОТИПА void pound(int n)
return 0;
}
void pound(int n)
//ОПРЕДЕЛЕНИЕ ФУНКЦИИ (ЧТО ДЕЛАЕТ ФУНКЦИЯ)? , функция рисует узор с помощью "#"
{
while (n --> 0)
//начало цикла while (МЕТОД ОБРАБОТКИ ДАННЫХ), проверка условия цикла
printf("#");
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет один аргумент
printf("\n");
}
ВЫВОД НА ЭКРАН
#####
#################################
######
-------------------------------------------------------------------------------------------------------------------
//ПРИМЕР
/*ПАРАМЕТРЫ - это переменные,
АРГУМЕНТЫ - это ЗНАЧЕНИЯ, которые предоставляются вызовом функции и присваиваются соответствующим параметрам */
pound(times);
//(times) -> АРГУМЕНТ(ЗНАЧЕНИЕ) функции pound()
//n -> параметр функции
/*ПРОТОТИП - это форма объявления, которая уведомляет компилятор о том, что вы
используете КОНКРЕТНУЮ ФУНКЦИЮ, поэтому он называется ОБЪЯВЛЕНИЕМ ФУНКЦИИ. Он также определяет СВОЙСТВА ФУНКЦИИ.
В данном примере pound() есть прототип функции. */
void pound(int n);
Первое void - говорит, что функция pound() не возвращает никакого значения
Второе pound(int n) говорит о том, функция pound() принимает один аргумент int тип - целое число
-----------------------------------------------------------------------------------------------------------------
//ПРИМЕР ПРОГРАММЫ КОТОРАЯ ВЫБИРАЕТ МЕНЬШЕЕ ИЗ ДВУХ ЧИСЕЛ
#include <stdio.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
int imin(int n, int m);
//ОБЪЯВЛЕНИЕ ПРОТОТИПА ФУНКЦИИ, функция imin() принимает один два аргумент int (целое число), возвращает int - целое число
int main(void)
//ИМЯ ФУНКЦИИ С АРГУМЕНТАМИ. Имя функции - main(). Функция которая всегда присуствует в программе на С.
//void - говорит о том, что функция main() не принимает никаких аргументов
{
int evil1, evil2;
printf("Введите два целых числа (или q для заверешения): \n");
while (scanf("%d %d", &evil1, &evil2) == 2)
{
printf("Меньшим из двух чисел %d и %d является %d. \n", evil1, evil2, imin(evil1, evil2));
printf("Введите два целых числа (или q для заверешения): \n");
}
printf("Программа завершенаю \n");
return 0;
}
int imin(int n, int m)
//ОПРЕДЕЛЕНИЕ ФУНКЦИИ (ЧТО ДЕЛАЕТ ФУНКЦИЯ)? Функция сравнивает два числа
{
int min;
if(n < m)
min = n;
else
min = m;
return min;
}
ВЫВОД НА ЭКРАНЕ
Введите два целых числа (или q для заверешения):
4 5
Меньшим из двух чисел 4 и 5 является 4.
Введите два целых числа (или q для заверешения):
17 56
Меньшим из двух чисел 17 и 56 является 17.
Введите два целых числа (или q для заверешения):
q
Программа завершенаю
-----------------------------------------------------------------------------------------------------------------------
//ДЕМОНСТРАЦИОННАЯ ПРОГРАММА
#include <stdio.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
const int S_PER_M = 60;
//ОБЪЯВЛЕНИЕ КОНСТАНТЫ тип данных - целочисленный int -> кол-во секунд в милях
const int S_PER_Н = 3600;
//ОБЪЯВЛЕНИЕ КОНСТАНТЫ тип данных - целочисленный int -> кол-во секунд в часе
const double M_PER_K = 0.62137;
//ОБЪЯВЛЕНИЕ КОНСТАНТЫ тип данных - вещественный -> кол-во миль в км
int main(void)
//ОБЯВЛЕНИЕ ФУНКЦИИ с именем main() - главная функция, каркас программы на С
{
double distk, distm;
//ОПЕРАТОРА ОБЪЯВЛЕНИЯ ПЕРЕМЕННЫХ с именами distk, distm и уведомляет, что они имеют вещественный тип
//дистанция пробега в км и милях
double rate;
//ОПЕРАТОРА ОБЪЯВЛЕНИЯ ПЕРЕМЕННЫХ с именами rate и уведомляет, что она имеет вещественный тип
//средняя скорость в милях в час
int time;
//ОПЕРАТОРА ОБЪЯВЛЕНИЯ ПЕРЕМЕННЫХ с именами time и уведомляет, что они имеют целочисленный тип
//время пробега только с сек.
double mtime;
//ОПЕРАТОРА ОБЪЯВЛЕНИЯ ПЕРЕМЕННЫХ с именами mtime и уведомляет, что они имеют вещественный тип
//время пробега одной мили в секундах
int mmin, msec;
//ОПЕРАТОРА ОБЪЯВЛЕНИЯ ПЕРЕМЕННЫХ с именами mmin, msec и уведомляет, что они имеют целочисленный тип
//время пробега одной мили в минутах и секундах
printf("Эта программа преобразует время пробега дистанции в метрической системе.\n");
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет один аргумент - управляющая строка
printf("во время пробега одной мили и вычислет вашу среднюю\n");
printf("скорость в милях в час\n");
/*получить входные данные от пользователя*/
printf("Введите дистанцию пробега в километрах\n");
scanf("%lf", &distk);
//ОПЕРАТОР ВЫЗОВА ИНТЕРАКИВНОЙ ФУНКЦИИ, УКАЗАТЕЛИ НА ПЕРЕМЕННЫЕ, %lf для типа double
printf("Введите время в минутах и секундах.\n");
printf("Начните с ввода минут.\n");
scanf("%d", &min);
//ОПЕРАТОР ВЫЗОВА ИНТЕРАКИВНОЙ ФУНКЦИИ, УКАЗАТЕЛИ НА ПЕРЕМЕННЫЕ
printf("Теперь введите секунды\n");
scanf("%d", &sec);
//переводим время в секунды
time = S_PER_M * min + sec;
//ОПЕРАТОР ПРИСВАИВАНИЯ - получить значение константы S_PER_M, умножить на значение переменной min,
//прибавить значение переменной sec и ПРИСВОИТЬ РЕЗУЛЬТАТ ВЫЧИСЛЕНИЯ переменной time
//переводит километры в мили
distm = M_PER_K * distk;
//OПЕРАТОР ПРИСВАИВАНИЯ - получить значение константы M_PER_K, умножить на значение переменной distk,
//и ПРИСВОИТЬ РЕЗУЛЬТАТ ВЫЧИСЛЕНИЯ переменной distm
//умножение миль в секунду на количество секунд в часе дает кол-во миль в час
rate = distm / time * S_PER_Н
//OПЕРАТОР ПРИСВАИВАНИЯ - получить значение переменной distm, time, получить значение константы S_PER_Н.
//Вычислить выражение и ПРИСВОИТЬ РЕЗУЛЬТАТ ВЫЧИСЛЕНИЯ переменной rate
//деление времени на расстояние дает время пробега одной мили
mtime = (double) time / distm;
//OПЕРАТОР ПРИСВАИВАНИЯ
mmin = (int) mtime / S_PER_M; //OПЕРАТОР ПРИСВАИВАНИЯ. Вычисление полного количества минут
msec = (int) mtime % S_PER_M; //OПЕРАТОР ПРИСВАИВАНИЯ. Вычисление остатка в секундах
printf("Вы пробежали %1.2f км (%1.2f мили) за %d мин, %d сек. \n", distk, distm, min, sec);
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет пять аргументов ->
//управляющая строка и СПИСОК ПЕРЕМЕННЫХ
prinf("Такая скорость соответсвует пробегу одной мили за %d мин", mmin);
printf("%d сек. \n Ваша средняя скорость составила %1.2f миль в секунду ", msec, rate);
return 0;
}
//ВЫРАЖЕНИЯ - КОМБИНАЦИИ ОПЕРАЦИЙ И ОПЕРАНДОВ
//ОПЕРАЦИИ - ИНСТРУКЦИИ ДЛЯ КОМПЬЮТЕРА, МЕТОДЫ ОБРАБОТКИ ДАННЫХ
//ОПЕРАНДЫ - ТО НАД ЧЕМ ПРОВОДЯТ ОПЕРАЦИИ. ТИП ДАННЫХ.
/*При определении ФУНКЦИИ, которая принимает АРГУМЕНТ, в определении функции мы объявляем ПЕРЕМЕННУЮ или ФОРМАЛЬНЫЙ АРГУМЕНТ.
Затем, значение, передаваемое в вызове функции, прсваивается этой переменной и может применятся внутри данной функции. */
printf("скорость в милях в час\n", min); //ВЫЗОВ ФУНКЦИИ printf(), то что в "", min -> аргумент(значение). ПЕРЕМЕННАЯ - min -> ФОРМАЛЬНЫЙ АРГУМЕНТ
%lf //СПЕЦИФИКАТОР указывают, что значение будет сохранено с типом double более точное число с плавающей точкой
&
//СПЕЦИФИКАТОР чтения типов из одного базового элемента
%d //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком
int main(void)
/*int - указывает на то, что функция main() возвращает целое число,
void - говорит о том, что функция main() не принимает никаких аргументов.*/
-------------------------------------------------------------------------------------------------------------------------
//ФУНКЦИЯ strlen()
sizeof - операция, которая предоставляет размер типа в байтах
strlen() - возращает длину строки в символах
/*ЧТО НУЖНО ЗНАТЬ О ФУНКЦИЯХ
- КАК ИХ ПРАВИЛЬНО ОПРЕДЕЛЯТЬ
- ВЫЗЫВАТЬ
- ОБЕСПЕЧИВАТЬ ВЗАИМОДЕЙСТВИЕ МЕЖДУ НИМИ*/
//EXAMPLES
#include <stdio.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С.
#include <string.h>
//предоставляет ПРОТОТИП ФУНКЦИИ strlen() (Данный заголовочный файл содержит прототипы для обработки строк)
#define PRAISE "Вы выдающаяся личность"
// СИМВОЛИЧЕСКАЯ КОНСТАНАТА
int main(void)
//ИМЯ ФУНКЦИИ С АРГУМЕНТАМИ. Имя функции - main(). Функция которая всегда присуствует в программе на С.
{
char name[40];
//ОПЕРАТОР ОБЪЯВЛЕНИЯ МАССИВ ИЗ 40 ЭЛЕМЕНТОВ с именем name, и уведомляет что он имеет тип данных char - символьное значение
printf("Как ва зовут?\n");
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет один аргумент
/*получить входные данные от пользователя*/
scanf ("%s", name);
//ОПЕРАТОР ВЫЗОВА ИНТЕРАКИВНОЙ ФУНКЦИИ - пользователь вводит символ, имеет два аргумента => УПРАВЛЯЮЩАЯ СТРОКА И УКАЗАТЕЛЬ НА ПЕРЕМЕННЫХ
printf("Здравствуйте, %s. %s\n", name, PRAISE);
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет три аргумента -> управляющая строка "", список переменных
printf("Ваше имя состоит из %zd символов и занимает %zd ячеек памяти. \n", strlen(name), sizeof name);//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет три аргумента
printf("Хвалебная фраза содержит %zd символов", strlen(PRAISE));
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет два аргумента
printf("и занимает %zd ячеек памяти. \n", sizeof PRAISE); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет два аргумента -> управляющая строка "", список переменных
return 0;
//ОПЕРАТОР ВОЗВРАТА
}
ВЫВОД НА ЭКРАН
Как ва зовут?
Tanya
Здравствуйте, Tanya. Вы выдающаяся личность
Ваше имя состоит из 5 символов и занимает 40 ячеек памяти.
Хвалебная фраза содержит 42 символови занимает 43 ячеек памяти.
-------------------------------------------------------------------------------------------------------------
/* В общем случае С разделяет БИБЛИОТЕКУ ФУНКЦИЙ на семейство связанных функций и предоставляет отдельный заголовочный файл для
каждого семейства.
ФУНКЦИИ printf(), scanf() принадлежит семейству стандартных функций ввода-вывода и имеют свой заголовочный файл stdio.h
ФУНКЦИЯ strlen() объединяет вокруг себя ряд других функций обработки строк таких как фунции функции копирования и поиска
в строках и имеют заголовочный файл string.h
*/
sizeof - //Операция сообщает что массив name имеет 40 ячеек памяти.
strlen() - //Функции strlen() известно, когда остановить подсчет символов
//КОНСТАНТЫ
circumference = 3.14159 * diameter; //общеизвестная константа Пи
circumference = Pi * diameter; //символическая константа Пи
#define ИМЯ значение
//формат символической константы
#define TAXRATE 0.015
//СИМВОЛИЧЕСКАЯ КОНСТАНТА ФОРМАТ
----------------------------------------------------------------------------------------------------------------
//ПРИМЕР
#include <stdio.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С.
#define PI 3.14159
// СИМВОЛИЧЕСКАЯ КОНСТАНАТА
int main(void)
//ИМЯ ФУНКЦИИ С АРГУМЕНТАМИ. Имя функции - main(). Функция которая всегда присуствует в программе на С.
{
float area, circum, radius; //ОПЕРАТОР ОБЪЯВЛЕНИЯ ПЕРЕМЕННЫХ с именами area, circum, radius и уведомляет что онb имеет тип число с плавающей точкой
printf("Каков радиус вашей пиццы?\n");
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет один аргумент.
/*получить входные данные от пользователя*/
scanf ("%f", &radius);
//ОПЕРАТОР ВЫЗОВА ИНТЕРАКИВНОЙ ФУНКЦИИ - пользователь вводит символ, имеет один аргумент.Спецификатор %f для вывода числе типа float и double
area = PI * radius * radius; //ОПЕРАТОР ПРИСВАИВАНИЯ, получить значение переменной radius и умножить его на PI -константа
//и присвоить результат вычисления переменной area
circum = 2.0 * PI * radius; //ОПЕРАТОР ПРИСВАИВАНИЯ, получить значение переменной radius, умножить его на PI -символич. константа, умножить на 2.0 (числовая константа)
//и присвоить результат вычисления переменной area
printf("Основные параметры вашей пиццы:\n");
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет один аргумент
printf("Длина окружности = %1.2f, площадь = %1.2f\n", circum, area);
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет три аргумента
return 0;
//ОПЕРАТОР ВОЗВРАТА
}
ВЫВОД НА ЭКРАН
Каков радиус вашей пиццы?
20
Основные параметры вашей пиццы:
Длина окружности = 125.66, площадь = 1256.64
------------------------------------------------------------------------------------------------------------
//ПРИМЕР
#include <stdio.h>
//КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
#include <limits.h>
//Заголовочный файл - пределы для целых чисел (размеры)
#include <float.h>
//пределы для чисел с плавающей точкой
int main(void)
//ИМЯ ФУНКЦИИ С АРГУМЕНТАМИ. Имя функции - main(). Функция которая всегда присуствует в программе на С.
{
printf("Некоторые пределы числе для данной системы:\n");
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет один аргумент
printf("Наибольшее значение типа int: %d \n", INT_MAX);//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет два аргумента
printf("Наименьшее значение типа long long: %lld", LLONG_MIN);
//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет два аргумента
printf("В данной системе один байт = %d битов. \n", CHAR_BIT);
printf("Наибольшее значение типа double: %e\n", DBL_MAX);
printf("Наименьшее нормализованное значение типа float: %e\n", FLT_MIN);
printf("Точность значения типа float = %d знаков\n", FLT_DIG);
printf("Разница между 1.0 и минимальным значением float, которое больше 1.00 = %e знаков\n", FLT_EPSILON);
return 0;
//ОПЕРАТОР ВОЗВРАТА
}
INT_MAX
//Символьная константа - максимальное значение типа int
LLONG_MIN
//Минимальное значение типа long long
CHAR_BIT
//Количество битов в типе char
DBL_MAX
//Наибольшее значение типа double
FLT_MIN
//Наименьшее нормализованное значение типа float сохраняющее полную точность
FLT_DIG
//Минимальное количество значащих десятичных цифр для типа float - число в плавающей точкой типа 2.8076
FLT_EPSILON
//Разница межд 1.00 и минимальным значением float, которое больше 1.00
-------------------------------------------------------------------------------------------------------------
#include <stdio.h> //КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки С
void butler(void); //Объявления ПРОТОТИП ФУНКЦИИ с именем batler()
int main(void) //ИМЯ ФУНКЦИИ С АРГУМЕНТАМИ. Имя функции - main(). Функция которой всегда присуствует в программе на С.
{
printf("I call the boss. \n"); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет один аргумент
butler(); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем butler() - это ПРОТОТИП ФУНКЦИИ
printf("yes. \n");
return 0; //ОПЕРАТОР ВОЗВРАТА
}
void butler(void) //ОПРЕДЕЛЕНИЕ ФУНКЦИИ (ЧТО ДЕЛАЕТ ФУНКЦИЯ)? , функция выводит на экран "yes". Функция не принимает аргументов и нечего не возвращает
{
printf("Yes. \n"); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет один аргумент. АРГУМЕНТ - ЭЛЕМЕНТЫ ИНФОРМАЦИИ, ПЕРЕДАВАЕМОЙ ФУНКЦИИ.
}
ВЫВОД НА ЭКРАН
I call the boss.
Yes.
yes.
//БУФЕР - ПРОМЕЖУТОЧНАЯ ОБЛАСТЬ ХРАНЕНИЯ
/*ФУНКЦИЯ в программировании — фрагмент программного кода (подпрограмма), к которому можно обратиться из другого места программы.
Функция может принимать параметры и должна возвращать некоторое значение, возможно пустое. Функции, которые возвращают пустое значение, часто называют ПРОЦЕДУРАМИ.
ПОДПРОГРАММА (ПРОЦЕДУРА) (англ. subroutine) — поименованная или иным образом идентифицированная часть компьютерной программы, содержащая описание определённого набора
действий. ПОДПРОГРАММА может быть многократно вызвана из разных частей программы.
*/
/* В данном примере функция batler() трижды появилась в программе
1) в виде прототипа void butler(void) передающего компилятору информацию о функциях
которые будут использоваться в данной программе
2) появлятся в теле функции main() в форме вызова функции
3) в виде определения функции, которое является исходным кодом самой функции
ПРОТОТИП - это форма объявления, которая уведомляет компилятор о том, что вы
используете КОНКРЕТНУЮ ФУНКЦИЮ, поэтому он называется ОБЪЯВЛЕНИЕМ ФУНКЦИИ. Он также определяет СВОЙСТВА ФУНКЦИИ.
В данном примере butler() есть прототип функции.
void butler(void)
Первое void - говорит, что butler() не имеет возвращаемого значения
Второе butler(void) говорит о том, что функция butler() не принимает аргументов
Т.о. функция butler() не принимает никаких аргументов(параметров) и не возвращает значения.
В старых вериях ПРОТОТИП => ОБЪЯВЛЕНИЕ ФУНКЦИИ
*/
/*ОПЕРАТОР ОБЪЯВЛЕНИЯ - назначает переменной имя и определяет тип данных, которые будут храниться в этой переменной.
Имя переменной может служить идентификатором.
ОПЕРАТОР ПРИСВАИВАНИЯ - устанавливает значение переменной или область хранения.
ОПЕРАТОР ВЫЗОВА ФУНКЦИИ - запускает на выполнение функцию с указанным именем.
ПЕРЕМЕННАЯ ЭТО ВСЕГО ЛИШЬ ИМЯ ВЫДЕЛЕННОЙ ЯЧЕЙКИ ПАМЯТИ КОМПЬЮТЕРА, КОТОРОЕ МОЖНО ИЗМЕНИТЬ, ПОЭТОМУ НАЗЫВАЕТСЯ ПЕРЕМЕННОЙ
КОНСТАНТА - ДАННЫЕ КОТОРЫЕ ХРАНЯТЬСЯ В ЯЧЕЙКЕ. */
/*АРГУМЕНТ - ЭЛЕМЕНТЫ ИНФОРМАЦИИ, ПЕРЕДАВАЕМОЙ ФУНКЦИИ.
ФУНКЦИИ printf() и scanf() не ограничены конкретным количеством аргументов.
Аргументы отделяются друг от друга запятыми. */
УКАЗАТЕЛИ
/*УКАЗАТЕЛЬ - представляет собой переменную, используемую для хранения адреса.
СТЭК - ВРЕМЕННАЯ ПАМЯТЬ - Сегмент который содержит величины, данные проходящиее через функции и процедуры внутри программы
Функция scanf() работает с адресами аргументов.
*/
& - //унитарная операция предоставляет адрес по которому хранится переменная.
pooh //переменная
&pooh //адрес этой переменной
//ПРИМЕР
pooh = 24; //оператор, инициализация переменной и присваивание ей целочисл. значения константы 24
//адрес по котрому храниться переменная pooh является 0B76 - шестнадцатиричное число
printf("%d %p\n", pooh, &pooh); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет один аргумент - управляющая строка
/*СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ определяет каким образом данные преобразутся в отображаемую форму*/
%d //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком
%p //спецификатор варьируется
//ПРИМЕР
#include <stdio.h> //КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
void mikado(int); //Объявление функции с именем mikado(), КОТОРАЯ ПРИНИМАЕТ АРГУМЕНТ int, и НИЧЕГО НЕ ВОЗВРАЩАЕТ
int main(void)
{
int pooh = 2; bah = 5; //Инцициализация локальных переменных для main(). Тип переменных целочислен. int
printf("Внутри main() pooh = %d и &pooh = %p\n", pooh, &pooh); //Оператор вызова фунции имеет три аргумента -> упаравляющая строка, переменная, указатель
printf("Внутри main() bah = %d и &bah = %p\n", bah, &bah); //Оператор вызова фунции имеет три аргумента -> упаравляющая строка, переменная, указатель
mikado(pooh); //оператор вызова фунции
return 0;
}
void mikado(int bah); //Объявление функции с именем mikado(), КОТОРАЯ ПРИНИМАЕТ АРГУМЕНТ int, и НИЧЕГО НЕ ВОЗВРАЩАЕТ
{
int pooh = 10; //Инициализация локальной переменной для mikado(), тип данных int
printf("Внутри mikado() pooh = %d и &pooh = %p\n", pooh, &pooh); //Оператор вызова фунции имеет три аргумента -> упаравляющая строка, переменная, указатель
printf("Внутри mikado() bah = %d и &bah = %p\n", bah, &bah); //Оператор вызова фунции имеет три аргумента -> упаравляющая строка, переменная, указатель
}
interchange() //Изменение переменных в вызывающей функции
//ПРИМЕРЫ
nurse = 22;
ptr = &nurse; //указатель на nurse
val = *ptr; //присваивает val значение, хранящееся в ячейке ptr
//ОБЪЯВЛЕНИЕ УКАЗАТЕЛЕЙ
int * pi; //pi - указатель на целочисленную переменную
char * pc; //pc - указатель на символьную переменную
float * pf, * pg //pf, pg - указатели на переменные с плавающей запятой
//В ОБЩЕМ СЛУЧАЕ В ФУНКЦИЮ МОЖНО ПЕРЕДАТЬ ДВА ВИДА ИНФОРМАЦИИ О ПЕРЕМЕННОЙ.
//Первая форма требует чтобы определение функции включало формальный аргумент
int function1 (int num) //ф-ции передают значение для вычисления или действия
// Вторая форма - определение функции должно включать формальный параметр, который является указателем на конкретный тип
int function2 (int * ptr) //испол. если ф-ция должна изменять значения переменных из вызывающей функции
/*ПЕРЕМЕННАЯ ИМЕЕТ ДВА АТРИБУТА
- ИМЯ
- ЗНАЧЕНИЕ
а также
- ТИП
ПОСЛЕ ТОГО КАК ПРОГРАММА СКОМПИЛИРОВАНА И ЗАГРУЖЕНА ПЕРЕМЕННАЯ РАСПОЛАГАЕТ
- АДРЕСОМ
- ЗНАЧЕНИЕМ */
&barn //адрес переменной barn
//СВОДКА ФУНКЦИИ
int diff (int x, int y) //функция с именем diff, список объявлен. переменных int x, int y
{
int z; //объявление локальной переменной
z = x - y;
return z; //возвращение значения
}
//ПРИМЕР
double duff (double, int); //прототип функции
int main(void)
{
double q,x;
int n;
.....
q = duff(x, n); //вызов функции
}
double duff (double u, int k) //определение фунции
{
double tor;
.....
return tor; //возврат значение типа double
}
РЕКУРСИЯ
/*РЕКУРСИЯ - ФУНКЦИИ РАЗРЕШЕНО ВЫЗЫВАТЬ САМУ СЕБЯ
КОД - это последовтельность инструкций, а ВЫЗОВ ФУНКЦИИ представляет собой команду перехода на начало этой последовательности
инструкций. РЕКУРСИВНЫЙ ВЫЗОВ затем возвращает программу в начало упомянутой последовтельности инструкций.
ХВОСТОВАЯ РЕКУРСИЯ - рекурсивный вызов находится в конце функции, непосредственно перед оператором return - это хвостовая или концевая рекурсия.
СТЭК - ВРЕМЕННАЯ ПАМЯТЬ - Сегмент который содержит величины, данные проходящиее через функции и процедуры внутри программы
/*ПРОТОТИП - ЭТО ОБЪЯВЛЕНИЕ ФУНКЦИИ, В КОТОРОМ ДАЕТСЯ ОПИСАНИЕ ВОЗВРАЩАЕМОГО ЗНАЧЕНИЯ ФУНЦИИ И ВСЕХ ЕЕ АРГУМЕНТОВ*/
/*ЧТО НУЖНО ЗНАТЬ О ФУНКЦИЯХ
- КАК ИХ ПРАВИЛЬНО ОПРЕДЕЛЯТЬ
- ВЫЗЫВАТЬ
- ОБЕСПЕЧИВАТЬ ВЗАИМОДЕЙСТВИЕ МЕЖДУ НИМИ*/
//ПРИМЕР
#include <stdio.h> //КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
void up_and_down(int); //ОПРЕДЕЛЕНИЕ ФУНКЦИИ с именем up_and_down(), КОТОРАЯ ПРИНИМАЕТ АРГУМЕНТ int, НО НИЧЕГО НЕ ВОЗВРАЩАЕТ
int main(void) //ОБЯВЛЕНИЕ ФУНКЦИИ с именем main() - главная функция, каркас программы на С
{
up_and_down(1);
return 0;
}
void up_and_down(int n) //ОПРЕДЕЛЕНИЕ ФУНКЦИИ с именем up_and_down(), КОТОРАЯ ПРИНИМАЕТ АРГУМЕНТ int, НО НИЧЕГО НЕ ВОЗВРАЩАЕТ
{
printf("Level %d: ячейка n %p\n", n, &n); //1 На каждом уровне рекурскии прим. собств. закрытая переменная n
if (n < 4)
up_and_down(n + 1);
printf("Level %d: ячейка n %p\n", n, &n); //2
}
ВЫВОД НА ЭКРАНЕ
Level 1: ячейка n 0xffffcbf0
Level 2: ячейка n 0xffffcbc0
Level 3: ячейка n 0xffffcb90
Level 4: ячейка n 0xffffcb60
Level 4: ячейка n 0xffffcb60
Level 3: ячейка n 0xffffcb90
Level 2: ячейка n 0xffffcbc0
Level 1: ячейка n 0xffffcbf0
/*СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ определяет каким образом данные преобразутся в отображаемую форму*/
%d //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком
%ld //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком для типа long
& //СПЕЦИФИКАТОР чтения типов из одного базового элемента
/*ФАКТОРИЛ ЦЕЛОГО ЧИСЛА - это результат произведения всех целых чисел, начиная с 1 и заканчивая заданным числом. Например
факторил 3 (записывается как 3!) соответствует 1*2*3
*/
//ПРИМЕР
#include <stdio.h> //КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
long fact(int n); //ОПРЕДЕЛЕНИЕ ФУНКЦИИ с именем fact(), КОТОРАЯ ПРИНИМАЕТ АРГУМЕНТ int, и ВОЗВРАЩАЕТ ЗНАЧЕНИЕ ТИПА long
long rfact (int n); //ОПРЕДЕЛЕНИЕ ФУНКЦИИ с именем rfact(), КОТОРАЯ ПРИНИМАЕТ АРГУМЕНТ int, и ВОЗВРАЩАЕТ ЗНАЧЕНИЕ ТИПА long
int main (void)
{
int num; //ОБЪЯВЛЕНИЕ ПЕРЕМЕННОЙ с именем num, тип int
printf ("Эта программа вычисляет факториалы. \n"); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет один аргумент - управляющая строка
printf ("Введите значение в диапазоне 0-12 (q для завершения) : \n");
while (scanf("%d", &num) == 1) //ЦИКЛ. ОПЕРАТОР ВЫЗОВА ИНТЕРАКИВНОЙ ФУНКЦИИ, УКАЗАТЕЛИ НА ПЕРЕМЕННЫЕ, == РАВНО
{
if (num < 0)
printf ("Отрицаельные числа не подходят. \n");
else if (num > 12)
printf ("Вводимое значение должно быть меньше 13. \n");
else
{
printf("Цикл: факториал %d = %ld\n", num, fact(num)); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет три аргумента - управляющая строка, переменная, функцияd
printf("Цикл: факториал %d = %ld\n", num, rfact(num)); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет три аргумента - управляющая строка, переменная, функцияd
}
printf("Введите значение в диапазоне 0-12 (q для завершения) : \n"); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет один аргумент - управляющая строка
}
printf("Программа завершена. \n");
return 0;
}
long fact(int n) //функция, основанная на цикле. ОПРЕДЕЛЕНИЕ ФУНКЦИИ (ЧТО ДЕЛАЕТ ФУНКЦИЯ - вычисляет факториал). Принимает аргумент(параметр) int, возвращает тип long
{
long ans; //ОБЪЯВЛЕНИЕ ПЕРЕМЕННОЙ с именем ans, ТИПА long
for (ans = 1; n > 1; n--)
ans *= n;
return ans;
}
long rfact (int n) //Рекурсивная версия. ОПРЕДЕЛЕНИЕ ФУНКЦИИ - что делает функция - вычисляет факториал. Принимает аргумент(параметр) int, возвращает тип long
{
long ans; //ОБЪЯВЛЕНИЕ ПЕРЕМЕННОЙ с именем ans, ТИПА long
if (n > 0)
ans = n * rfact(n - 1);
else
ans = 1;
return ans;
}
ВЫВОД НА ЭКРАН
Эта программа вычисляет факториалы.
Введите значение в диапазоне 0-12 (q для завершения) :
6
Цикл: факториал 6 = 720
Цикл: факториал 6 = 720
Введите значение в диапазоне 0-12 (q для завершения) :
3
Цикл: факториал 3 = 6
Цикл: факториал 3 = 6
Введите значение в диапазоне 0-12 (q для завершения) :
q
Программа завершена.
//РЕГИСТРЫ - хранят элементы данных без доступа к памяти.
------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------
//ПРИМЕР
#include <stdio.h> //КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
long fact(int n); //ОПРЕДЕЛЕНИЕ ФУНКЦИИ с именем fact(), КОТОРАЯ ПРИНИМАЕТ АРГУМЕНТ int, и ВОЗВРАЩАЕТ ЗНАЧЕНИЕ ТИПА long
int main (void)
{
int num; //ОБЪЯВЛЕНИЕ ПЕРЕМЕННОЙ с именем num, тип int
printf ("Эта программа вычисляет факториалы. \n"); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет один аргумент - управляющая строка
printf ("Введите значение в диапазоне 0-12 (q для завершения) : \n");
while (scanf("%d", &num) == 1) //ЦИКЛ. ОПЕРАТОР ВЫЗОВА ИНТЕРАКИВНОЙ ФУНКЦИИ, УКАЗАТЕЛИ НА ПЕРЕМЕННЫЕ, == РАВНО
{
if (num < 0)
printf ("Отрицаельные числа не подходят. \n");
else if (num > 12)
printf ("Вводимое значение должно быть меньше 13. \n");
else
{
printf("Цикл: факториал %d = %ld\n", num, fact(num)); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет три аргумента - управляющая строка, переменная, функцияd
}
printf("Введите значение в диапазоне 0-12 (q для завершения) : \n"); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ имеет один аргумент - управляющая строка
}
printf("Программа завершена. \n");
return 0;
}
long fact(int n) //функция, основанная на цикле. ОПРЕДЕЛЕНИЕ ФУНКЦИИ (ЧТО ДЕЛАЕТ ФУНКЦИЯ - вычисляет факториал). Принимает аргумент(параметр) int, возвращает тип long
{
long ans; //ОБЪЯВЛЕНИЕ ПЕРЕМЕННОЙ с именем ans, ТИПА long
for (ans = 1; n > 1; n--)
ans *= n;
return ans;
}
ВЫВОД НА ЭКРАН
Эта программа вычисляет факториалы.
Введите значение в диапазоне 0-12 (q для завершения) :
6
Цикл: факториал 6 = 720
Введите значение в диапазоне 0-12 (q для завершения) :
9
Цикл: факториал 9 = 362880
Введите значение в диапазоне 0-12 (q для завершения) :
q
Программа завершена.
//ФОРМАТ ФУНКЦИИ printf()
//В ФУНКЦИИ printf() ПРИМЕНЯЮТСЯ ИМЕНА ПЕРЕМЕННЫХ, КОНСТАНТЫ И ВЫРАЖЕНИЯ
//В ФУНКЦИИ scanf() ПРИМЕНЯЮТСЯ УКАЗАТЕЛИ НА ПЕРЕМЕННЫЕ
printf("управляющая-строка", элемент1, элемент2, ...);
элемент1, элемент2 и т.д. - //эти элементы которые нужно вывести. Ими могут быть переменные, константы или выражения
//которые вычисляются до того, как значение будет выведено
управляющая-строка, //это символьная строка, описывающая способ вывода элементов, заключена в "" кавычки.
printf("%d участников соревнований съели %f пирожков с вишнями. \n", number, pies);
/*ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет три аргумента: управляющая строка и список из двух переменных number, pies
В управляющей строке есть два СПЕЦИФИКАТОРА ПРЕОБРАЗВАНИЯ
%d //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком
%f //число с плавающей запятой, десятичное представление
УПРАВЛЯЮЩАЯ СТРОКА содержит два разных вида информации:
- символы которые в действительности выводятся
- спецификаторы преобразования
*/
/*СТРОКА - это последовательности символов, трактуемая как отдельная единица.
МАССИВ - это последовательность элементов, имеющих один и тот же тип.
char name [30];
*/
//ПРИМЕР
#include <stdio.h> //КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
#define PI 3.141593 //СИМВОЛИЧЕСКАЯ КОНСТАНАТА
int main(void) //ИМЯ ФУНКЦИИ С АРГУМЕНТАМИ. Имя функции - main(). Функция которая всегда присуствует в программе на С.
//void - говорит о том, что функция main() не принимает никаких аргументов
{
int number = 7; //ИНИЦИАЛИЗАЦИЯ ПЕРЕМЕННОЙ с именем name и ПРИСВАИВАНИЕ ей целочисленного значени int, КОНСТАНТА -7
float pies = 12.75; //ИНИЦИАЛИЗАЦЯ ПЕРЕМЕННОЙ с именами pies и ПРИСВАИВАНИЕ ЕЙ вещественное значение. КОНСТАНТА -> 12.75 (Вещественный тип - Литерал)
int coast = 7800; //ИНИЦИАЛИЗАЦИЯ ПЕРЕМЕННОЙ с именем coast и ПРИСВАИВАНИЕ ей целочисленного значени int, КОНСТАНТА -7800
printf("%d участников соревнований съели %f пирожков с вишнями. \n", number, pies); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет три аргумента
//управляющая строка "" и список переменных
printf("Значение pi равно %f \n", PI);//ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет два аргумента -> управляющая строка "" и список переменных
printf("До свидания! Ваше искусство слишком дорого обходится, \n"); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет один аргумент -> управляющая строка ""
printf("%c%d\n", 2 * coast); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет два аргумента -> управляющая строка "" и ссписок переменных
return 0; //ОПЕРАТОР ВОЗВРАТА
}
/*СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ определяет каким образом данные преобразутся в отображаемую форму*/
%d //СПЕЦИФИКАТОР ПРЕОБРАЗОВАНИЯ десятичное число со знаком
%f //число с плавающей запятой, десятичное представление
%c //одиночный символ
%s //интерпретирует введенные данные как строку
//В ФУНКЦИИ printf() ПРИМЕНЯЮТСЯ ИМЕНА ПЕРЕМЕННЫХ, КОНСТАНТЫ И ВЫРАЖЕНИЯ
//В ФУНКЦИИ scanf() ПРИМЕНЯЮТСЯ УКАЗАТЕЛИ НА ПЕРЕМЕННЫЕ
#include <stdio.h> //КОМАНДА ПРЕПРОЦЕССОРА. Подключение файла из стандартной библиотеки компилятора С. Заголовочный файл.
int main(void) //ИМЯ ФУНКЦИИ С АРГУМЕНТАМИ. Имя функции - main(). Функция которая всегда присуствует в программе на С.
//void - говорит о том, что функция main() не принимает никаких аргументов
{
int age; //ОПЕРАТОР ОБЪЯВЛЕНИЯ ПЕРЕМЕННОЙ с именем age и уведомляет что переменная имеет тип int целочисленное значение
float assets; //ОПЕРАТОР ОБЪЯВЛЕНИЯ ПЕРЕМЕННОЙ с именами assets и и уведомляет что переменная имеет тип float - вещественное значение
char pet[30]; //ОПЕРАТОР ОБЪЯВЛЕНИЯ МАССИВ ИЗ 30 ЭЛЕМЕНТОВ с именем pet, и уведомляет что он имеет тип данных char - символьное значение
printf("Введите информацию о своем возрасте, сумме в банке и любимом животном \n"); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет один аргумент
//управляющая строка ""
scanf("%d %f", &age, &assets); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем scanf() имеет три аргумента -> управляющая строка "" и УКАЗАТЕЛИ НА ПЕРЕМЕННЫЕ
scanf("%s", pet); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем scanf() имеет два аргумент -> управляющая строка "" и УКАЗАТЕЛЬ НА ПЕРЕМЕННУЮ
printf("%D $%.2f %s\n", age, assets, pet); //ОПЕРАТОР ВЫЗОВА ФУНКЦИИ с именем printf() имеет четыре аргумента -> управляющая строка "" и СПИСОК ПЕРЕМЕННЫХ
return 0; //ОПЕРАТОР ВОЗВРАТА
}
