Для чего используется ключевое слово void. Смотреть что такое "void" в других словарях
Теги: void*, пустые указатели, неопределённые указатели.
Указатели типа void
В си существует особый тип указателей – указатели типа void или пустые указатели. Эти указатели используются в том случае, когда тип переменной не известен. Так как void не имеет типа, то к нему не применима операция разадресации (взятие содержимого) и адресная арифметика, так как неизвестно представление данных. Тем не менее, если мы работаем с указателем типа void, то нам доступны операции сравнения.
Если необходимо работать с пустым указателем, то сначала нужно явно привести тип. Например
#include
Переменная не может иметь типа void, этот тип определён только для указателей. Пустые указатели нашли широкое применение при вызове функций. Можно написать функцию общего назначения, которая будет работать с любым типом. Например, напишем функцию swap, которая обменивает местами содержимое двух переменных. У этой функции будет три аргумента – указатели на переменные, которые необходимо обменять местами и их размер.
#include
Наша функция может выглядеть и по-другому. Обойдёмся без дорогостоящего выделения памяти и будем копировать побайтно.
Void swap(void *a, void *b, size_t size) { char tmp; size_t i; for (i = 0; i < size; i++) { tmp = *((char*) b + i); *((char*) b + i) = *((char*) a + i); *((char*) a + i) = tmp; } }
Пустые указатели позволяют создавать функции, которые возвращают и принимают одинаковые параметры, но имеют разное название. Это пригодится в дальнейшем, при изучении указателей на функции. Например
Int cmpInt(void* a, void* b) { return *((int*) a) - *((int*) b); } int cmpString(void *a, void* b) { return strcmp((char*) a, (char*) b); } int cmpFloat(void* a, void* b) { float fdiff = *((float*) a) - *((float*) b); if (fabs(fdiff) < 0.000001f) { return 0; } if (fdiff < 0) { return -1; } else { return 1; } }
Ru-Cyrl 18- tutorial Sypachev S.S. 1989-04-14 [email protected] Stepan Sypachev students
Всё ещё не понятно? – пиши вопросы на ящик
Для чего нужны функции в C?
Функции в Си применяются для выполнения определённых действий в рамках общей программы. Программист сам решает какие именно действия вывести в функции. Особенно удобно применять функции для многократно повторяющихся действий.
Простой пример функции в Cи
Пример функции в Cи:
#include
Это очень простая программа на Си. Она просто выводит строку «Functions in C». В программе имеется единственная функция под названием main. Рассмотрим эту функцию подробно. В заголовке функции, т.е. в строке
int – это тип возвращаемого функцией значения;
main - это имя функции;
(void) - это перечень аргументов функции. Слово void указывает, что у данной функции нет аргументов;
return – это оператор, который завершает выполнение функции и возвращает результат работы функции в точку вызова этой функции;
EXIT_SUCCESS - это значение, равное нулю. Оно определено в файле stdlib.h;
часть функции после заголовка, заключенная в фигурные скобки
{
puts("Functions in C");
return EXIT_SUCCESS;
}
называют телом функции.
Итак, когда мы работаем с функцией надо указать имя функции, у нас это main, тип возвращаемого функцией значения, у нас это int, дать перечень аргументов в круглых скобках после имени функции, у нас нет аргументов, поэтому пишем void, в теле функции выполнить какие-то действия (ради них и создавалась функция) и вернуть результат работы функции оператором return. Вот основное, что нужно знать про функции в C.
Как из одной функции в Cи вызвать другую функцию?
Рассмотрим пример вызова функций в Си:
/*
Author: @author Subbotin B.P..h>
#include
Запускаем на выполнение и получаем:
В этом примере создана функция sum, которая складывает два целых числа и возвращает результат. Разберём подробно устройство этой функции.
Заголовок функции sum:
int sum(int a, int b)
здесь int - это тип возвращаемого функцией значения;
sum - это имя функции;
(int a, int b) - в круглых скобках после имени функции дан перечень её аргументов: первый аргумент int a, второй аргумент int b. Имена аргументов являются формальными, т.е. при вызове функции мы не обязаны отправлять в эту функцию в качестве аргументов значения перемнных с именами a и b. В функции main мы вызываем функцию sum так: sum(d, e);. Но важно, чтоб переданные в функцию аргументы совпадали по типу с объявленными в функции.
В теле функции sum, т.е. внутри фигурных скобок после заголовка функции, мы создаем локальную переменную int c, присваиваем ей значение суммы a плюс b и возвращаем её в качестве результата работы функции опрератором return.
Теперь посмотрим как функция sum вызывается из функции main.
Вот функция main:
Int main(void) { puts("Functions in C"); int d = 1; int e = 2; int f = sum(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS; }
Сначала мы создаём две переменных типа int
Int d = 1; int e = 2;
их мы передадим в функцию sum в качестве значений аргументов.
int f = sum(d, e);
её значением будет результат работы функции sum, т.е. мы вызываем функцию sum, которая возвратит значение типа int, его-то мы и присваиваем переменной f. В качестве аргументов передаём d и f. Но в заголовке функции sum
int sum(int a, int b)
аргументы называются a и b, почему тогда мы передаем d и f? Потому что в заголовке функций пишут формальные аргументы, т.е. НЕ важны названия аргументов, а важны их типы. У функции sum оба аргумента имеют тип int, значит при вызове этой функции надо передать два аргумента типа int с любыми названиями.
Ещё одна тонкость. Функция должна быть объявлена до места её первого вызова. В нашем примере так и было: сначала объявлена функция sum, а уж после мы вызываем её из функции main. Если функция объявляется после места её вызова, то следует использовать прототип функции.
Прототип функции в Си
Рассмотрим пример функциив Си:
/*
Author: @author Subbotin B.P..h>
#include
В этом примере функция sum определена ниже места её вызова в функции main. В таком случае надо использовать прототип функции sum. Прототип у нас объявлен выше функции main:
int sum(int a, int b);
Прототип - это заголовок функции, который завершается точкой с запятой. Прототип - это объявление функции, которая будет ниже определена. Именно так у нас и сделано: мы объявили прототип функции
int f = sum(d, e);
а ниже функции main определяем функцию sum, которая предварительно была объявлена в прототипе:
Int sum(int a, int b) { int c = 0; c = a + b; return c; }
Чем объявление функции в Си отличается от определения функции в Си?
Когда мы пишем прототип функции, например так:
int sum(int a, int b);
то мы объявляем функцию.
А когда мы реализуем функцию, т.е. записываем не только заголовок, но и тело функции, например:
Int sum(int a, int b) { int c = 0; c = a + b; return c; }
то мы определяем функцию.
Оператор return
Оператор return завершает работу функции в C и возвращает результат её работы в точку вызова. Пример:
Int sum(int a, int b) { int c = 0; c = a + b; return c; }
Эту функцию можно упростить:
Int sum(int a, int b) { return a + b; }
здесь оператор return вернёт значение суммы a + b.
Операторов return в одной функции может быть несколько. Пример:
Int sum(int a, int b) { if(a > 2) { return 0;// Первый случай; } if(b < 0) { return 0;// Второй случай; } return a + b; }
Если в примере значение аргумента a окажется больше двух, то функция вернет ноль (первый случай) и всё, что ниже комментария «// Первый случай;» выполнятся не будет. Если a будет меньше двух, но b будет меньше нуля, то функция завершит свою работу и всё, что ниже комментария «// Второй случай;» выполнятся не будет.
И только если оба предыдущих условия не выполняются, то выполнение программы дойдёт до последнего оператора return и будет возвращена сумма a + b.
Передача аргументов функции по значению
Аргументы можно передавать в функцию C по значению. Пример:
/*
Author: @author Subbotin B.P..h>
#include
В примере, в функции main, создаём переменную int d = 10. Передаём по значению эту переменную в функцию sum(d). Внутри функции sum значение переменной увеличивается на 5. Но в функции main значение d не изменится, ведь она была передана по значению. Это означает, что было передано значение переменной, а не сама переменная. Об этом говорит и результат работы программы:
т.е. после возврата из функции sum значеие d не изменилось, тогда как внутри функции sum оно менялось.
Передача указателей функции Си
Если в качестве аргумента функции передавать вместо значения переменной указатель на эту переменную, то значение этой переменной может меняться. Для примера берём программу из предыдущего раздела, несколько изменив её:
/*
Author: @author Subbotin B.P..h>
#include
В этом варианте программы я перешел от передачи аргумента по значению к передаче указателя на переменную. Рассмотрим подробнее этот момент.
printf("sum = %d\n", sum(&d));
в функцию sum передается не значение переменной d, равное 10-ти, а адрес этой переменной, вот так:
Теперь посмотрим на функцию sum:
Int sum(int *a) { return *a += 5; }
Аргументом её является указатель на int. Мы знаем, что указатель - это переменная, значением которой является адрес какого-то объекта. Адрес переменной d отправляем в функцию sum:
Внутри sum указатель int *a разыменовывается. Это позволяет от указателя перейти к самой переменной, на которую и указывает наш указатель. А в нашем случае это переменная d, т.е. выражение
равносильно выражению
Результат: функция sum изменяет значение переменной d:
На этот раз изменяется значение d после возврата из sum, чего не наблюдалось в предыдущм пункте, когда мы передавали аргумент по значению.
C/C++ в Eclipse
Все примеры для этой статьи я сделал в Eclipse. Как работать с C/C++ в Eclipse можно посмотреть . Если вы работаете в другой среде, то примеры и там будут работать.
До сих пор мы писали программы единым, функционально неделимым, кодом. Алгоритм программы находился в главной функции, причём других функций в программе не было. Мы писали маленькие программы, поэтому не было потребности в объявлении своих функций. Для написания больших программ, опыт показывает, что лучше пользоваться функциями. Программа будет состоять из отдельных фрагментов кода, под отдельным фрагментом кода понимается функция. Отдельным, потому, что работа отдельной функции не зависит от работы какой-нибудь другой. То есть алгоритм в каждой функции функционально достаточен и не зависим от других алгоритмов программы. Однажды написав функцию, её можно будет с лёгкостью переносить в другие программы. Функция (в программировании) — это фрагмент кода или алгоритм, реализованный на каком-то языке программирования, с целью выполнения определённой последовательности операций. Итак, функции позволяют сделать программу модульной, то есть разделить программу на несколько маленьких подпрограмм (функций), которые в совокупности выполняют поставленную задачу. Еще один огромнейший плюс функций в том, что их можно многократно использовать. Данная возможность позволяет многократно использовать один раз написанный код, что в свою очередь, намного сокращает объем кода программы!
Кроме того, что в С++ предусмотрено объявление своих функций, также можно воспользоваться функциями определёнными в стандартных заголовочных файлах языка программирования С++. Чтобы воспользоваться функцией, определённой в заголовочном файле, нужно его подключить. Например, чтобы воспользоваться функцией, которая возводит некоторое число в степень, нужно подключить заголовочный файл
// inc_func.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
//действие 1 - подключаем заголовочный файл
// код Code::Blocks
// код Dev-C++
// inc_func.cpp: определяет точку входа для консольного приложения.
//действие 1 - подключаем заголовочный файл
Подключение заголовочных файлов выполняется так, как показано в строке 5
, т. е. объявляется препроцессорная директива #include , после чего внутри знаков <> пишется имя заголовочного файла. Когда подключен заголовочный файл, можно использовать функцию, что, и сделано в строке 9
.Функция pow() возводит число 3.14
в квадрат и присваивает полученный результат переменной power , где
pow — имя функции;
числа 3.14 и 2 — аргументы функции;
Всегда после имени функции ставятся круглые скобочки, внутри которых, функции передаются аргументы, и если аргументов несколько, то они отделяются друг от друга запятыми. Аргументы нужны для того, чтобы функции передать информацию. Например, чтобы возвести число 3.14 в квадрат используя функцию pow() , нужно как-то этой функции сообщить, какое число, и в какую степень его возводить. Вот именно для этого и придуманы аргументы функций, но бывают функции, в которых аргументы не передаются, такие функции вызываются с пустыми круглыми скобочками. Итак, для того, чтобы воспользоваться функцией из стандартного заголовочного файла С++ необходимо выполнить два действия:
- Подключить необходимый заголовочный файл;
- Запустить нужную функцию.
Кроме вызова функций из стандартных заголовочных файлов, в языке программирования С++ предусмотрена возможность создания собственных функций. В языке программирования С++ есть два типа функций:
- Функции, которые не возвращают значений
- Функции, возвращающие значение
Функции, не возвращающие значения, завершив свою работу, никакого ответа программе не дают. Рассмотрим структуру объявления таких функций.
// структура объявления функций не возвращающих значений void /*имя функции*/(/*параметры функции*/) // заголовок функции { // тело функции }
Строка 2 начинается с зарезервированного слова void — это тип данных, который не может хранить какие-либо данные. Тип данных void говорит о том, что данная функция не возвращает никаких значений. void никак по-другому не используется и нужен только для того, чтобы компилятор мог определить тип функции. После зарезервированного слова void пишется имя функции. Сразу за именем функции ставятся две круглые скобочки, открывающаяся и закрывающаяся. Если нужно функции передавать какие-то данные, то внутри круглых скобочек объявляются параметры функции, они отделяются друг от друга запятыми. Строка 2 называется заголовком функции. После заголовка функции пишутся две фигурные скобочки, внутри которых находится алгоритм, называемый телом функции. Разработаем программу, в которой объявим функцию нахождения факториала, причём функция не должна возвращать значение.
// код Code::Blocks
// код Dev-C++
После того, как были подключены все необходимые заголовочные файлы, можно объявлять функцию нахождения факториала.Под объявлением функции подразумевается выбор имени функции, определение параметров функции и написание алгоритма, который является телом функции. После выполнения этих действий функцию можно использовать в программе. Так как функция не должна возвращать значение, то тип возвращаемых данных должен быть void . Имя функции — faktorial , внутри круглых скобочек объявлена переменная numb типа int . Эта переменная является параметром функции faktorial() . Таким образом, все объявления в строке 8 в совокупности составляют заголовок функции. Строки 9 — 14 составляют тело функции faktorial() . Внутри тела в строке 10 объявлена переменная rezult , которая будет хранить результат нахождения n! После чего, в строках 11-12 Объявлен оператор цикла for для нахождения факториала. В строке 13 объявлен оператор cout , с помощью которого значение факториала будет печататься на экране. Теперь, когда функция объявлена можно воспользоваться ею. В строке 21 запускается функция faktorial(digit) , внутри скобочек функции передаётся аргумент, т. е. значение, содержащееся в переменной digit . Результат работы программы (см. Рисунок 1).
Рисунок 1 — Функции в С++
Итак, после запуска программы, было введена цифра 5, и программа вычислила, что значение 120 это 5!.
Функции, возвращающие значение, по завершению своей работы возвращают определённый результат. Такие функции могут возвращать значение любого типа данных. Структура функций, возвращающих значение будет немного отличатся от структуры функций рассмотренных ранее.
// структура объявления функций возвращающих значения /*возвращаемый тип данных*/ /*имя функции*/(/*параметры функции*/) // заголовок функции { // тело функции return /*возвращаемое значение*/; }
Структура объявления функций осталась почти неизменной, за исключением двух строк. В заголовке функции сначала нужно определять возвращаемый тип данных, это может быть тип данных int , если необходимо возвратить целое число или тип данных float — для чисел с плавающей точкой. В общем, любой другой тип данных, всё зависит от того, что функция должна вернуть. Так как функция должна вернуть значение, то для этого должен быть предусмотрен специальный механизм, как в строке 5 . C помощью зарезервированного слова return можно вернуть значение, по завершении работы функции. Всё, что нужно, так это указать переменную, содержащую нужное значение, или некоторое значение, после оператора return . Тип данных возвращаемого значения в строке 5 должен совпадать с типом данных в строке 2 . Переделаем программу нахождения факториала так, чтобы функция faktorial() возвращала значение факториала.
// struct_func.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
#include
// код Code::Blocks
// код Dev-C++
// struct_func.cpp: определяет точку входа для консольного приложения.
#include
Теперь функция faktorial() имеет возвращаемый тип данных — int , так как n! — это целое число.В строке 13 объявлен оператор return , который возвращает значение, содержащееся в переменной rezult . В строке 21 выполняем запуск функции faktorial() ,возвращаемое значение которой отправляем в поток вывода с помощью оператора cout . Можно было бы написать так int fakt = faktorial(digit); — переменной типа int присваиваем возвращаемое значение функции faktorial() , после чего в переменной fakt будет храниться значение n! . Результат работы программы не изменился (см. Рисунок 2).
Enter number: 5 5! = 120 Для продолжения нажмите любую клавишу. . .
Рисунок 2 — Функции в С++
Мы рассмотрели два типа функций, причём объявление функций выполняли в области программы, после подключения заголовочных файлов, но до начала функции main() . Существует несколько способов объявления функций (см. Рисунок 3).
Рисунок 3 — Функции в С++
На рисунке 3 показаны 4 способа объявления функций в языке программирования С++. Рассмотрим структуры объявления функций в одном файле, с главной функцией. Функции можно объявлять в двух областях, до начала функции main() , после функции main() . До сих пор мы объявляли функции в одном файле, перед функцией main() — это самый простой из способов.
// struct_func.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" /*область 1 - объявление функций до начала main() место для объявления функций функциям объявленным в этой области не нужны прототипы */ int main(int argc, char* argv) { return 0; }
Если функции объявлять в области 1 , перед главной функцией, то прототипы для этих функций не нужны. Хорошему стилю программирования соответствует способ объявления функций после main() . Рассмотрим структуру такого объявления функций.
// struct_func.cpp: определяет точку входа для консольного приложения. #include "stdafx.h" // место для объявления прототипов функций int main(int argc, char* argv) { return 0; } /*область 2 - объявление функций после main() место для объявления функций */
// код Code::Blocks
// код Dev-C++
// struct_func.cpp: определяет точку входа для консольного приложения. // место для объявления прототипов функций int main(int argc, char* argv) { return 0; } /*область 2 - объявление функций после main() место для объявления функций */
Область объявления функций переместилась в самый конец программы, после main() . Что касается самого способа объявления функций, то он не поменялся. Но так как функции объявлены после main() , использовать их не получится, ведь порядок объявлений изменился и функция main() просто не будет видеть функции объявленные после. Так вот для того, чтобы эти функции можно было увидеть в main() существует понятие прототипа. Прототип функции — это заголовок функции, который объявляется перед функцией main() . И если объявить прототип функции, тогда функцию можно будет увидеть в main() .
// синтаксис объявления прототипа /*тип возвращаемых данных функции*/ /*имя функции*/(/*параметры функции*/);
Структура объявления прототипа очень схожа со структурой объявления функции. Разработаем программу, которая определяет, является ли введённое пятизначное число палиндромом. Палиндром — это число или текст, который читается одинаково как слева, так и справа: 93939; 49094; 11311.
// palindrom_func.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
#include // код Code::Blocks // код Dev-C++ // palindrom_func.cpp: определяет точку входа для консольного приложения.
#include В строке 7
объявлен прототип функции нахождения палиндрома пятизначных чисел. Обратите внимание на то, что прототип полностью должен совпадать с заголовком функции, но некоторые отличия все же есть. Например, то, что в прототипе имена параметров перечислять не надо, достаточно объявить их типы данных. В конце объявления прототипа всегда нужно ставить точку с запятой. В остальном объявление прототипа совпадает с объявлением заголовка одной функции. Прототип необходимо объявлять для каждой функции отдельно. Переменная out_number служит для временного хранения введённого числа. В строке 16
в условии оператора выбора if выполняется запуск функции palindrom5() . Аргументом для неё является переменная in_number . функция вернёт значение типа bool , и если функция вернёт true , то условие будет истинно, в противном случае — ложно. Можно было бы сначала присвоить значение, возвращаемое функцией, некоторой переменной, а потом эту переменную подставить в условие оператора выбора if , но это бы увеличило код программы на одну строку. В строках 23 — 40
объявлена функция palindrom5() , с одним параметром, через который функции передаётся пятизначное число. Переменные balance1 , balance2 , balance4 , balance5 объявлены в строке 25
, и необходимы для хранения разрядов пятизначного числа: первого, второго, четвёртого, пятого (нумерация — справа на лево). В строках 26, 29, 32, 35 выполняется одна и та же операция — остаток от деления. Операция остаток от деления отсекает по одному разряду справа налево и сохраняет их в переменные balance1 , balance2 , balance4 , balance5 соответственно. Причём операция остаток от деления чередуется с операцией обычного деления. Операция деления выполняется в строках 27
, 30
, 33
, и уменьшает введённое пятизначное число за шаг на один разряд. В строке 30
операция деления уменьшает введённое число сразу на два разряда, потому, что число пятизначное и средний разряд нас не интересует, он может быть любым. В строках 36 — 39
объявлен оператор выбора if , который сравнивает разряды пятизначного числа, и если они, соответствующим образом, равны, то функция вернёт значение true , иначе — false . Результат работы программы (см. Рисунок 4). Enter 5zn-e chislo: 12321
Number 12321 - palendrom
Для продолжения нажмите любую клавишу. . . Рисунок 4 — Функции в С++ До сих пор мы объявляли функции в одном файле, с основной программой, то есть там, где находится функция main() . В С++ существует возможность поместить объявления функций в отдельный файл, тогда необходимо будет подключать файл с функциями, как в случае с подключением стандартных заголовочных файлов. Есть два способа: К хорошему стилю программирования относится второй способ. Таким образом, если объявлять функции в другом файле, то делать это согласно способу два. Переделаем программу нахождения палиндрома так, чтобы объявление функции palindrom5() находилось в отдельном файле *.cpp . Файл *.h нужен для того, чтобы скрыть реализацию функций, т. е. в файле *.h будут содержаться прототипы функций. С помощью обозревателя решений MVS создаём файл типа *.h и называем его palendrom . // код файла palendrom.h
#ifndef palendrom
#define palendrom
bool palindrom5(int); // прототип функции нахождения палиндрома пятизначных чисел
#endif Директивы в строках 2,3,5
необходимо всегда объявлять в файлах с прототипами функций, причём прототипы функций всегда объявляются в файлах типа *.h . После директив записанных в строках 2,3
, но до директивы #endif объявляются прототипы функций. В строке 4 объявлен прототип функции palindrom5() . Объявление данной функции находится в файле palendrom.cpp , который предварительно тоже был создан с помощью обозревателя решений MVS. // содержимое файла palendrom.cpp
#include "stdafx.h"
#include "palendrom.h"
bool palindrom5(int number) // функция нахождения палиндрома пятизначных чисел
{
int balance1, balance2, balance4, balance5; // переменные хранящие промежуточные результаты
balance1 = number % 10; // переменной balance1 присвоили первый остаток
number = number / 10; // уменьшаем введённое число на один разряд
balance2 = number % 10; // переменной balance2 присвоили второй остаток
number = number / 100; // уменьшаем введённое число на два разряда
balance4 = number % 10; // переменной balance4 присвоили четвёртый остаток
number = number / 10; // уменьшаем введённое число на один разряд
balance5 = number % 10; // переменной balance5 присвоили пятый остаток
if ((balance1 == balance5) && (balance2 == balance4))
return true; // функция возвращает истинное значение
else
return false; // функция возвращает ложное значение
} // код Code::Blocks // код Dev-C++ // содержимое файла palendrom.cpp
#include "palendrom.h"
bool palindrom5(int number) // функция нахождения палиндрома пятизначных чисел
{
int balance1, balance2, balance4, balance5; // переменные хранящие промежуточные результаты
balance1 = number % 10; // переменной balance1 присвоили первый остаток
number = number / 10; // уменьшаем введённое число на один разряд
balance2 = number % 10; // переменной balance2 присвоили второй остаток
number = number / 100; // уменьшаем введённое число на два разряда
balance4 = number % 10; // переменной balance4 присвоили четвёртый остаток
number = number / 10; // уменьшаем введённое число на один разряд
balance5 = number % 10; // переменной balance5 присвоили пятый остаток
if ((balance1 == balance5) && (balance2 == balance4))
return true; // функция возвращает истинное значение
else
return false; // функция возвращает ложное значение
} В файле palendrom.cpp находится объявление функции palindrom5() . Так как файл palendrom.cpp является исполняемым файлом (*.cpp — исполняемые файлы), то в нём обязательно нужно подключить контейнер "stdafx.h" , как в строке 2
. Чтобы связать файл, где объявлена функция palindrom5() и файл с её прототипом, подключим заголовочный файл (файл с прототипом), это сделано в строке 3
. Обратите внимание на то, что при подключении созданного нами файла используются двойные кавычки, а не знаки больше, меньше. Осталось только запустить функцию palindrom5() в главном исполняемом файле func_palendrom.cpp . // func_palendrom.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
#include // код Code::Blocks // код Dev-C++ // func_palendrom.cpp: определяет точку входа для консольного приложения.
#include В строке 6
мы подключили файл с прототипом функции palindrom5() , после чего можно использовать эту функцию. Итак, мы разбили программу на три файла: Файл проекта связываем с заголовочным файлом, а заголовочный файл связываем с исполняемым файлом, в таком случае файл проекта увидит функцию palindrom5() и сможет её запустить. Среди современных языков программирования ключевое слово void впервые появилось в Си++ для поддержки концепции обобщенных указателей . Тем не менее, благодаря скорому заимствованию у Си++, первым нормативным документом, содержащим это ключевое слово, стал стандарт языка Си, опубликованный ANSI в 1989 г. В рамках языка Си++ void был стандартизован в 1998 г. Впоследствии ключевое слово void и связанные с ним языковые конструкции были унаследованы языками Java и C#, D. void expression === undefined; Семантика ключевого слова void не подчиняется общей семантике спецификаторов типа и зависит от способа употребления: f(long l)
{
/* ... */
} Схожим образом, определения функций, не имеющие параметров записывались с пустыми круглыми скобками: int main()
{
/* ... */
} В качестве обобщенного указателя использовался указатель на char . Более того, современные стандарты требуют, чтобы представление и требования по выравниванию для void -указателей были теми же, что для указателей на char , что означает взаимозаменяемость этих типов. Первый стандартный диалект Си (C89), хотя уже позволял записи с ключевым словом void , все же допускал такое использование неявного int в целях поддержки совместимости с существующим кодом. Современный диалект Си (C99) не допускает отсутствия спецификаторов типов в именах типов и объявлениях. Показаны примеры объявления функции, возвращающей void. void message(void) -(void) message; function message() : void Женитьба на богатой невесте в Петербурге не удалась Борису и он с этой же целью приехал в Москву. В Москве Борис находился в нерешительности между двумя самыми богатыми невестами – Жюли и княжной Марьей. Хотя княжна Марья, несмотря на свою некрасивость, и казалась ему привлекательнее Жюли, ему почему то неловко было ухаживать за Болконской. В последнее свое свиданье с ней, в именины старого князя, на все его попытки заговорить с ней о чувствах, она отвечала ему невпопад и очевидно не слушала его. Теги: Функции в си, прототип, описание, определение, вызов. Формальные параметры и фактические параметры. Аргументы функции, передача по значению, передача по указателю. Возврат значения.
Ч
ем дальше мы изучаем си, тем больше становятся программы. Мы собираем все действия в одну функцию main и по несколько раз копируем
одни и те же действия, создаём десятки переменных с уникальными именами. Наши программы распухают и становятся всё менее и менее понятными, ветвления становятся всё длиннее
и ветвистее. Но из сложившейся ситуации есть выход! Теперь мы научимся создавать функции на си. Функции, во-первых, помогут выделить в отдельные подпрограммы дублирующийся код, во-вторых,
помогут логически разбить программу на части, в-третьих, с функциями в си связано много особенностей, которые позволят использовать новые подходы к структурированию приложений. Функция – это именованная часть программы, которая может быть многократно вызвана из другого участка программы (в котором эта функция видна). Функция может принимать
фиксированное либо переменное число аргументов, а может не иметь аргументов. Функция может как возвращать значение, так и быть пустой (void) и ничего не возвращать. Мы уже знакомы с многими функциями и знаем, как их вызывать – это функции библиотек stdio, stdlib, string, conio и пр. Более того, main – это тоже функция.
Она отличается от остальных только тем, что является точкой входа при запуске приложения. Самый простой пример – функция, которая принимает число типа float и возвращает квадрат этого числа
#include Внутри функции sqr мы создали локальную переменную, которой присвоили значение аргумента. В качестве аргумента функции передали число 9,3.
Служебное слово return возвращает значение переменной tmp. Можно переписать функцию следующим образом: Float sqr(float x) {
return x*x;
}
В данном случае сначала будет выполнено умножение, а после этого возврат значения. В том случае, если функция ничего не возвращает, типом возвращаемого значения будет void.
Например, функция, которая печатает квадрат числа: Void printSqr(float x) {
printf("%d", x*x);
return;
}
в данном случа return означает выход из функции. Если функция ничего не возвращает, то return можно не писать. Тогда функция доработает до конца и произойдёт возврат
управления вызывающей функции. Void printSqr(float x) {
printf("%d", x*x);
}
Если функция не принимает аргументов, то скобки оставляют пустыми. Можно также написать слово void: Void printHelloWorld() {
printf("Hello World");
}
эквивалентно Void printHelloWorld(void) {
printf("Hello World");
}
П
ри объявлении функции указываются формальные параметры, которые потом используются внутри самой функции.
При вызове функции мы используем фактические параметры. Фактическими параметрами могут быть переменные любого подходящего типа или
константы. Например, пусть есть функция, которая возвращает квадрат числа и функция, которая суммирует два числа.
#include Обращаю внимание, что приведение типов просиходит неявно и только тогда, когда это возможно. Если функция получает число
в качестве аргумента, то нельзя ей передать переменную строку, например "20" и т.д. Вообще, лучше всегда использовать верный тип
или явно приводить тип к нужному.
#include При передаче аргументов происходит их копирование. Это значит, что любые изменения, которые функция производит над переменными, имеют место быть только внутри функции. Например
#include Программы выведет
#include Вот теперь программа выводит В программировании первый способ передачи параметров называют передачей по значению, второй – передачей по указателю.
Запомните простое правило: если вы хотите изменить переменную, необходимо передавать функции указатель на эту переменную. Следовательно, чтобы изменить указатель, необходимо передавать указатель на указатель и т.д.
Например, напишем функцию, которая будет принимать размер массива типа int и создавать его. С первого взгляда, функция должна выглядеть как-то так:
#include Но эта функция выведет ERROR. Мы передали адрес переменной. Внутри функции init была создана локальная переменная a, которая хранит адрес массива. После выхода из
функции эта локальная переменная была уничтожена. Кроме того, что мы не смогли добиться нужного результата, у нас обнаружилась утечка памяти: была выделена память на куче,
но уже не существует переменной, которая бы хранила адрес этого участка. Для изменения объекта необходимо передавать указатель на него, в данном случае – указатель на указатель.
#include Вот теперь всё работает как надо.
#include В этом примере утечки памяти не происходит. Мы выделили память с помощью функции malloc, скопировали туда строку, а после этого вернули указатель. Локальные переменные были
удалены, но переменная test хранит адрес участка памяти на куче, поэтому можно его удалить с помощью функции free. В
си можно объявить функцию до её определения. Объявление функции, её прототип, состоит из возвращаемого
значения, имени функции и типа аргументов. Имена аргументов можно не писать. Например
#include Это смешанная рекурсия – функция odd возвращает 1, если число нечётное и 0, если чётное. Обычно объявление функции помещают отдельно, в.h файл, а определение функций в.c файл. Таким образом, заголовочный файл представляет
собой интерфейс библиотеки и показывает, как с ней работать, не вдаваясь в содержимое кода. Давайте создадим простую библиотеку. Для этого нужно будет создать два файла – один с расширением.h и поместить туда прототипы функций,
а другой с расширением.c и поместить туда определения этих функций. Если вы работаете с IDE, то.h файл необходимо создавать в папке
Заголовочные файлы, а файлы кода в папке Файлы исходного кода. Пусть файлы называются File1.h и File1.c
#ifndef _FILE1_H_
#define _FILE1_H_
int odd(int);
int even(int);
#endif
Содержимое файла исходного кода File1.c
#include "File1.h"
int even(int a) {
if (a) {
odd(--a);
} else {
return 1;
}
}
int odd(int a) {
if (a) {
even(--a);
} else {
return 0;
}
}
Наша функция main
#include Рассмотрим особенности каждого файла. Наш файл, который содержит функцию main, подключает необходимые ему библиотеки а также заголовочный
файл File1.h. Теперь компилятору известны прототипы функций, то есть он знает возвращаемый тип, количество и тип аргументов и имена
функций. Заголовочный файл, как и оговаривалось ранее, содержит прототип функций. Также здесь могут быть подключены используемые библиотеки.
Макрозащита #define _FILE1_H_ и т.д. используется для предотвращения повторного копирования кода библиотеки при компиляции.
Эти строчки можно заменить одной
#pragma once
int odd(int);
int even(int);
Файл File1.c исходного кода подключает свой заголовочный файл. Всё как обычно логично и просто. В заголовочные файлах принято кроме
прототипов функций выносить константы, макроподстановки и определять новые типы данных. Кроме того, именно в заголовочных файлах можно
обширно комментировать код и писать примеры его использования. К
ак уже говорилось ранее, имя массива подменяется на указатель, поэтому передача одномерного массива эквивалентна передаче указателя. Пример:
функция получает массив и его размер и выводит на печать:
#include В этом примере функция может иметь следующий вид Void printArray(int arr, unsigned size) {
unsigned i;
for (i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
}
Также напомню, что правило подмены массива на указатель не рекурсивное. Это значит, что необходимо указывать размерность двумерного массива при передаче
#include Либо, можно писать
#include Если двумерный массив создан динамически, то можно передавать указатель на указатель. Например функция, которая получает массив слов и возвращает массив целых,
равных длине каждого слова:
#include Можно вместо того, чтобы возвращать указатель на массив, передавать массив, который необходимо заполнить
#include На этом первое знакомство с функциями заканчивается: тема очень большая и разбита на несколько статей.Синтаксис
Синтаксически, void является одним из спецификаторов типа, входящих в более общую группу спецификаторов объявления , но в некоторых языках программирования реализован в виде оператора. Например, в языке JavaScript void является оператором и всегда возвращает undefined: Семантика
Язык Си до введения void
До публикации первого стандарта Си в 1989 г., которая ввела в язык ключевое слово void общепринятой практикой было объявлять функции, не возвращающие значений без использования спецификаторов типов. Хотя семантически такое объявление было эквивалентно объявлению функции, возвращающей значение типа int , намеренно опущенные спецификаторы типа подчеркивали, что функция не возвращает никакого определенного значения. Например: Примеры
C++
Java
C#
C
Objective-C
D
ActionScript
Напишите отзыв о статье "Void"
Примечания
Неинтерпретируемые
Числовые
Текстовые
Ссылочные
Композитные
Другие
Связанные темы
Отрывок, характеризующий Void
– Я не знаю, как отвечать на ваш вопрос, – сказал он, покраснев, сам не зная от чего. – Я решительно не знаю, что это за девушка; я никак не могу анализировать ее. Она обворожительна. А отчего, я не знаю: вот всё, что можно про нее сказать. – Княжна Марья вздохнула и выражение ее лица сказало: «Да, я этого ожидала и боялась».
– Умна она? – спросила княжна Марья. Пьер задумался.
– Я думаю нет, – сказал он, – а впрочем да. Она не удостоивает быть умной… Да нет, она обворожительна, и больше ничего. – Княжна Марья опять неодобрительно покачала головой.
– Ах, я так желаю любить ее! Вы ей это скажите, ежели увидите ее прежде меня.
– Я слышал, что они на днях будут, – сказал Пьер.
Княжна Марья сообщила Пьеру свой план о том, как она, только что приедут Ростовы, сблизится с будущей невесткой и постарается приучить к ней старого князя.
Жюли, напротив, хотя и особенным, одной ей свойственным способом, но охотно принимала его ухаживанье.
Жюли было 27 лет. После смерти своих братьев, она стала очень богата. Она была теперь совершенно некрасива; но думала, что она не только так же хороша, но еще гораздо больше привлекательна, чем была прежде. В этом заблуждении поддерживало ее то, что во первых она стала очень богатой невестой, а во вторых то, что чем старее она становилась, тем она была безопаснее для мужчин, тем свободнее было мужчинам обращаться с нею и, не принимая на себя никаких обязательств, пользоваться ее ужинами, вечерами и оживленным обществом, собиравшимся у нее. Мужчина, который десять лет назад побоялся бы ездить каждый день в дом, где была 17 ти летняя барышня, чтобы не компрометировать ее и не связать себя, теперь ездил к ней смело каждый день и обращался с ней не как с барышней невестой, а как с знакомой, не имеющей пола.
Дом Карагиных был в эту зиму в Москве самым приятным и гостеприимным домом. Кроме званых вечеров и обедов, каждый день у Карагиных собиралось большое общество, в особенности мужчин, ужинающих в 12 м часу ночи и засиживающихся до 3 го часу. Не было бала, гулянья, театра, который бы пропускала Жюли. Туалеты ее были всегда самые модные. Но, несмотря на это, Жюли казалась разочарована во всем, говорила всякому, что она не верит ни в дружбу, ни в любовь, ни в какие радости жизни, и ожидает успокоения только там. Она усвоила себе тон девушки, понесшей великое разочарованье, девушки, как будто потерявшей любимого человека или жестоко обманутой им. Хотя ничего подобного с ней не случилось, на нее смотрели, как на такую, и сама она даже верила, что она много пострадала в жизни. Эта меланхолия, не мешавшая ей веселиться, не мешала бывавшим у нее молодым людям приятно проводить время. Каждый гость, приезжая к ним, отдавал свой долг меланхолическому настроению хозяйки и потом занимался и светскими разговорами, и танцами, и умственными играми, и турнирами буриме, которые были в моде у Карагиных. Только некоторые молодые люди, в числе которых был и Борис, более углублялись в меланхолическое настроение Жюли, и с этими молодыми людьми она имела более продолжительные и уединенные разговоры о тщете всего мирского, и им открывала свои альбомы, исписанные грустными изображениями, изречениями и стихами.
Жюли была особенно ласкова к Борису: жалела о его раннем разочаровании в жизни, предлагала ему те утешения дружбы, которые она могла предложить, сама так много пострадав в жизни, и открыла ему свой альбом. Борис нарисовал ей в альбом два дерева и написал: Arbres rustiques, vos sombres rameaux secouent sur moi les tenebres et la melancolie. [Сельские деревья, ваши темные сучья стряхивают на меня мрак и меланхолию.]
В другом месте он нарисовал гробницу и написал:
«La mort est secourable et la mort est tranquille
«Ah! contre les douleurs il n"y a pas d"autre asile».
[Смерть спасительна и смерть спокойна;
О! против страданий нет другого убежища.]
Жюли сказала, что это прелестно.
– II y a quelque chose de si ravissant dans le sourire de la melancolie, [Есть что то бесконечно обворожительное в улыбке меланхолии,] – сказала она Борису слово в слово выписанное это место из книги.Введение
Функция в си определяется в глобальном контексте. Синтаксис функции:
(, ...) {
}
Формальные и фактические параметры
Если функция возвращает значение, то оно не обязательно должно быть сохранено. Например, мы пользуемся функцией getch, которая считывает символ и возвращает его.Передача аргументов
200
100
200
Понятно почему. Внутри функции мы работаем с переменной x, которая является копией переменной d. Мы изменяем локальную копию, но сама переменная d при этом не меняется.
После выхода из функции локальная переменная будет уничтожена. Переменная d при этом никак не изменится.
Каким образом тогда можно изменить переменную? Для этого нужно передать адрес этой переменной. Перепишем функцию, чтобы она принимала указатель типа int
200
100
100
Здесь также была создана локальная переменная, но так как передан был адрес, то мы изменили значение переменной d, используя её адрес в оперативной памяти.
Ещё подобный пример. Напишем функцию, которая принимает в качестве аргумента строку и возвращает указатель на область памяти, в которую скопирована эта строка.Объявление функции и определение функции. Создание собственной библиотеки
Перепишем предыдущий код. Вот так будет выглядеть заголовочный файл File1.hПередача массива в качестве аргумента
