Как в языке c называют именованную последовательность инструкций

Язык Си. Функция, пишем свою функцию. Технические детали.

лекция № 2 — Функция, пишем свою функцию. Часть 1.

лекция № 2 — Функция, пишем свою функцию. Часть 2.

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

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

Синтаксис объявления функции:

тип имя(список параметров через запятую);

 void foo(); 

Описание функции без тела(без реализации) называется объявлением.
Описание функции с телом(с реализацией) называется объявлением и определением. Обычно объявление функций делается в заголовочных файлах(.h), а определение в файлах реализации(.c).
Если в текущей единице трансляции  присутствует только объявление функции(не берем в счет ошибки программиста), это значит что реализация функции находится в другой единице трансляции. Вы должны были уже заметить что для вывода сообщений на экран, мы использовали функцию printf(), для этого нам нужно было ввести это имя в нашу единицу трансляции, мы это делали с помощью подключения заголовочного файла #include<stdio.h>, а вот реализации этой функции мы не наблюдали, все нормально, на этапе компоновки, компоновщик увидит использование функции printf(), найдет ее объявление в заголовочном файле, далее, он не найдет ее реализации в исходном коде, и начнет искать ее готовую реализацию в библиотеках которые присоеденены к проекту. К нашему проекту автоматически присоединяются(линкуются) стандартные библиотеки языка(если этого требует исходный код). Функция может возвращать значение любого из законченных типов (стандартных или пользовательских), либо не возвращать ничего(для этого ее тип должен быть void). Точно так же, функция может принимать аргументы, или не принимать их СОВСЕМ, рассмотрим пример ниже:

void foo_a()
{
}
void foo_b(void)
{
}

Функция foo_a() определена как функция без параметров, но это не так!
В языке Си это означает что аргументов может не быть, или они могут быть, но их количество может меняться (аналогия со стандартной библиотечной функцией printf(), в которой количество аргументов всегда разное). Каким способом узнать сколько аргументов было передано, это отдельная тема.
Что касается второй функции foo_b(), то в месте отведенном для описания параметров, мы четко указали void что означает НИКАКИХ АРГУМЕНТОВ. Посмотрите на пример ниже, и попробуйте его отдать компилятору

void foo_a()
{
}
void foo_b(void)
{
}
int main()
{
  foo_a();
  foo_a(1);
  foo_a(1,2,3);
  foo_b();
  foo_b(1);     // compilation error
  return 0;
} 

#include <math.h>
double triangle_area_herons(double aA, double aB, double aC)
{
  double p = (aA + aB + aC) / 2.;
  return sqrt(p *(p - aA) * (p - sB) * (p - sC));
}

#include <math.h>
#include <stdio.h>
double triangle_area_herons(double aA, double aB, double aC)
{
  double p = (aA + aB + aC) / 2.;
  return sqrt(p *(p - aA) * (p - sB) * (p - sC));
}
int main()
{
 double tr_area = 0.0;
 
 tr_area = triangle_area_herons(12., 10., 6.);
 printf("Area of triangle 1 = %dn", tr_area);
 printf("Area of triangle 2 = %dn", triangle_area_herons(1., 2., 3.));
 
 return 0;
}

void foo_a()        // external linkage
{
}
extern void foo_b() // external linkage
{
}
static void foo_c() // internal linkage
{
}
int main()          // external linkage
{
  foo_a();
  foo_b();
  foo_c(); 
  return 0;
}

extern void hello();
int main()
{
  hello();
  return 0;
} 

#include <stdio.h>
void hello()
{
  printf("I am from another translation unit!n");
}

После сборки программы, на экране появится нужное нам сообщение
Но стоит вам изменить void hello() на static void hello(), то вы получите ошибку при сборке.
Есть очень хорошая программа для того чтобы определить, какие обьекты являются со внешней связью а какие с внутренней, называется она NM из GNU Binary Utils, если вы используете один из дистрибутивов Linux(крайне рекомендую, особенно при изучении программирования) то проблем не должно быть с ее использованием, если же Windows … то …
вас никто не заставлял использовать Windows , в принципе можно установить Linux Terminal под Windows, называется он Cygwin при установке которого, можно установить практически все полезные программы из Linux.

#!/bin/bash
clear
gcc -c main.c
nm -C main.o
#nm -C --extern-only main.o
#nm --defined-only main.o
#nm --undefined-only main.o

Если его выполнить в корне со следующим файлом,
main.c

void foo_a()        // external linkage
{
}
extern void foo_b() // external linkage
{
}
static void foo_c() // internal linkage
{
}
int main()          // external linkage
{
  foo_a();
  foo_b();
  foo_c(); 
  return 0;
}

То на экране вы увидите:
0000000000000000 T  foo_a
0000000000000007 T  foo_b
000000000000000e  t  foo_c
0000000000000015  T main
Где большие буковки, означают что функция со внешней связью, о том что и какие буковки означают, читайте в справке к NM, выше ссылка уже была, и есть она еще и тут

Цель
занятия:

1. Знакомство
   с интегрированной средой разработки
   Visual
   C++
   CLR
   для создания консольных приложений.

2. Изучить
   общую структуру программы на языке
   С++.

Время
на выполнение работы:
2 часа

Учебные
вопросы:

1. Классическая
   первая
   программа

2. Компиляция

3. Редактирование
   связей

4. Среда
   программирования

Подготовка
к выполнению работы:

1. Изучить
   рекомендованную литературу.

2. Изучить
   материал настоящего руководства.

Материалы
для подготовки к занятию:

1. Конспект
   лекций

2. [1]
   стр. 15-22

3. [2]
   стр. 13-30

4. [3]
   стр. 29-62

Приведем вариант
классической первой программы.

//
Эта программа выводит на экран сообщение
«Hello,World!»

#include
<iostream.h>

int
main{)
//Программы
на C++
начинаются с выполнения функции main

{

cout
<< «Hello, World!n»; //
вывод «Hello,World!»

return
0;

}

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

cout
<< “Hello, World!n»; //вывод
“Hello,World!”

Именно эта строка
выводит сообщение на экран. Она печатает
символы Hello,
world!,
за которыми следует символ перехода на
новую строку; иначе говоря, после вывода
символов Hello,World!
курсор будет установлен на начало новой
строки. Курсор
— это
небольшой мерцающий символ или строка,
показывающая, где будет выведен следующий
символ.

В языке C++ строковые
литералы выделяются двойными кавычками
(“);
т.е. “Hello,
Word!n”
— это строка символов. Символ n
— это специальный символ, означающий
переход на новую строку. Имя cout
относится к стандартному потоку вывода.
Символы, «выведенные в поток cout»
с помощью оператора вывода <<,
будут отображены на экране. Имя cout
произносится как «see-out»,
но является аббревиатурой «character
output
stream»
(«поток вывода символов»). Аббревиатуры
довольно широко распространены в
программировании. Естественно,
аббревиатура на первых порах может
показаться неудобной для запоминания,
но привыкнув, вы уже не сможете от них
отказаться, так как они позволяют
создавать короткие и управляемые
программы.

Конец строки

//
вывод «Hello,World!»

является комментарием.
Все, что написано после символа //
(т.е. после двойной косой черты (/),
которая называется слэшем), считается
комментарием. Он игнорируется компилятором
и предназначен для программистов,
которые будут читать программу.
Многострочный комментарий помещают
между символами /*
… */.

Строка

#include
<iostream.h>

представляет собой
директиву #include.
Она заставляет компьютер «включить»
возможности, описанные в файле iostream.h.
Этот файл упрощает использование
возможностей, предусмотренных во всех
реализациях языках C++ (стандартной
библиотеке языка C++). Файл, включаемый
в программу с помощью директивы #include,
обычно имеет суффикс .h
и называется заголовком
(header),
или заголовочным
файлом (header
file).
Заголовок содержит определения терминов,
таких как cout,
которые мы используем в нашей программе.

Как компьютер
находит точку, с которой начинается
выполнение программы? Он просматривает
функцию с именем main
и начинает выполнять ее инструкции. Вот
как выглядит функция main
нашей программы «Hello,
World!»:

int
main
() //Программы
на C++
начинаются с выполнения функции main

{

cout
<< «Hello, World!n»; //вывод
«Hello,World!»

return
0;

}

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

• Тип возвращаемого
  значения, в
  этой функций — тип int
  (т.е. целое число), определяет, какой
  результат возвращает функция в точку
  вызова (если она возвращает какое-нибудь
  значение). Слово int
  является зарезервированным в языке
  C++ (ключевым
  словом), поэтому
  его нельзя использовать как имя
  чего-нибудь еще.

• Имя, в
  данном случае main.

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

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

Отсюда следует,
что минимальная программа на языке C++
выглядит так:

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #

8.10. Плодотворные (fruitful) функции и void-функции

Некоторые из функций, которые мы используем, такие, как математические
функции, возвращают результаты (приносят плоды); за неимением лучшего
названия, я называю их плодотворными функциями (fruitful functions).
Другие функции, подобные print_twice, выполняют некоторые действия, но
не возвращают значение. Они называются void-функциями.

Когда вы вызываете плодотворную функцию, вы почти всегда хотите сделать
что-то с результатом, например, вы можете присвоить его переменной или
использовать его как часть выражения:

x = math.cos(radians)
golden = (math.sqrt(5) + 1) / 2

Когда вы вызываете функцию в интерактивном режиме, Python отображает
результат:

>>> math.sqrt(5)
2.2360679774997898

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

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

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

>>> result = print_twice('Bing')
Bing
Bing
>>> print result
None

Значение None – это не тоже самое, что строка ‘None’. Это специальное
значение, которое имеет собственный тип:

>>> print type(None)
<type 'NoneType'>

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

def addtwo(a, b):
       added = a + b
       return added
x = addtwo(3, 5)
print x

Когда скрипт выполнится, инструкция print напечатает «8». Внутри функции
параметры a и b, в момент выполнения, будут содержать значения 3 и 5
соответственно. Функция подсчитывает сумму двух чисел и помещает ее в
локальную переменную added. Затем с помощью инструкции return результат
вычисления возвращается в вызываемый код, как результат выполнения
функции. Далее результат присваивается переменной x и выводится на экран.

8.11. Зачем нужны функции?

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

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

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

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

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

8.13. Словарь

Алгоритм (algorithm): обобщенный подход к решению категории проблем.

Аргумент (argument): значение, передаваемое функции, в момент ее вызова.
Это значение присваивается соответствующему параметру в функции.

Тело функции (body): последовательность инструкций внутри определения
функции.

Детерминистический (deterministic): относится к программе, которая
выполняет одинаковые действия при одинаковых входных значениях.

Точечная нотация (dot notation): синтаксис для вызова функции из другого
модуля.

Поток исполнения (flow of execution): порядок, в котором выполняются
инструкции во время работы программы.

Плодотворная функция (fruitful function): функция, которая возвращает
значение.

Функция (function): это именованная последовательность инструкций,
которая выполняет некоторые полезные действия. Функции могут иметь или
не иметь аргументы, могут возвращать или не возвращать результат.

Вызов функции (function call): инструкция, которая выполняет функцию. Она
содержит имя функции и список аргументов.

Определение функции (function definition): инструкция, которая создает новую
функцию; задает имя функции, параметры и инструкции для выполнения.

Функциональный объект (function object): значение, созданное определением
функции. Имя функции является переменной, которая ссылается на
функциональный объект.

Заголовок функции (header): первая строка в определении функции.

Инструкция импорта (import statement): инструкция, которая читает файл
модуля и создает модульный объект.

Модульный объект (module object): значение, которое создает инструкция
импорта, для предоставления доступа к данным и коду, определенном в
модуле.

Параметр (parameter): имя, используемое внутри функции, которое
ссылается на передающееся в качестве аргумента значение.

Псевдослучайный (pseudorandom): относится к последовательности чисел,
которые похожи на случайные, но генерируются детерминированной
программой.

Возвращаемое значение (return value): результат выполнения функции.

Void—функция (void function): функция, которая не возвращает
результирующего значения.

1


Функции Функция – именованная последовательность описаний и операторов, выполняющая некоторое действие. Может иметь параметры и возвращать значение. Функция должна быть объявлена и определена. Объявление функции (прототип, заголовок) задает имя, тип значения и список формальных параметров. Определение содержит кроме объявления тело функции в фигурных скобках. Вложенность функций в С++ не допускается!

2


Формат определения функции [класс] [inline] тип имя ( [список параметров] ) { тело функции } Класс определяет видимость функции extern — во всех файлах программы (по умолчанию) static – только в файле, в котором ф-ция определена Модификатор inline определяет функцию как встроенную. Компилятор по мере возможности будет вместо вызова функции помещать в точку вызова ее код. Тип может быть любым кроме массива (но может быть указателем на массив). Если значение не возвращается, используется void Список параметров определяет величины, значения которых передаются в функцию при ее вызове. Элементы списка разделяются запятыми. Для каждого параметра указывается тип и имя. В объявлениях имена можно опускать. Для возврата значения используется оператор return выражение

3


Вызов функции имя (список фактических параметров) Круглые скобки в С++ — операция с максимальным приоритетом // максимум трех чисел #include int max(int a, int b); int main() { int a, b, c; cout > a >> b >> c; cout b) return a; else return b; } Вызов функции без параметров: f()

4


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

5


Типы параметров Функции в С++ работают только с параметрами – значениями. Только массивы и функции передаются по адресу. Для передачи параметров по адресу используется либо указатель, либо ссылка. #include void f(int i, int* j, int& k) { i++; (*j)++; k++; } int main() { int i = 1, j = 1, k = 1; f( i, &j, k); cout

6


Параметры-константы. Значения по умолчанию. Указание перед именем параметра const запрещает его изменение. В заголовке у параметров могут быть указаны значения по умолчанию void f( const int n = 10);

7


Массивы как параметры Передается указатель на первый элемент. Если размер массива не является константой, то он должен передаваться внутрь функции. #include int sum(int mas[], const int n) { int s = 0; for (int i = 0; i < n; i++ ) s += mas[i]; return s; } int main() { const int n = 5; int marks[5] = { 1, 2, 3, 4, 5}; cout

8


Многомерные массивы Многомерные массивы передаются как двойные указатели ( int ** a). #include int sum(int **a, const int m, const int n) { int s = 0; for (int i = 0; i < m; i++ ) for (int j = 0; j < n; j++ ) s += a[i][j]; return s; } int main() { int m, n; cin >> m >> n; int **a, i, j; a = new int * [m]; for ( i = 0; i < m; i++) a[i] = new int [n]; for ( i = 0; i < m; i++) for (int j = 0; j > a[i][j]; cout

9


Рекурсивные функции long fact (long n) { return (n > 1) ? n * fact(n — 1) : 1; }

10


Перегрузка функций Одинаковые имена, но разные типы параметров. int max (int, int) char* max (char*, char*) Автоматическое преобразование типов может привести к неоднозначности Функции не могут быть перегружены, если отличаются только модификатором const или использованием ссылки.

11


Типы данных, определяемые пользователем typedef тип новое_имя [размер] Примеры: typedef unsigned long Cardinal; typedef char String [100]; Использование: const Cardinal p = ; String a,b,c;

12


Перечислимые типы Перечисления – способ определения числовых констант с различными значениями. Константы, не имеющие явно указанных значений, получают их в порядке возрастания. enum { список констант } Пример: enum {a, b, c=5, d} // a=0, b=1, c=5, d=6 Можно указать имя типа. Тогда переменной этого типа можно присваивать только одну из указанных констант Пример: enum year {winter, spring, summer, autumn}; year t; t = winter; cout

13


Структуры Аналог записей Паскаля. Содержат элементы разных типов. struct [имя типа] { тип1 имя1; тип2 имя2; … } [список_переменных];

14


Пример описания структуры #include struct student { char name[30], fam[30], gr[10]; int age; } vasya, group[25], *s; /* Для инициализации структуры значения полей берут в фигурные скобки */ student masha = {Mary», Ivanova», «05MOS1»,18}; int main() { s = &masha; cout fam; // обращение к полям }

15


Структуры как параметры Структуры могут передаваться в функции и служить возвращаемым значением. struct ratio { int m,n; }; ratio add (ratio a, ratio b) { ratio c; c.m = a.m * b.n + a.n * b.m; c.n = a.n * b.n; return c; }

16


Битовые поля Поля структуры с размером в битах. Размер указывается через двоеточие после имени. struct flags { bool iszero:1; bool isgreat:1; int palette:6; };

17


Объединения Аналог записей с вариантами. Все поля располагаются по одному и тому же адресу. Длина объединения равна длине наибольшего поля. Используются для экономии памяти. Часто включаются внутрь структур. Пример: enum typeworker {student, teacher}; struct worker{ char fam[100]; typeworker wtype; union department{ char chair[100]; int group; };