Си (язык программирования)

Материал из Википедии — свободной энциклопедии
Перейти к: навигация, поиск
Си
The C Programming Language logo.svg
Класс языка:

процедурный

Тип исполнения:

компилируемый

Появился в:

1972

Автор(ы):

Деннис Ритчи, Кен Томпсон

Расширение файлов:

.c - для файлов кода, .h - для заголовочных файлов

Выпуск:

C11 (декабрь 2011)

Система типов:

статическая слабая

Основные реализации:

GCC, TCC, Turbo C, Watcom, Oracle Solaris Studio C

Диалекты:

«K&R» C (1978)
ANSI C (1989)
C90 (1990)
C99 (1999)
C11 (2011)

Испытал влияние:

BCPL, B

Повлиял на:

C++, Objective-C, C#, Cyclone, Java, BitC[en]

ОС:

кроссплатформенное программное обеспечение

Си (англ. C) — компилируемый статически типизированный язык программирования общего назначения, разработанный в 1969—1973 годах сотрудником Bell Labs Деннисом Ритчи как развитие языка Би. Первоначально был разработан для реализации операционной системы UNIX, но, впоследствии, был перенесён на множество других платформ. Благодаря близости по скорости выполнения программ, написанных на Си, к языку ассемблера, этот язык получил широкое применение при создании системного программного обеспечения и прикладного программного обеспечения для решения широкого круга задач. Язык программирования Си оказал существенное влияние на развитие индустрии программного обеспечения, а его синтаксис стал основой для таких языков программирования как C++, C#, Java и D.


Содержание

История Си[править | править вики-текст]

Язык программирования Си был разработан в лабораториях Bell Labs в период с 1969 по 1973 годы. Согласно Ритчи, самый активный период творчества пришёлся на 1972 год. Язык назвали «Си» (C — третья буква латинского алфавита), потому что многие его особенности берут начало от старого языка «Би» (B — вторая буква латинского алфавита). Существует несколько различных версий происхождения названия языка Би. Кен Томпсон указывает на язык программирования BCPL, однако существует ещё и язык Bon, также созданный им, и названный так в честь его жены Бонни.

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

  • Разработка Си стала результатом того, что его будущие авторы любили компьютерную игру, подобную популярной игре Asteroids (Астероиды). Они уже давно играли в неё на главном сервере компании, который был недостаточно мощным и должен был обслуживать около ста пользователей. Томпсон и Ритчи посчитали, что им не хватает контроля над космическим кораблём для того, чтобы избегать столкновений с некоторыми камнями. Поэтому они решили перенести игру на свободный PDP-7, стоящий в офисе. Однако этот компьютер не имел операционной системы, что заставило их её написать. В конце концов, они решили перенести эту операционную систему ещё и на офисный PDP-11, что было очень тяжело, потому что её код был целиком написан на ассемблере. Было вынесено предложение использовать какой-нибудь высокоуровневый портируемый язык, чтобы можно было легко переносить ОС с одного компьютера на другой. Язык Би, который они хотели сначала задействовать для этого, оказался лишён функциональности, способной использовать новые возможности PDP-11. Поэтому они и остановились на разработке языка Си.
  • Самый первый компьютер, для которого была первоначально написана UNIX, предназначался для создания системы автоматического заполнения документов. Первая версия UNIX была написана на ассемблере. Позднее для того, чтобы переписать эту операционную систему, был разработан язык Си.

К 1973 году язык Си стал достаточно силён, и большая часть ядра UNIX, первоначально написанная на ассемблере PDP-11/20, была переписана на Си. Это было одно из самых первых ядер операционных систем, написанное на языке, отличном от ассемблера; более ранними были лишь системы Multics (написана на ПЛ/1) и TRIPOS (написана на BCPL).

K&R C[править | править вики-текст]

В 1978 году Брайан Керниган и Деннис Ритчи опубликовали первую редакцию книги «Язык программирования Си». Эта книга, известная среди программистов как «K&R», служила многие годы неформальной спецификацией языка. Версию языка Си, описанную в ней, часто называют «K&R C». Вторая редакция этой книги посвящена более позднему стандарту ANSI C, описанному ниже.

K&R ввёл следующие особенности языка:

  • структуры (тип данных struct);
  • длинное целое (тип данных long int);
  • целое без знака (тип данных unsigned int);
  • оператор += и подобные ему (старые операторы =+ вводили анализатор лексики компилятора Си в заблуждение, например, при сравнении выражений i =+ 10 и i = +10).

K&R C часто считают самой главной частью языка, которую должен поддерживать компилятор Си. Многие годы даже после выхода ANSI C, он считался минимальным уровнем, которого следовало придерживаться программистам, желающим добиться от своих программ максимальной переносимости, потому что не все компиляторы тогда поддерживали ANSI C, а хороший код на K&R C был верен и для ANSI C.

После публикации K&R C в язык было добавлено несколько возможностей, поддерживаемый компиляторами AT&T и некоторых других производителей:

  • функции, не возвращающие значение (с типом void) и указатели, не имеющие типа (с типом void *);
  • функции, возвращающие объединения и структуры;
  • имена полей данных структур в разных пространствах имён для каждой структуры;
  • присваивания структур;
  • спецификатор констант (const);
  • стандартная библиотека, реализующая большую часть функций, введённых различными производителями;
  • перечислимый тип (enum);
  • дробное число одинарной точности (float).

ISO C[править | править вики-текст]

В конце 1970-х годов Си начал вытеснять Бейсик с позиции ведущего языка для программирования микрокомпьютеров. В 1980-х годах он был адаптирован для использования в IBM PC, что привело к резкому росту его популярности. В то же время Бьёрн Страуструп и другие в лабораториях Bell Labs начали работу по добавлению в Си возможностей объектно-ориентированного программирования. Язык, который они в итоге сделали, C++, оказал большое влияние на разработку ПО, но так и не смог сравняться по популярности[1] с Си, особенно в UNIX-подобных системах.

В 1983 году Американский национальный институт стандартов (ANSI) сформировал комитет для разработки стандартной спецификации Си. По окончании этого долгого и сложного процесса в 1989 году он был наконец утверждён как «Язык программирования Си» ANSI X3.159-1989. Эту версию языка принято называть ANSI C или C89. В 1990 году стандарт ANSI C был принят с небольшими изменениями Международной организацией по стандартизации (ISO) как ISO/IEC 9899:1990.

Одной из целей этого стандарта была разработка надмножества K&R C, включающего многие особенности языка, созданные позднее. Однако комитет по стандартизации также включил в него и несколько новых возможностей, таких как прототипы функций (заимствованные из C++) и более сложный препроцессор.

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

  1. они используют нестандартные библиотеки, например, для графических дисплеев;
  2. они используют специфические платформо-зависимые средства;
  3. они рассчитаны на определённое значение размера некоторых типов данных или на определённый способ хранения этих данных в памяти для конкретной платформы.

C99[править | править вики-текст]

После стандартизации в ANSI спецификация языка Си оставалась относительно неизменной в течение долгого времени, в то время как C++ продолжал развиваться (в 1995 году в стандарт Си была внесена Первая нормативная поправка, но её почти никто не признавал). Однако в конце 1990-х годов стандарт подвергся пересмотру, что привело к публикации ISO 9899:1999 в 1999 году. Этот стандарт обычно называют «C99». В марте 2000 года он был принят и адаптирован ANSI.

Некоторые новые особенности C99:

  • подставляемые функции (inline);
  • объявление локальных переменных в любом операторе программного текста (как в C++);
  • новые типы данных, такие как long long int (для облегчения перехода от 32- к 64-битным числам), явный булевый тип данных _Bool и тип complex для представления комплексных чисел;
  • массивы переменной длины;
  • поддержка ограниченных указателей (restrict);
  • именованная инициализация структур: struct { int x, y, z; } point = { .y=10, .z=20, .x=30 };
  • поддержка однострочных комментариев, начинающихся на //, заимствованных из C++ (многие компиляторы Си поддерживали их и ранее в качестве дополнения);
  • несколько новых библиотечных функций, таких как snprintf;
  • несколько новых заголовочных файлов, таких как stdint.h.

Интерес к поддержке новых особенностей C99 в настоящее время[когда?] смешан. В то время как GCC[2], компилятор Си от Sun Microsystems и некоторые другие компиляторы в настоящее время поддерживают большую часть новых особенностей C99, компиляторы компаний Borland и Microsoft не делают этого, причём, похоже, что две эти компании и не думают их добавлять.

C11[править | править вики-текст]

8 декабря 2011 опубликован новый стандарт для языка Си (ISO/IEC 9899:2011)[3]. Некоторые возможности нового стандарта уже поддерживаются компиляторами GCC[4] и Clang[5]. Основные изменения:

  • поддержка многопоточности;
  • улучшенная поддержка юникода;
  • обобщенные макросы (type-generic expressions, позволяют статичную перегрузку);
  • анонимные структуры и объединения (упрощают обращение ко вложенным конструкциям);
  • управление выравниванием объектов;
  • статичные утверждения (static assertions);
  • удаление опасной функции gets (в пользу безопасной gets_s);
  • функция quick_exit;
  • спецификатор функции _Noreturn;
  • новый режим эксклюзивного открытия файла.


Введение в Си[править | править вики-текст]

Язык программирования Си отличается минимализмом. Авторы языка хотели, чтобы программы на нём легко компилировались с помощью однопроходного компилятора, чтобы каждой элементарной составляющей программы после компиляции соответствовало весьма небольшое число машинных команд, а использование базовых элементов языка не задействовало библиотеку времени выполнения. Однопроходный компилятор компилирует программу, не возвращаясь назад, к уже обработанному тексту. Поэтому использованию функций и переменных должно предшествовать их объявление. Код на Си можно легко писать на низком уровне абстракции, почти как на ассемблере. Иногда Си называют «универсальным ассемблером» или «ассемблером высокого уровня», что отражает различие языков ассемблера для разных платформ и единство стандарта Си, код которого может быть скомпилирован без изменений практически на любой модели компьютера. Си часто называют языком среднего уровня или даже низкого уровня, учитывая то, как близко он работает к реальным устройствам. Однако, в строгой классификации, он является языком высокого уровня.

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

Си (как и ОС UNIX, с которой он долгое время был связан) создавался программистами и для программистов, круг которых был бы ненамного шире круга разработчиков языка. Несмотря на это, область использования языка значительно шире задач системного программирования.

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

В то же время, в Си отсутствуют

а также, средства:

Часть отсутствующих возможностей относительно легко имитируется встроенными средствами (например, сопрограммы можно имитировать с помощью функций setjmp и longjmp), часть добавляется с помощью сторонних библиотек (например, для поддержки многозадачности и для сетевых функций можно использовать библиотеки pthreads, sockets и т. п.; существуют библиотеки для поддержки автоматической сборки мусора[6]), часть реализуется в некоторых компиляторах в виде расширений языка (например, вложенные функции в GCC).

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

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

Многие элементы Си потенциально опасны, а последствия неправильного использования этих элементов зачастую непредсказуемы. Керниган говорит: «Си — инструмент, острый, как бритва: с его помощью можно создать и элегантную программу, и кровавое месиво». В связи со сравнительно низким уровнем языка многие случаи неправильного использования опасных элементов не обнаруживаются и не могут быть обнаружены ни при компиляции, ни во время исполнения. Это часто приводит к непредсказуемому поведению программы. Иногда в результате неграмотного использования элементов языка появляются уязвимости в системе безопасности. Необходимо заметить, что использования многих таких элементов можно избежать.

Примером ошибки является обращение к несуществующему элементу массива. Несмотря на то, что Си непосредственно поддерживает статические массивы, он не имеет средств проверки индексов массивов (проверки границ). Например, возможна запись в шестой элемент массива из пяти элементов, что, естественно, приведёт к непредсказуемым результатам. Частный случай такой ошибки называется ошибкой переполнения буфера. Ошибки такого рода приводят к большинству проблем с безопасностью.

Другим потенциальным источником опасных ситуаций служит механизм указателей. Указатель может ссылаться на любой объект в памяти, включая и исполняемый код программы, и неправильное использование указателей может порождать непредсказуемые эффекты и приводить к катастрофичным последствиям. К примеру, указатель может быть неинициализированным или, в результате неверных арифметических операций над указателем, указывать в произвольное место памяти; на некоторых платформах работа с таким указателем может вызвать аппаратную остановку программы, на незащищённых же платформах это может привести к порче произвольных данных в памяти, причём эта порча может проявиться в самые произвольные моменты времени и намного позже момента порчи. Также, область динамической памяти, на которую ссылается указатель, может быть освобождена (и даже выделена после этого под другой объект) — такие указатели называются «висячими». Или, наоборот, после манипуляций с указателями на область динамической памяти может не остаться ссылок, и тогда эта область, называемая «мусором» (garbage), никогда не будет освобождена, что может приводить к «утечкам памяти» в программе. В других языках подобные проблемы пытаются решить введением более ограниченных ссылочных типов.

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

Ещё одной распространённой проблемой является то, что память не может быть использована снова, пока она не будет освобождена программистом с помощью функции free(). В результате программист может случайно забыть освобождать эту память, но продолжать её выделять, занимая всё большее и большее пространство. Это обозначается термином утечка памяти. Наоборот, возможно освободить память слишком рано, но продолжать её использовать. Из-за того, что система выделения может использовать освобождённую память по-другому, это ведёт к непредсказуемым последствиям. Эти проблемы решаются в языках со сборкой мусора. С другой стороны, если память выделяется в функции и должна освобождаться после выхода из функции, данная проблема решается с помощью автоматического вызова деструкторов в языке C++, или с помощью локальных массивов, используя расширения C99.

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

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

Синтаксис Си[править | править вики-текст]

Лексемы[править | править вики-текст]

В языке Си используются (являются допустимыми)

  • все символы латинского алфавита
    A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z
    a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
  • цифры
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9
  • и специальные символы
    , (запятая), ;,. (точка), +, -, *, ^, & (амперсанд), =, ~ (тильда), !, /, <, >, (, ), {, }, [, ], |, %, ?, ' (апостроф), " (кавычки), : (двоеточие), _ (знак подчёркивания)

Из допустимых символов формируются лексемыпредопределённые константы, идентификаторы и знаки операций. В свою очередь, лексемы являются частью выражений; а из выражений составляются инструкции и операторы.

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

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

Идентификаторы[править | править вики-текст]

Допустимый идентификатор — это слово (лексема), составленное из допустимых символов алфавита языка программирования, не являющееся знаком некоторой операции или разделителем.

Идентификаторы — это те имена, которые даются программным объектам — (именованным) константам, переменным, типам и функциям.

Некоторые лексемы являются зарезервированными (или, что то же самое, ключевыми) словами (см. ниже), и, поэтому, не могут быть использованы в программе в качестве идентификаторов программных объектов.

Предопределённые константы[править | править вики-текст]

Для введения в программе на Си именованных констант используется директива препроцессора #define:

#define имя константы [значение] ;.

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

#undefine имя константы;.

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

Если для именованной константы указано некоторое значение, то для константы определяется так же и тип, соответствующий виду задаваемого значения. Различают следующие типы констант:

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

Ключевые слова[править | править вики-текст]

Ключевые слова — это лексемы, которые зарезервированы компилятором для обозначения типов переменных, класса хранения, элементов операторов

Стандартом С89 предусмотрены следующие ключевые слова:

  • для указания операции получения размера объекта: sizeof
  • для описания прототипа объекта: typedef
  • для объявления переменных:
    для обозначения класса хранения переменных: auto, register
    для обозначения того, что объект описывается в другом месте extern
    для обозначения того, что объект статический static
  • для обозначения типа переменных char, short,int, long, signed, unsigned,float, double, void (для указания на произвольный родовой тип)
  • для обозначения специальных типов данных:
    struct (структура), enum (перечисление), union
  • для обозначения операторов и их элементов:
    для обозначения операторов цикла: do, for, while
    для обозначения условного оператора: if, else
    для обозначения оператора выбора: switch, case, default
  • для обозначения операторов перехода:
    операторы прерывания исполнения кода: break, continue
    для обозначения оператора безусловного перехода: goto
  • для обозначения оператора возврата из функции: return.

В стандарте C99 добавлены следующие ключевые слова:

  • для обозначения того, что функция является встраиваемой: inline
  • для обозначения типа переменной: _Bool, _Complex, _Imaginary
  • и для обозначения того, что restrict.


Операции[править | править вики-текст]

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

Операнд — это константа, переменная, выражение или вызов какой-либо определённой в программе функции. Операции различают по количеству задействованных операндов, а именно — различают

  • унарные операции — операции вида
    [знак операции] [операнд]
  • бинарные операции
    [операнд] [знак операции] [операнд]
  • и тернарные операции.

Унарные операции[править | править вики-текст]

Унарные операции — это операции, содержащие единственный операнд.

К унарным операциям в Си относятся следующие операции:

+ (унарный плюс), - (унарный минус), ~ (взятие обратного кода), ! (логическое отрицание), & (взятие адреса), * (операция разыменовывания указателя), sizeof (операция определения занимаемого объектом объёма памяти).

Бинарные операции[править | править вики-текст]

Бинарные операции — это операции, содержащие два операнда, между которыми расположен знак операции.

К бинарным операциям в Си относятся следующие операции:

+ (сложение), - (вычитание), * (умножение), / (деление), % (взятие остатка от деления), & (поразрядное И), | (поразрядное ИЛИ), ^ (поразрядное исключающее ИЛИ), && (логическое И), || (логическое ИЛИ).

Также к бинарным операциям в Си относятся операции, по сути представляющие собою присваивание:

+= (добавление к левому операнду значения, представленного правым операндом)
-= (вычитание из левого операнда значения, представленного правым операндом)
*= (умножение левого операнда на значение, представленное правым операндом)
/= (деление левого операнда на значение, представленное правым операндом)

Данные операции предполагают, что левый операнд представляет собою лево-допустимое выражение

.

Тернарные операции[править | править вики-текст]

В Си имеется единственная тернарная операция — условная операция, которая имеет следующий вид:

[условие]? [выражение1] : [выражение2] ;

и которая имеет три операнда:

  • [условие] — логическое условие, которое проверяется на истинность,
  • [выражение1] — выражение, значение которое возвращается в качестве результата выполнения операции, если условие истинно;
  • [выражение2] — выражение, значение которое возвращается в качестве результата выполнения операции, если условие ложно.

Знаком операции здесь служит целое сочетание ? :.

Выражения[править | править вики-текст]

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

Простейшее выражение содержит только имя переменной (её идентификатор). Значением такого выражения будет то значение (или тот объект), которое хранится в данной переменной.

Среди выражений выделяют класс лево-допустимых выражений — выражений, которые могут присутствовать слева от знака присваивания.

Приоритет выполнения операций[править | править вики-текст]

Операции в Си выполняются в соответствии следующей таблице приоритетов операций:

Лексемы Операция Класс Приоритет Ассоциативность
имена, литералы простые лексемы первичный 16 нет
a[k] индексы постфиксный 16 слева направо
f(…) вызов функции постфиксный 16 слева направо
. прямой выбор постфиксный 16 слева направо
-> опосредованный выбор постфиксный 16 слева направо
(имя типа) {init} составной литерал (C99) постфиксный 15 справа налево
++ -- положительное и отрицательное приращение постфиксный 15 справа налево
sizeof размер унарный 15 справа налево
~ побитовое НЕ унарный 15 справа налево
! логическое НЕ унарный 15 справа налево
- + изменение знака, плюс унарный 15 справа налево
& адрес унарный 15 справа налево
* опосредование (разыменование) унарный 15 справа налево
(имя типа) приведение типа унарный 15 справа налево
* / % мультипликативные операции бинарный 13 слева направо
+ - аддитивные операции бинарный 12 слева направо
<< >> сдвиг влево и вправо бинарный 11 слева направо
< > <= >= отношения бинарный 10 слева направо
== != равенство/неравенство бинарный 9 слева направо
& побитовое И бинарный 8 слева направо
^ побитовое исключающее ИЛИ бинарный 7 слева направо
| побитовое ИЛИ бинарный 6 слева направо
&& логическое И бинарный 5 слева направо
|| логическое ИЛИ бинарный 4 слева направо
? : условие тернарный 3 справа налево
= += -= *= /= %= <<= >>= &= ^= |= присваивание бинарный 2 справа налево
, последовательное вычисление бинарный 1 слева направо

Операторы[править | править вики-текст]

Операторы предназначены для осуществления действий и для управления ходом выполнения программы.

Несколько идущих подряд операторов образуют последовательность операторов.

Пустой оператор[править | править вики-текст]

Самый простой оператор — это пустой оператор:

;

Этот оператор не совершает никаких действий и может находиться в любом месте программы.

Инструкции[править | править вики-текст]

Инструкция — это некое элементарное действие:

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

Действие этого оператора заключается в выполнении указанного в теле оператора выражения.

Несколько идущих подряд инструкций образуют последовательность инструкций.

Блок вычислений[править | править вики-текст]

Инструкции могут быть сгруппированы в специальные вычислительные блоки следующего вида:

main(){

(последовательность инструкций)
}

ограниченные при помощи двух разделителей:

  • левая фигурная скобка ({) обозначает начало вычислительного блока,
  • правая фигурная скобка (}) обозначает конец вычислительного блока.

Вычислительный блок называют ещё составным оператором.

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

Условные операторы[править | править вики-текст]

В языке существует два условных оператора, реализующих ветвление программы:

  • оператор if, содержащий проверку одного условия;
  • и оператор switch, содержащий проверку нескольких условий.

Самая простая форма оператора if

if((условие)) (оператор)
(следующий оператор)

Оператор if работает следующим образом:

  • если выполнено условие, указанное в скобках, то выполняется первый оператор, и затем, выполняется оператор, указанный после оператора if.
  • если условие, указанное в скобках, не выполнено, то сразу выполняется оператор, указанный после оператора if.

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

if((условие)) ;

поскольку, фактически, выполняется пустой оператор. Более сложная форма оператора if содержит ключевое слово else:

if((условие)) (оператор)
else (альтернативный оператор)
(следующий оператор)

Здесь, если условие, указанное в скобках, не выполнено, то выполняется оператор, указанный после ключевого слова else.

Операторы выполнения цикла[править | править вики-текст]

Цикл — это фрагмент программного кода, содержащий

  • условие выполнения цикла — условие, которое постоянно проверяется;
  • и тело цикла --- простой или составной оператор, выполнение которого зависит от условия цикла.

В соответствии с этим, различают два вида циклов:

  • цикл с предусловием, где сначала проверяется условие выполнения цикла, и, если условие выполнено, то выполняется тело цикла;
  • цикл с постусловием, где сначала выполняется тело цикла, а уже потом проверяется условие выполнения цикла, и, если условие выполнено, то ;

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

В Си предусмотрен оператор цикла с предусловием:

while(условие) [тело цикла]

и оператор с постусловием do-while:

do [тело цикла] while( условие)

Также имеется оператор

for( блок инициализации;условие;оператор)) [тело цикла],

который эквивалентен следующему блоку операторов:

[блок инициализации]
while(условие)
{
[тело цикла]
[оператор]
}

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

Условие цикла — это логическое выражение. Однако, неявное приведение типов позволяет использовать в качестве условия цикла арифметическое выражение. Это позволяет организовать т.н. «бесконечный цикл»:

while(1);

или то же самое, но уже с применением оператора for:

for(;;);

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

Операторы безусловного перехода[править | править вики-текст]

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

Оператор

goto [метка]

где [метка] — это некоторый (числовой) идентификатор, передаёт управление тому оператору, который помечен в программе указанной меткой:

[метка] : [оператор]

Если указанная метка отсутствует в программе, или, если существует несколько операторов с одной и той же меткой, компилятор сообщает об ошибке.

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

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

  • оператор break немедленно прерывает выполнение тела цикла, и происходит передача управления на оператор, следующий непосредственно сразу за оператором цикла;
  • оператор continue прерывает выполнение тела цикла и передаёт управление в начало цикла, что инициирует проверку условия цикла.

Оператор continue может быть использован только внутри операторов do, while и for; оператор break также может использоваться внутри оператора switch.

Существует два особых случая применения операторов break и continue:

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

Оператор возврата из функции[править | править вики-текст]

В Си определён оператор return, который прерывает выполнение функции, где использован данный оператор. Если функция не должна возвращать значение, то используется вызов

return;

Если функция должна возвращать какое-либо значение, то использует вызов

return[значение];

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

Функции[править | править вики-текст]

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

Для того, чтобы задать функцию в Си, необходимо её объявить:

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

Также необходимо привести определение функции, которое содержит блок операторов, реализующих поведение функции.

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

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

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

Объявление функции[править | править вики-текст]

Объявление функции имеет следующий формат:

[описатель] [имя] ( [список] );

где

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

Признаком объявления функции является символ «;», таким образом, объявление функции — это инструкция.

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

void

При необходимости, в описателе могут быть присутствовать дополнительные элементы:

  • модификатор extern указывает на то, что определение функции находится в другом модуле;
  • модификатор static задаёт статическую функцию;
  • модификаторы pascal или cdecl влияют на обработку формальных параметров и связаны с подключением внешних модулей.

Список параметров функции задаёт сигнатуру функции.

Си не допускает объявление нескольких функций, имеющих одно и то же имя, перегрузка функций не поддерживается.[7]

Определение функции[править | править вики-текст]

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

[описатель] [имя] ( [список] ) [тело]

Где [описатель], [имя] и [список] — те же, что и в объявлении, а [тело] — это составной оператор, который представляет собою конкретную реализацию функции. Компилятор различает определения одноимённых функций по их сигнатуре, и таким образом (по сигнатуре) устанавливается связь между определением и соответствующим ему объявлением.

Тело функции имеет следующий вид:

{
[последовательность операторов]
return ([возвращаемое значение]) ;
}

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

Вызов функции[править | править вики-текст]

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

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

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

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

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

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

Возврат из функции[править | править вики-текст]

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

Структура программы[править | править вики-текст]

Комментарии[править | править вики-текст]

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

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

Следующий стандарт (стандарт C99) ввёл ещё один способ оформления комментариев: комментарием считается текст, начинающийся с символа // и заканчивающийся в конце строки.

Элементы Си[править | править вики-текст]

Типы[править | править вики-текст]

Система типов в Си подобна типам в других потомках Алгола, таких, как Паскаль. В Си имеются типы целых чисел различных размеров (short int, long int), со знаком (signed) и без (unsigned), чисел с плавающей запятой (float, double), символов, перечисляемых типов (enum) и записей-структур (struct). Кроме того, язык Си предлагает тип объединение (union), с помощью которого можно осуществлять каламбуры типизации — либо хранить в одном месте памяти разнородные данные, не пересекающиеся по времени существования (это позволяет экономить память), либо обращаться к содержимому участка памяти, как к данным разных типов (что позволяет менять тип-интерпретацию данных, не меняя сами данные).

В языке возможно преобразование типов, но оно не всегда происходит автоматически. Только некоторые типы числовых данных полностью совместимы друг с другом. При таком преобразовании компилятор может выдать только предупреждение. Чтобы полностью обезопасить себя от ошибок такого рода, можно использовать программу lint.[8]

Хранение данных[править | править вики-текст]

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

В Си есть три разных способа выделения памяти (классы памяти) для объектов:

  • Статическое выделение памяти: пространство для объектов создаётся в сегменте данных программы в момент компиляции; время жизни таких объектов совпадает со временем жизни этого кода. Изменение таких объектов ведёт к так называемому в стандарте «неопределённому поведению» (англ. undefined behaviour). На практике эта операция приводит к ошибке времени выполнения.
  • Автоматическое выделение памяти: объекты можно хранить в стеке; эта память затем автоматически освобождается и может быть использована снова, после того, как программа выходит из блока, использующего его.
  • Динамическое выделение памяти: блоки памяти нужного размера могут запрашиваться во время выполнения программы с помощью библиотечных функций malloc, realloc, calloc из области памяти, называемой кучей. Эти блоки освобождаются и могут быть использованы снова после вызова для них функции free.

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

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

Примеры на Си[править | править вики-текст]

Простейшая программа на Си[править | править вики-текст]

Простейшая программа на Си имеет следующий вид:

int main() {  return 0;  }

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

Программа «Hello, World»[править | править вики-текст]

Эта простая программа, приведена ещё в первом издании книги «Язык программирования Си» Кернигана и Ритчи:

 #include <stdio.h>
 void main() {  printf("Hello World!"); }

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

Си и другие языки программирования[править | править вики-текст]

Си и C++[править | править вики-текст]

Язык программирования C++ произошёл от Си. Однако в дальнейшем Си и C++ развивались независимо, что привело к росту несовместимости между ними. Редакция C99 добавила в язык несколько конфликтующих с C++ особенностей. Эти различия затрудняют написание программ и библиотек, которые могли бы нормально компилироваться и работать одинаково и в Си и в C++, что, конечно, запутывает тех, кто программирует на обоих языках.

Бьёрн Страуструп, придумавший C++, неоднократно выступал за максимальное сокращение различий между Си и C++ для создания максимальной совместимости между этими языками. Противники же такой точки зрения считают, что так как Си и C++ являются двумя различными языками, то и совместимость между ними не так важна, хоть и полезна. Согласно этому лагерю, усилия по уменьшению несовместимости между ними не должны препятствовать попыткам улучшения каждого языка в отдельности.

Различия между этими языками, существующие на сегодня[когда?]:

  • inline — подставляемые функции существуют в глобальном пространстве C++, а в Си — в пространстве файла (статическом пространстве). Другими словами, это значит, что в C++ любое определение подставляемой функции (независимо от переопределения функций) должно соответствовать правилу одного определения, требующего того, чтобы любая подставляемая функция была определена только один раз. В Си же одна и та же подставляемая функция может быть определена по-разному в разных компилируемых файлах одной программы.
  • В отличие от C++, макрос bool в C99 требует включения соответствующего заголовочного файла stdbool.h. В стандарте C99 определён собственный тип логических данных _Bool. Предыдущий стандарт Си (C89) не определял булевый тип вообще, поэтому для этого часто использовались различные (а значит, несовместимые) методы.
  • Символьные константы (заключённые в одинарные кавычки) по умолчанию имеют: тип int в Си и тип char в C++. Поэтому в Си справедливо равенство sizeof('a') == sizeof(int), а в C++ — равенство sizeof('a') == sizeof(char).[9]
  • Некоторые новые возможности C99, в первую очередь, restrict, не включены в C++.

Си перенял от C++ ряд особенностей:

  • прототипы объявления функций;
  • однострочные комментарии, начинающиеся на // и заканчивающиеся символом перевода строки;
  • более сильную проверку типов, включая добавление типа void, спецификатора const и удаление принятия по умолчанию типа int в качестве возвращаемого значения.

Реализация Си[править | править вики-текст]

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

Компиляторы на динамические языки и платформы[править | править вики-текст]

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

  • Clue[10] — компилятор из ANSI Си в Lua, JavaScript, Perl, Java, Common Lisp.
  • Flascc (старое название - Alchemy)[11] — компилятор из Си/C++ в ActionScript Virtual Machine (AVM2). Позволяет использовать Си-библиотеки в Flash- и Adobe AIR-приложениях.
  • AMPC[12] — компилятор из Си в виртуальную машину Java.
  • Emscripten[13] — компилятор из LLVM-байтокода (например, полученный из C++) в JavaScript.


См. также[править | править вики-текст]

Примечания[править | править вики-текст]

Литература[править | править вики-текст]

Ссылки[править | править вики-текст]