Просмотр кода страницы Си (язык программирования)

{{Другие значения|Си}}
{{Перенаправление|Язык программирования Си|Язык программирования Си (книга)|о книге}}
{{Карточка языка программирования
| название = C
| класс = [[Процедурный язык программирования|процедурный]]
| тип = [[Компилятор|компилируемый]]
| дата выпуска = [[1972]]
| расширение = {{nobr|<code>.c</code> — для}} файлов кода, {{nobr|<code>.h</code> — для}} [[Заголовочный файл|заголовочных файлов]]
| последняя версия = ISO/IEC 9899:2024
| дата выпуска последней версии = [[31 октября]] [[2024 год]]а
| система типов = [[Статическая типизация|статическая]] [[Сильная и слабая типизация|слабая]]
| реализации = [[GCC]], [[Clang]], [[MSVC]], [[Tiny C Compiler|TCC]], [[Turbo C]], [[Open Watcom|Watcom]], [[Oracle Solaris Studio]] C, [[Pelles C]]
| диалекты = «K&R» C ([[1978]])<br>ANSI C ([[1989]])<br>C99 ([[1999]])<br>C11 ([[2011]])<br>C17 ([[2018]])<br>C23 ([[2024]])
| испытал влияние = [[BCPL]], [[Би (язык программирования)|B]]
| повлиял на = [[C++]], [[Objective-C]], [[C Sharp|C#]], [[Java]], [[Nim]]
}}
{{Стандарт ISO
| название = ISO/IEC 9899
| содержание = Information technology — Programming languages — C
| сайт = [https://www.iso.org/standard/74528.html www.iso.org]
| профком = ISO/IEC JTC 1/SC 22
| страница = [https://www.iso.org/ru/committee/45202.html Programming languages, their environments and system software interfaces]
| издатель = Международная организация по стандартизации (ISO)
| редакция = [[C23|ISO/IEC 9899:2024]]
| МКС = 35.060
| редакции = [[ANSI C|ISO/IEC 9899:1990/COR2:1996]]<br>[[C99|ISO/IEC 9899:1999/COR3:2007]]<br>[[C11|ISO/IEC 9899:2011/COR1:2012]]<br>[[C17 (стандарт)|ISO/IEC 9899:2018]]
}}
'''Си''' (от [[Латинский язык|лат.]] буквы ''[[C (латиница)|C]]'' [[Английский язык|англ. языка]]{{переход|История}}) — [[Компилятор|компилируемый]] [[Статическая типизация|статически типизированный]] [[язык программирования]] общего назначения, разработанный в 1969—1973 годах сотрудником [[Bell Labs]] [[Ритчи, Деннис|Деннисом Ритчи]] как развитие языка [[Би (язык программирования)|Би]]. Первоначально был разработан для реализации [[операционная система|операционной системы]] [[UNIX]], но впоследствии был [[портирование|перенесён]] на множество других платформ. Согласно дизайну языка, его конструкции близко сопоставляются типичным [[Машинный код|машинным инструкциям]], благодаря чему он нашёл применение в проектах, для которых был свойственен [[язык ассемблера]], в том числе как в [[Операционная система|операционных системах]], так и в различном [[Прикладное ПО|прикладном программном обеспечении]] для множества устройств — от [[суперкомпьютер]]ов до [[Встраиваемая система|встраиваемых систем]]. Язык программирования Си оказал существенное влияние на развитие индустрии программного обеспечения, а его [[Синтаксис (программирование)|синтаксис]] стал основой для таких языков программирования, как [[C++]], [[C Sharp|C#]], [[Java]] и [[Objective-C]].

== История ==
{{основная статья|История языка Си}}
Язык программирования Си разрабатывался в период с [[1969]] по [[1973 год]]ы в лабораториях [[Bell Labs]], и к 1973 году на этот язык была переписана большая часть [[Ядро операционной системы|ядра]] [[Unix|UNIX]], первоначально написанного на ассемблере [[PDP-11]]/20. Название языка стало логическим продолжением старого языка «[[Би (язык программирования)|Би]]»{{efn|{{lang|en|B}} (читается как «би») — вторая, а  {{lang|en|C}} (читается как «си») — третья буква [[Английский алфавит|английского алфавита]]<ref>{{Источник информации |ссылка=https://www.google.ru/books/edition/Книга_юного_радиолюби/Wcv9AgAAQBAJ?hl=en&gbpv=1&pg=PA120&printsec=frontcover |авторы=Г. З. Лабскир |заглавие=Книга юного радиолюбителя |дата=1981 |язык=ru |издатель=Рипол Классик |страницы=120 |страниц=145 |isbn=978-5-458-28905-4}}</ref>.}}<ref>{{Книга |ссылка=https://www.google.ru/books/edition/Наука_и_жизнь/5gQoAQAAIAAJ?hl=en&gbpv=1&bsq=%22вторая+буква+английского+алфавита%22&dq=%22вторая+буква+английского+алфавита%22&printsec=frontcover |автор= |заглавие=Наука и жизнь |год=1988 |язык=ru |издательство=Изд. "Правда" |страницы=130 |всего страниц=696}}</ref>, многие особенности которого были положены в основу.

По мере развития язык сначала стандартизировали как [[ANSI C]], а затем этот стандарт был принят комитетом по международной стандартизации [[Международная организация по стандартизации|ISO]] как ISO C, ставший также известным под названием C90. В стандарте [[C99|С99]] язык получил новые возможности, такие как массивы переменной длины и встраиваемые функции. А в стандарте [[C11]] в язык добавили реализацию потоков и поддержку атомарных типов; поддержка массивов переменной длины стала необязательной. 31 октября 2024 года официально вышел стандарт [[C23]].

== Общие сведения ==
[[File:1999 ISO C Concepts.png|thumb]]
Язык Си разрабатывался как язык системного программирования, для которого можно создать однопроходный [[компилятор]]. Стандартная библиотека также невелика. Как следствие данных факторов — компиляторы разрабатываются сравнительно легко<ref>{{Cite web|url=https://www.sigbus.info/how-i-wrote-a-self-hosting-c-compiler-in-40-days.html|title=How I wrote a self-hosting C compiler in 40 days|author=Rui Ueyama|website=|date=2015-12|publisher=www.sigbus.info|lang=en|access-date=2019-02-18|archive-date=2019-03-23|archive-url=https://web.archive.org/web/20190323045627/https://www.sigbus.info/how-i-wrote-a-self-hosting-c-compiler-in-40-days.html|url-status=live}}</ref>. Поэтому данный язык доступен на самых различных платформах. К тому же, несмотря на свою низкоуровневую природу, язык ориентирован на переносимость. Программы, соответствующие стандарту языка, могут компилироваться под различные архитектуры компьютеров.

Целью языка было облегчение написания больших программ с минимизацией ошибок по сравнению с ассемблером, следуя принципам [[процедурное программирование|процедурного программирования]], но избегая всего, что может привести к дополнительным накладным расходам, специфичным для языков высокого уровня.

Основные особенности Си:

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

В то же время в Си отсутствуют:
* вложенные функции;
* прямое возвращение нескольких значений из функций;
* [[Сопрограмма|сопрограммы]];
* средства автоматического [[Менеджер памяти|управления памятью]];
* встроенные средства [[объектно-ориентированное программирование|объектно-ориентированного программирования]];
* средства [[Функциональное программирование|функционального программирования]].

Часть отсутствующих возможностей может имитироваться встроенными средствами (например, сопрограммы можно имитировать с помощью функций [[setjmp.h|<code>setjmp</code> и <code>longjmp</code>]]), часть добавляется с помощью сторонних библиотек (например, для поддержки многозадачности и для сетевых функций можно использовать библиотеки [[POSIX Threads|pthreads]], sockets и тому подобные; существуют библиотеки для поддержки автоматической сборки мусора<ref>[http://www.hpl.hp.com/personal/Hans_Boehm/gc/ A garbage collector for C and C++] {{Wayback|url=http://www.hpl.hp.com/personal/Hans_Boehm/gc/ |date=20051013094532 }}{{ref|en}}</ref>), часть реализуется в некоторых компиляторах в виде расширений языка (например, вложенные функции в [[GNU Compiler Collection|GCC]]).
Существует несколько громоздкая, но вполне работоспособная методика, позволяющая реализовывать на Си механизмы [[объектно-ориентированное программирование|ООП]]<ref>[https://www.cs.rit.edu/~ats/books/ooc.pdf Object-Oriented Programming With ANSI-C] {{Wayback|url=https://www.cs.rit.edu/~ats/books/ooc.pdf |date=20160306204308 }}{{ref|en}}</ref>, базирующаяся на фактической полиморфности указателей в Си и поддержке в этом языке указателей на функции. Механизмы ООП, основанные на данной модели, реализованы в библиотеке [[GLib]] и активно используются во фреймворке [[GTK]]. GLib предоставляет базовый класс <code>GObject</code>, возможности наследования от одного класса<ref>{{Cite web|url=https://developer.gnome.org/gobject/stable/gtype-instantiable-classed.html|title=Instantiable classed types: objects|website=GObject Reference Manual|publisher=developer.gnome.org|lang=en|access-date=2019-05-27|archive-date=2019-05-27|archive-url=https://web.archive.org/web/20190527151524/https://developer.gnome.org/gobject/stable/gtype-instantiable-classed.html|url-status=live}}</ref> и реализации множества интерфейсов<ref>{{Cite web|url=https://developer.gnome.org/gobject/stable/gtype-non-instantiable-classed.html|title=Non-instantiable classed types: interfaces|website=GObject Reference Manual|publisher=developer.gnome.org|lang=en|access-date=2019-05-27|archive-date=2019-05-27|archive-url=https://web.archive.org/web/20190527151527/https://developer.gnome.org/gobject/stable/gtype-non-instantiable-classed.html|url-status=live}}</ref>.

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

== Синтаксис и семантика ==
{{Основная статья|Синтаксис и семантика языка Си}}
Синтаксис языка Си достаточно сложный<!-- Нет источника -->, а семантика неоднозначная<ref>{{Источник информации|Q36247140}}</ref>. Основными двумя особенностями языка на момент его появления были унифицирование работы с массивами и указателями, а также схожесть того, как что-либо объявляется, с тем, как это в дальнейшем используется в выражениях{{sfn|Papaspyrou|1998|p=4|loc=1.1 The C programming language}}. Однако в последующем эти две особенности языка были в числе наиболее критикуемых{{sfn|Papaspyrou|1998|p=4|loc=1.1 The C programming language}}, и обе являются сложными для понимания среди начинающих программистов<ref>{{Источник информации|Q55869040|ссылка=https://www.bell-labs.com/usr/dmr/www/chist.html|дата обращения=2023-01-22}}</ref>. Стандарт языка, определяя его семантику, не стал слишком сильно ограничивать реализации языка компиляторами, но этим самым сделал семантику недостаточно определённой. В частности, в стандарте есть 3 типа недостаточно определённой семантики: определяемое реализацией поведение, не заданное стандартом поведение и неопределённое поведение{{sfn|Papaspyrou|1998|p=17-18|loc=2.1 Selected issues from the syntax and semantics of C}}.

== Типы данных ==
{{основная|Система типов Си}}

=== Примитивные типы ===

==== Целые числа ====
Размер целочисленных типов данных варьируется от не менее 8 до не менее 32 бит. Стандарт [[C99]] увеличивает максимальный размер целого числа — не менее 64 бит. Целочисленные типы данных используются для хранения целых чисел (тип <code>char</code> также используется для хранения ASCII-символов). Все размеры диапазонов представленных ниже типов данных минимальны и на отдельно взятой платформе могут быть больше<ref>{{Cite web|url=http://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html#Integer-Types|title=The GNU C Reference Manual|publisher=www.gnu.org|access-date=2017-05-21|archive-date=2021-04-27|archive-url=https://web.archive.org/web/20210427114039/http://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html#Integer-Types|url-status=live}}</ref>.

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

<code>1</code> = <syntaxhighlight lang="C" inline>sizeof(char)</syntaxhighlight> ≤ <syntaxhighlight lang="C" inline>sizeof(short)</syntaxhighlight> ≤ <syntaxhighlight lang="C" inline>sizeof(int)</syntaxhighlight> ≤ <syntaxhighlight lang="C" inline>sizeof(long)</syntaxhighlight> ≤ <syntaxhighlight lang="C" inline>sizeof(long long)</syntaxhighlight>.

Таким образом, размеры некоторых типов по количеству байт могут совпадать, если будет удовлетворяться условие по минимальному количеству бит. Даже <code>char</code> и <code>long</code> могут иметь одинаковый размер, если один байт будет занимать 32 бита или более, но такие платформы будут очень редки или не будут существовать. Стандарт гарантирует, что тип <code>char</code> '''всегда''' равен 1 байту. Размер байта в битах определяется константой <code>CHAR_BIT</code> из заголовочного файла <code>[[limits.h]]</code>, у [[POSIX]]-совместимых систем равен 8 битам<ref>{{Cite web|url=http://www.gnu.org/software/libc/manual/html_node/Width-of-Type.html|title=Width of Type (The GNU C Library)|author=|website=|date=|publisher=www.gnu.org|lang=en|access-date=2018-12-07|archive-date=2018-12-09|archive-url=https://web.archive.org/web/20181209123817/http://www.gnu.org/software/libc/manual/html_node/Width-of-Type.html|url-status=live}}</ref>.

Минимальный диапазон значений целых типов по стандарту определяется с <code>-(2<sup>N-1</sup>-1)</code> по <code>2<sup>N-1</sup>-1</code> для знаковых типов и с <code>0</code> по <code>2<sup>N</sup>-1</code> — для беззнаковых, где N — разрядность типа. Реализация компиляторов может расширять этот диапазон по своему усмотрению. На практике для знаковых типов чаще используется диапазон с <code>-2<sup>N-1</sup></code> по <code>2<sup>N-1</sup>-1</code>. Минимальное и максимальное значения каждого типа указывается в файле <code>[[limits.h]]</code> в виде макроопределений.

Отдельное внимание стоит уделить типу <code>char</code>. Формально это отдельный тип, но фактически <code>char</code> эквивалентен либо <code>signed char</code>, либо <code>unsigned char</code>, в зависимости от компилятора{{sfn|Черновик стандарта C17|loc=6.2.5 Types|с=31}}.

Для того, чтобы избежать путаницы между размерами типов стандарт C99 ввел новые типы данных, описанные в файле <code>[[stdint.h]]</code>. Среди них такие типы как: <code>int''N''_t</code>, <code>int_least''N''_t</code>, <code>int_fast''N''_t</code>, где <code>N</code> = 8, 16, 32 или 64. Приставка <code>least-</code> обозначает минимальный тип, способный вместить <code>N</code> бит, приставка <code>fast-</code> обозначает тип размером не менее 16 бит, работа с которым наиболее быстрая на данной платформе. Типы без приставок обозначают типы с фиксированном размером, равным <code>N</code> бит.

Типы с приставками <code>least-</code> и <code>fast-</code> можно считать заменой типам <code>int</code>, <code>short</code>, <code>long</code>, с той лишь разницей, что первые дают программисту выбрать между скоростью и размером.
{| class="wikitable"
|+Основные типы данных для хранения целых чисел
!Тип данных
!Размер
!Минимальный диапазон значений
!Стандарт
|-
|<code>signed char</code>
| rowspan="3" |минимум 8 бит
| rowspan="3" |от −127<ref name=":0" /> (= -(2<sup>7</sup>−1)) до 127
|[[ANSI C|C90]]{{efn|name=k_and_r_c|Первое появление знаковых и беззнаковых типов <code>char</code>, <code>short</code>, <code>int</code> и <code>long</code> было в K&R C.}}
|-
|<code>int_least8_t</code>
| rowspan="2" |[[C99]]
|-
|<code>int_fast8_t</code>
|-
|<code>unsigned char</code>
| rowspan="3" |минимум 8 бит
| rowspan="3" |от 0 до 255 (=2<sup>8</sup>−1)
|C90{{efn|name=k_and_r_c}}
|-
|<code>uint_least8_t</code>
| rowspan="2" |C99
|-
|<code>uint_fast8_t</code>
|-
|<code>char</code>
|минимум 8 бит
|от −127 до 127 или от 0 до 255 в зависимости от компилятора
|C90{{efn|name=k_and_r_c}}
|-
|<code>short int</code>
| rowspan="4" |минимум 16 бит
| rowspan="4" |от −32,767 (= -(2<sup>15</sup>−1)) до 32,767
| rowspan="2" |C90{{efn|name=k_and_r_c}}
|-
|<code>int</code>
|-
|<code>int_least16_t</code>
| rowspan="2" |C99
|-
|<code>int_fast16_t</code>
|-
|<code>unsigned short int</code>
| rowspan="4" |минимум 16 бит
| rowspan="4" |от 0 до 65,535 (= 2<sup>16</sup>−1)
| rowspan="2" |C90{{efn|name=k_and_r_c}}
|-
|<code>unsigned int</code>
|-
|<code>uint_least16_t</code>
| rowspan="2" |C99
|-
|<code>uint_fast16_t</code>
|-
|<code>long int</code>
| rowspan="3" |минимум 32 бита
| rowspan="3" | от −2,147,483,647 до 2,147,483,647
|C90{{efn|name=k_and_r_c}}
|-
|<code>int_least32_t</code>
| rowspan="2" |C99
|-
|<code>int_fast32_t</code>
|-
|<code>unsigned long int</code>
| rowspan="3" |минимум 32 бита
| rowspan="3" | от 0 до 4,294,967,295 (= 2<sup>32</sup>−1)
|C90{{efn|name=k_and_r_c}}
|-
|<code>uint_least32_t</code>
| rowspan="2" |C99
|-
|<code>uint_fast32_t</code>
|-
|<code>long long int</code>
| rowspan="3" |минимум 64 бита
| rowspan="3" |от −9,223,372,036,854,775,807 до 9,223,372,036,854,775,807
| rowspan="14" |C99
|-
|<code>int_least64_t</code>
|-
|<code>int_fast64_t</code>
|-
|<code>unsigned long long int</code>
| rowspan="3" |минимум 64 бита
| rowspan="3" |от 0 до 18,446,744,073,709,551,615 (= 2<sup>64</sup>−1)
|-
|<code>uint_least64_t</code>
|-
|<code>uint_fast64_t</code>
|-
|<code>int8_t</code>
|8 бит
|от −127 до 127
|-
|<code>uint8_t</code>
|8 бит
|от 0 до 255 (=2<sup>8</sup>−1)
|-
|<code>int16_t</code>
|16 бит
|от −32,767 до 32,767
|-
|<code>uint16_t</code>
|16 бит
|от 0 до 65,535 (= 2<sup>16</sup>−1)
|-
|<code>int32_t</code>
|32 бита
|от −2,147,483,647 до 2,147,483,647
|-
|<code>uint32_t</code>
|32 бита
|от 0 до 4,294,967,295 (= 2<sup>32</sup>−1)
|-
|<code>int64_t</code>
|64 бита
|от −9,223,372,036,854,775,807 до 9,223,372,036,854,775,807
|-
|<code>uint64_t</code>
|64 бита
|от 0 до 18,446,744,073,709,551,615 (= 2<sup>64</sup>−1)
|-
| colspan="4" |''<small>В таблице приведён минимальный диапазон значений согласно стандарту языка. Компиляторы языка Си могут расширять диапазон значений.</small>''
|}

==== Вспомогательные целочисленные типы ====
Также со стандарта C99 добавлены типы <code>intmax_t</code> и <code>uintmax_t</code>, соответствующие самым большим знаковому и беззнаковому типам соответственно. Данные типы удобны при использовании в макросах для хранения промежуточных или временных значений при операциях над целочисленными аргументами, так как позволяют уместить значения любого типа. Например, эти типы используются в макросах сравнения целочисленных значений библиотеки модульного тестирования [[Check (библиотека модульного тестирования)|Check]] для языка Си<ref>{{Cite web|url=http://check.sourceforge.net/doc/check_html/check_4.html|title=Check 0.10.0: 4. Advanced Features|author=|website=Check|date=|publisher=check.sourceforge.net|lang=en|access-date=2019-02-11|archive-date=2018-05-18|archive-url=https://web.archive.org/web/20180518223511/http://check.sourceforge.net/doc/check_html/check_4.html|url-status=live}}</ref>.

В Си существует несколько дополнительных целочисленных типов для безопасной работы с типом данных указателей: <code>intptr_t</code>, <code>uintptr_t</code> и <code>ptrdiff_t</code>. Типы <code>intptr_t</code> и <code>uintptr_t</code> из стандарта C99 предназначены для хранения соответственно знакового и беззнакового значений, которые по размеру могут уместить в себе указатель. Эти типы часто применяются для хранения произвольного целого числа в указателе, например, как способ избавиться от лишнего выделения памяти при регистрации функций обратной связи<ref>{{Cite web|url=https://developer.gnome.org/glib/stable/glib-Type-Conversion-Macros.html|title=Type Conversion Macros: GLib Reference Manual|author=|website=|date=|publisher=developer.gnome.org|lang=en|access-date=2019-01-14|archive-date=2019-01-14|archive-url=https://web.archive.org/web/20190114153236/https://developer.gnome.org/glib/stable/glib-Type-Conversion-Macros.html|url-status=live}}</ref> либо при использовании сторонних связных списков, ассоциативных массивов и прочих структур, в которых данные хранятся по указателю. Тип <code>ptrdiff_t</code> из заголовочного файла <code>[[stddef.h]]</code> предназначен для безопасного хранения разности двух указателей.

Для хранения размера предусмотрен беззнаковый тип <code>size_t</code> из заголовочного файла <code>stddef.h</code>. Данный тип способен уместить максимально возможное количество байт, доступное по указателю, и обычно используется для хранения размера в байтах. Значение именно этого типа возвращает оператор <code>sizeof</code><ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/INT01-C.+Use+rsize_t+or+size_t+for+all+integer+values+representing+the+size+of+an+object|title=INT01-C. Use rsize_t or size_t for all integer values representing the size of an object - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-02-22|archive-date=2021-08-07|archive-url=https://web.archive.org/web/20210807210218/https://wiki.sei.cmu.edu/confluence/display/c/INT01-C.+Use+rsize_t+or+size_t+for+all+integer+values+representing+the+size+of+an+object|url-status=live}}</ref>.

==== Приведение целочисленных типов ====
Преобразования целочисленных типов могут происходить как явно, с помощью оператора приведения типов, так и неявно. Значения типов, меньших по размеру, чем <code>int</code>, при участии в каких-либо операциях или при передаче в вызов функции автоматически приводятся к типу <code>int</code>, а в случае невозможности преобразования — к типу <code>unsigned int</code>. Зачастую подобные неявные приведения необходимы, чтобы результат вычисления оказался правильным, но иногда приводят к интуитивно-непонятным ошибкам в вычислениях. Например, если в операции участвуют числа типа <code>int</code> и <code>unsigned int</code>, а знаковое значение отрицательно, то преобразование отрицательного числа к беззнаковому типу приведёт к переполнению и возникновению очень большого положительного значения, что может привести к неверному результату операций сравнения<ref name=":7">{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/INT02-C.+Understand+integer+conversion+rules|title=INT02-C. Understand integer conversion rules - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-02-22|archive-date=2019-02-22|archive-url=https://web.archive.org/web/20190222152330/https://wiki.sei.cmu.edu/confluence/display/c/INT02-C.+Understand+integer+conversion+rules|url-status=live}}</ref>.
{| class="wikitable"
|+Сравнение правильного и ошибочного автоматического приведения типов
!Знаковый и беззнаковый типы меньше, чем <code>int</code>
!Знаковый меньше беззнакового, а беззнаковый не менее <code>int</code>
|-
|<syntaxhighlight lang="c" line="1">
#include <stdio.h>

signed char x = -1;
unsigned char y = 0;
if (x > y) { // условие ложно
    printf("Сообщение не будет показано.\n");
}
if (x == UCHAR_MAX) {
    // условие ложно
    printf("Сообщение не будет показано.\n");
}
</syntaxhighlight>
|<syntaxhighlight lang="c" line="1">
#include <stdio.h>

signed char x = -1;
unsigned int y = 0;
if (x > y) { // условие истинно
    printf("Переполнение в переменной x.\n");
}
if ((x == UINT_MAX) && (x == ULONG_MAX)) {
    // условие всегда будет истинным
    printf("Переполнение в переменной x.\n");
}
</syntaxhighlight>
|-
|<small>В данном примере оба типа, знаковый и беззнаковый, будут приведены к знаковому типу <code>int</code>, поскольку он позволяет уместить диапазоны обоих типов. Поэтому сравнение в условном операторе будет корректным.</small>
|<small>Знаковый тип будет приведён к беззнаковому, поскольку беззнаковый больше или равен по размеру типу <code>int</code>, но произойдёт переполнение, поскольку в беззнаковом типе невозможно представить отрицательное значение.</small>
|}
Также автоматическое приведение типов сработает, если в выражении используется два или более разных целочисленных типа. Стандарт определяет ряд правил, согласно которым выбирается такое преобразование типов, которое может дать правильный результат вычислений. Разным типам назначены разные ранги в рамках преобразования, а сами ранги основаны на размере типа. При участии в выражении разных типов обычно выбирается приведение этих значений к типу большего ранга<ref name=":7" />.

==== Вещественные числа ====
[[Число с плавающей запятой|Числа с плавающей запятой]] в языке Си представлены тремя основными типами: <code>float</code>, <code>double</code> и <code>long double</code>.

Вещественные числа имеют представление, сильно отличающее их от целых. Константы вещественных чисел разных типов, записанные в десятичном представлении, могут быть не равны друг другу. Например, условие <code>0.1 == 0.1f</code> будет ложным из-за потери точности у типа <code>float</code>, в то время как условие <code>0.5 == 0.5f</code> будет истинным, поскольку эти числа конечны в двоичном представлении. Однако условие с приведением <code>(float) 0.1 == 0.1f</code> также будет истинным, поскольку при приведении типа к менее точному теряются разряды, из-за которых в этих двух константах есть различия.

Арифметические операции с вещественными числами также являются неточными и зачастую имеют некоторую плавающую погрешность<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/FLP02-C.+Avoid+using+floating-point+numbers+when+precise+computation+is+needed|title=FLP02-C. Avoid using floating-point numbers when precise computation is needed - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-05-21|archive-date=2021-08-07|archive-url=https://web.archive.org/web/20210807210223/https://wiki.sei.cmu.edu/confluence/display/c/FLP02-C.+Avoid+using+floating-point+numbers+when+precise+computation+is+needed|url-status=live}}</ref>. Наибольшая погрешность будет возникать при операциях над значениями, близкими к минимально возможному для конкретного типа. Также погрешность может оказаться большой при вычислениях над одновременно очень маленькими (≪ 1) и очень большими [[Абсолютная величина|по модулю]] числами (≫ 1). В ряде случаев погрешность может быть снижена изменением алгоритмов и методик вычислений. Например, при замене многократного сложения умножением погрешность может снизиться во столько раз, сколько изначально было операций сложения.

Также в заголовочном файле <code>[[math.h]]</code> присутствуют два дополнительных типа <code>float_t</code> и <code>double_t</code>, которые соответствуют как минимум типам <code>float</code> и <code>double</code> соответственно, но могут быть отличными от них. Типы <code>float_t</code> и <code>double_t</code> добавлены в стандарте [[C99]], а их соответствие основным типам определяется значением макроса <code>FLT_EVAL_METHOD</code>.
{| class="wikitable"
|+Вещественные типы данных
!Тип данных
!Размер
!Стандарт
|-
|<code>float</code>
|32 бита
|IEC 60559 ([[IEEE 754-2008|IEEE 754]]), расширение F стандарта Си{{sfn|Черновик стандарта C17|loc=IEC 60559 floating-point arithmetic|с=370}}{{efn|name=IEC_60559|Соответствие формата типов <code>float</code> и <code>double</code> стандарту IEC 60559 определяется расширением F стандарта Си, поэтому формат может отличаться на отдельных платформах или компиляторах.}}, [[число одинарной точности]]
|-
|<code>double</code>
|64 бита
|IEC 60559 (IEEE 754), расширение F стандарта Си{{sfn|Черновик стандарта C17|loc=IEC 60559 floating-point arithmetic|с=370}}{{efn|name=IEC_60559}}, [[число двойной точности]]
|-
|<code>long double</code>
|минимум 64 бита
|зависит от реализации
|-
|<code>float_t</code> (C99)
|минимум 32 бита
|зависит от базового типа
|-
|<code>double_t</code> (C99)
|минимум 64 бита
|зависит от базового типа
|}
{| class="wikitable"
|+Соответствие дополнительных типов базовым{{sfn|Черновик стандарта C17|loc=7.12 Mathematics &lt;math.h&gt;|с=169—170}}
!<code>FLT_EVAL_METHOD</code>
!<code>float_t</code>
!<code>double_t</code>
|-
|1
|<code>float</code>
|<code>double</code>
|-
|2
|<code>double</code>
|<code>double</code>
|-
|3
|<code>long double</code>
|<code>long double</code>
|}

=== Строки ===

==== Нуль-терминированные строки ====
{{Основная статья|Нуль-терминированная строка}}
Хотя как такового специального типа для строк в Си не предусмотрено, в языке активно используются нуль-терминированные строки. [[ASCII]]-строки объявляются как массив типа <code>char</code>, последним элементом которого должен быть символ с кодом <code>0</code> (<code>'\0'</code>). В этом же формате принято хранить и строки в формате [[UTF-8]]. Однако все функции, работающие с ASCII-строками, рассматривают каждый символ как байт, что ограничивает применение стандартных функций при использовании данной кодировки.

Несмотря на широкое распространение идеи нуль-терминированных строк и удобство их использования в некоторых алгоритмах, у них есть несколько серьёзных недостатков.

# Необходимость добавления в конец строки терминального символа не даёт возможность получить подстроку без необходимости её копирования, а функций для работы с указателем на подстроку и её длиной в языке не предусмотрено.
# Если требуется заранее выделять память под результат алгоритма на основе входных данных, каждый раз требуется обходить всю строку для подсчёта её длины.
# При работе с большими объёмами текста подсчёт длины может оказаться [[Узкое место|узким местом]].
# Работа со строкой, которая по ошибке не терминирована нулём, может приводить к неопределённому поведению программы, в том числе к [[Ошибка сегментации|ошибкам сегментирования]], ошибкам [[Переполнение буфера|переполнения буфера]] и к [[Уязвимость (компьютерная безопасность)|уязвимостям]].

В современных условиях, когда производительность кода приоритетнее расхода памяти, может оказаться эффективнее и проще использовать структуры, содержащие в себе как саму строку, так и её размер<ref name=":15" />{{переход|Неэффективные и небезопасные строки}}, например:
<syntaxhighlight lang="c" line="1">
struct string_t {
    char *str; // указатель на строку
    size_t str_size; // размер строки
};
typedef struct string_t string_t; // альтернативное имя для упрощения кода
</syntaxhighlight>

Альтернативным вариантом хранения размера строки с низким потреблением памяти может оказаться подход добавления в начало строки её размера в формате {{Не переведено 3|Размер переменной длины|размера переменной длины|4=Variable-length quantity}}. Подобный подход применяется в [[Protocol Buffers|протокольных буферах]], однако только на этапе передачи данных, но не их хранения.

==== Строковые литералы ====
Строковые литералы в Си по своей сути являются константами{{sfn|Подбельский, Фомин|2012|с=19}}. При объявлении заключаются в двойные кавычки, а терминирующий <code>0</code> добавляются компилятором автоматически. Допускается два способа присваивания строкового литерала: по указателю и по значению. При присваивании по указателю в переменную типа <code>char *</code> заносится указатель на неизменяемую строку, то есть формируется константная строка. Если же заносить строковый литерал в массив, то происходит копирование строки в область стека.
<syntaxhighlight lang="c" line="1">
#include <stdio.h>
#include <string.h>

int main(void)
{
    const char *s1 = "Константная строка";
    char s2[] = "Строка, которую можно менять";
    memcpy(s2, "с", strlen("с")); // замена первой буквы на маленькую
    puts(s2); // выведется текст строки
    memcpy((char *) s1, "к", strlen("к")); // ошибка сегментирования
    puts(s1); // строка не будет исполнена
}
</syntaxhighlight>Поскольку строки являются обычными массивами символов, вместо литералов можно использовать инициализаторы, если каждый символ умещается в 1 байт:<syntaxhighlight lang="c" line="1">
char s[] = {'I', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'r', '\0'};
</syntaxhighlight>
Однако на практике такой подход имеет смысл только в крайне редких случаях, когда к ASCII-строке требуется не добавлять терминирующий ноль.

==== Широкие строки ====
{| class="wikitable" style="float:right; margin-left:1.0em;"
|+Кодировка типа <code>wchar_t</code> в зависимости от платформы
!Платформа
!Кодировка
|-
|[[Linux|GNU/Linux]]
| rowspan="2" |[[UCS-4|USC-4]]<ref name=":10" />
|-
|[[macOS]]
|-
|[[Windows]]
| rowspan="2" |[[UCS-4|USC-2]]<ref name=":9" />
|-
|[[AIX]]
|-
|[[FreeBSD]]
| rowspan="2" |Зависит от локали,
не документировано<ref name=":9" />
|-
|[[Solaris]]
|}
Альтернативой обычным строкам могут служить широкие строки, в которых каждый символ хранится в специальном типе <code>wchar_t</code>. Данный тип по стандарту должен быть способен уместить в себе все символы самой большой из существующих [[Локаль|локалей]]. Функции для работы с широкими строками описаны в заголовочном файле <code>[[wchar.h]]</code>, а функции для работы с широкими символами описаны в заголовочном файле <code>[[wctype.h]]</code>.

При объявлении строковых литералов для широких строк используется модификатор <code>L</code>:
<syntaxhighlight lang="c" line="1">
const wchar_t *wide_str = L"Широкая строка";
</syntaxhighlight>

В форматированном выводе используется спецификатор <code>%ls</code>, однако спецификатор размера, если задан, указывается в байтах, а не в символах<ref>{{Cite web|url=https://www.linux.com/news/programming-wide-characters|title=Programming with wide characters|date=2006-02-11|publisher=Linux.com {{!}} The source for Linux information|lang=en|access-date=2019-06-07|archive-date=2019-06-07|archive-url=https://web.archive.org/web/20190607163810/https://www.linux.com/news/programming-wide-characters|url-status=live}}</ref>.

Тип <code>wchar_t</code> задумывался для того, чтобы в него мог поместиться любой символ, а широкие строки — для хранения строк любой локали, но в результате API оказался неудобным, а реализации — платформозависимыми. Так, на платформе [[Windows]] в качестве размера типа <code>wchar_t</code> было выбрано 16 бит, а позже появился стандарт UTF-32, таким образом тип <code>wchar_t</code> на платформе Windows уже не способен уместить в себе все символы из кодировки UTF-32, в результате чего теряется смысл данного типа<ref name=":9">{{Cite web|url=https://www.gnu.org/software/libunistring/manual/html_node/The-wchar_005ft-mess.html|title=The wchar_t mess - GNU libunistring|author=|website=|date=|publisher=www.gnu.org|lang=en|access-date=2019-01-02|archive-date=2019-09-17|archive-url=https://web.archive.org/web/20190917202126/https://www.gnu.org/software/libunistring/manual/html_node/The-wchar_005ft-mess.html|url-status=live}}</ref>. В то же время на платформах Linux<ref name=":10">{{Cite web|url=http://man7.org/linux/man-pages/man7/unicode.7.html|title=unicode(7) - Linux manual page|author=|website=|date=|publisher=man7.org|lang=en|access-date=2019-02-24|archive-date=2019-02-25|archive-url=https://web.archive.org/web/20190225044833/http://man7.org/linux/man-pages/man7/unicode.7.html|url-status=live}}</ref> и macOS данный тип занимает 32 бита, поэтому для реализации [[Кроссплатформенность|кроссплатформенных]] задач тип <code>wchar_t</code> не подходит.

==== Многобайтовые строки ====
Существует много разных кодировок, в которых отдельный символ может быть запрограммирован разным количеством байт. Такие кодировки называются многобайтовыми. К ним относится также и [[UTF-8]]. В Си существует набор функций для преобразования строк из многобайтовых в рамках текущей локали в широкие и наоборот. Функции для работы с многобайтовыми символами имеют префикс либо суффикс <code>mb</code> и описаны в заголовочном файле <code>[[stdlib.h]]</code>. Для поддержки многобайтовых строк в программах на языке Си, такие строки должны поддерживаться на уровне текущей [[Локаль|локали]]. Для явного задания кодировки можно менять текущую локаль с помощью функции <code>setlocale()</code> из заголовочного файла <code>[[locale.h]]</code>. Однако задание кодировки для локали должно поддерживаться используемой стандартной библиотекой. Так, например, стандартная библиотека [[Glibc]] полностью поддерживает кодировку UTF-8 и способна преобразовывать текст во множество других кодировок<ref>{{Cite web|url=https://www.cl.cam.ac.uk/~mgk25/unicode.html|title=UTF-8 and Unicode FAQ|author=[https://www.cl.cam.ac.uk/~mgk25/ Markus Kuhn]|website=|date=|publisher=www.cl.cam.ac.uk|lang=en|access-date=2019-02-25|archive-date=2019-02-27|archive-url=https://web.archive.org/web/20190227012305/https://www.cl.cam.ac.uk/~mgk25/unicode.html|url-status=live}}</ref>.

Начиная со стандарта C11 язык поддерживает также 16-битные и 32-битные широкие многобайтовые строки с соответствующими типами символа <code>char16_t</code> и <code>char32_t</code> из заголовочного файла <code>[[uchar.h]]</code>, а также объявление строковых литералов в формате UTF-8 с помощью модификатора <code>u8</code>. 16-битные и 32-битные строки могут использоваться для хранения кодировок [[UTF-16]] и [[UTF-32]], если в заголовочном файле <code>uchar.h</code> заданы макроопределения <code>__STDC_UTF_16__</code> и <code>__STDC_UTF_32__</code>, соответственно. Для задания строковых литералов в данных форматах используются модификаторы: <code>u</code> для 16-битных строк и <code>U</code> для 32-битных строк. Примеры объявления строковых литералов для многобайтовых строк:
<syntaxhighlight lang="c" line="1">
const char *s8 = u8"Многобайтовая строка в кодировке UTF-8";
const char16_t *s16 = u"16-битная многобайтовая строка";
const char32_t *s32 = U"32-битная многобайтовая строка";
</syntaxhighlight>

Следует иметь в виду, что функция <code>c16rtomb()</code> для преобразования из 16-битной строки в многобайтовую работает не так, как задумывалось, и в стандарте C11 оказалась неспособной переводить из UTF-16 в UTF-8<ref>{{Cite web|url=http://www.open-std.org/jtc1/sc22/WG14/www/docs/summary.htm#dr_488|title=Defect Report Summary for C11|publisher=www.open-std.org|access-date=2019-01-02|archive-date=2019-01-01|archive-url=https://web.archive.org/web/20190101094052/http://www.open-std.org/jtc1/sc22/wg14/www/docs/summary.htm#dr_488|url-status=live}}</ref>. Исправление работы данной функции может зависеть от конкретной реализации компилятора.

=== Пользовательские типы ===

==== Перечисления ====
[[Перечисляемый тип|Перечисления]] представляют собой набор именованных целочисленных констант и обозначаются с помощью ключевого слова <code>enum</code>. Если константе не сопоставлено число, то ей автоматически задаётся либо <code>0</code> для первой константы в списке, либо число на единицу бо́льшее, чем задано в предыдущей константе. При этом сам тип данных перечисления по факту может соответствовать любому знаковому или беззнаковому примитивному типу, в диапазон которого умещаются все значения перечислений; решение о выборе того или иного типа принимает компилятор. Однако явно заданные значения для констант должны быть выражениями типа <code>int</code>{{sfn|Черновик стандарта C17|с=84}}.

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

На практике перечисления часто используются для обозначения состояний [[Конечный автомат|конечных автоматов]], для задания вариантов режимов работы или значений параметров<ref>{{Cite web|url=https://developer.gnome.org/gtk3/stable/gtk3-Standard-Enumerations.html|title=Standard Enumerations: GTK+ 3 Reference Manual|author=|website=|date=|publisher=developer.gnome.org|lang=en|access-date=2019-01-15|archive-date=2019-01-14|archive-url=https://web.archive.org/web/20190114195413/https://developer.gnome.org/gtk3/stable/gtk3-Standard-Enumerations.html|url-status=live}}</ref>, для создания целочисленных констант, а также для перечисления каких-либо уникальных объектов или свойств<ref>{{Cite web|url=https://developer.gnome.org/gobject/stable/gobject-properties.html|title=Object properties: GObject Reference Manual|author=|website=|date=|publisher=developer.gnome.org|lang=en|access-date=2019-01-15|archive-date=2019-01-16|archive-url=https://web.archive.org/web/20190116045901/https://developer.gnome.org/gobject/stable/gobject-properties.html|url-status=live}}</ref>.

==== Структуры ====
Структуры представляют собой объединение переменных разных типов данных в рамках одной области памяти; обозначаются ключевым словом <code>struct</code>. Переменные внутри структуры называются полями структуры. С точки зрения адресного пространства поля всегда идут друг за другом в том же порядке, в котором указаны, но компиляторы могут выравнивать адреса полей для оптимизации под ту или иную архитектуру. Таким образом, фактически поле может занимать бо́льший размер, чем указано в программе.

Каждое поле имеет определённое смещение относительно адреса структуры и размер. Смещение можно получить с помощью макроса <code>offsetof()</code> из заголовочного файла <code>[[stddef.h]]</code>. При этом смещение будет зависеть от выравнивания и размера предыдущих полей. Размер поля обычно определяется выравниванием структуры: если размер выравнивания типа данных поля меньше значения выравнивания структуры, то размер поля определяется выравниванием структуры. Выравнивание типов данных можно получить с помощью макроса <code>alignof()</code>{{efn|Макрос <code>alignof</code> из заголовочного файла <code>[[stdalign.h]]</code> является обёрткой над ключевым словом <code>'''_Alignof'''</code>.|name=alignof}} из заголовочного файла <code>[[stdalign.h]]</code>. Размер самой структуры является совокупным размером всех её полей с учётом выравнивания. При этом некоторые компиляторы предоставляют специальные атрибуты, позволяющие упаковывать структуры, убирая из них выравнивания<ref>{{Cite web|url=https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#Common-Type-Attributes|title=Using the GNU Compiler Collection (GCC): Common Type Attributes|author=|website=|date=|publisher=gcc.gnu.org|lang=en|access-date=2019-01-19|archive-date=2019-01-16|archive-url=https://web.archive.org/web/20190116060115/http://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#Common-Type-Attributes|url-status=live}}</ref>.

Полям структур можно явно задавать размер в битах через двоеточие после определения поля и указание количества бит, что ограничивает диапазон их возможных значений, несмотря на тип поля. Подобный подход может использоваться как альтернатива флагам и битовым маскам для обращения к ним. Однако указание количества бит не отменяет возможного выравнивания полей структур в памяти. Работа с битовыми полями имеет ряд ограничений: к ним невозможно применить оператор <code>sizeof</code> или макрос <code>alignof()</code>, на них невозможно получить указатель.

==== Объединения ====
[[Объединение (структура данных)|Объединения]] необходимы в тех случаях, когда требуется обращаться к одной и той же переменной как к разным типам данных; обозначаются ключевым словом <code>union</code>. Внутри объединения может быть объявлено произвольное количество пересекающихся полей, которые по факту предоставляют доступ к одной и той же области памяти как к разным типам данных. Размер объединения выбирается компилятором исходя из размера самого большого поля в объединении. Следует иметь в виду, что изменение одного поля объединения приводит к изменению и всех других полей, но гарантированно правильным будет только значение того поля, которое менялось.

Объединения могут служить более удобной альтернативной приведению указателя к произвольному типу. К примеру, с помощью объединения, помещённого в структуру, можно создавать объекты с динамически меняющимся типом данных:
{{Начало скрытого блока
 |Рамка = 1px solid black
 |Ссылка = left
 |Выравнивание_заголовка = center
 |Заголовок = Код структуры для изменения типа данных на лету
 |Фон_заголовка = transparent
}}
<syntaxhighlight lang="c" line="1">
#include <stddef.h>

enum value_type_t {
    VALUE_TYPE_LONG, // целое число
    VALUE_TYPE_DOUBLE, // вещественное число
    VALUE_TYPE_STRING, // строка
    VALUE_TYPE_BINARY, // произвольные данные
};

struct binary_t {
    void *data; // указатель на данные
    size_t data_size; // размер данных
};

struct string_t {
    char *str; // указатель на строку
    size_t str_size; // размер строки
};

union value_contents_t {
    long as_long; // значение как целое число
    double as_double; // значение как вещественное число
    struct string_t as_string; // значение как строка
    struct binary_t as_binary; // значение как произвольные данные
};

struct value_t {
    enum value_type_t type; // тип значения
    union value_contents_t contents; // содержимое значения
};
</syntaxhighlight>
{{Конец скрытого блока}}

==== Массивы ====
[[Массив (программирование)|Массивы]] в языке Си примитивны и являются лишь синтаксическим абстрагированием над [[Указатель (тип данных)#Адресная арифметика|арифметикой указателей]]. Сам по себе массив является указателем на область памяти, поэтому вся информация о размерности массива и его границах может быть доступна только на этапе компиляции согласно описанию типа. Массивы могут быть как одномерными, так и многомерными, но обращение к элементу массива сводится к простому вычислению смещения относительно адреса начала массива. Поскольку массивы основаны на адресной арифметике, с ними возможно работать без использования индексов<ref name=":16">{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/ARR00-C.+Understand+how+arrays+work|title=ARR00-C. Understand how arrays work - SEI CERT C Coding Standard - Confluence|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-05-30|archive-date=2019-05-30|archive-url=https://web.archive.org/web/20190530043013/https://wiki.sei.cmu.edu/confluence/display/c/ARR00-C.%2BUnderstand%2Bhow%2Barrays%2Bwork|url-status=live}}</ref>. Так, например, следующие два примера считывания с потока ввода 10 чисел идентичны друг другу:
{{Начало скрытого блока
 |Рамка = 1px solid black
 |Ссылка = left
 |Выравнивание_заголовка = center
 |Заголовок = Сравнение работы через индексы с работой через адресную арифметикой
 |Фон_заголовка = transparent
}}
{| class="wikitable"
|+
!Код примера работы через индексы
!Код примера работы через адресную арифметику
|-
|<syntaxhighlight lang="c">
#include <stdio.h>

int a[10] = {0}; // Инициализация нулями
unsigned int count = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < count; ++i) {
    int *ptr = &a[i]; // Указатель на текущий элемента массива
    int n = scanf("%8d", ptr);
    if (n != 1) {
        perror("Не удалось считать значение");
        // Обработка ошибки
        break;
    }
}
</syntaxhighlight>
|<syntaxhighlight lang="c">
#include <stdio.h>

int a[10] = {0}; // Инициализация нулями
unsigned int count = sizeof(a) / sizeof(a[0]);
int *a_end = a + count; // Указатель на элемент, следующий за последним
for (int *ptr = a; ptr != a_end; ++ptr) {
    int n = scanf("%8d", ptr);
    if (n != 1) {
        perror("Не удалось считать значение");
        // Обработка ошибки
        break;
    }
}
</syntaxhighlight>
|}
{{Конец скрытого блока}}
Длина массивов с заранее известным размером вычисляется на этапе компиляции. В стандарте [[C99]] появилась возможность объявлять массивы переменной длины, у которых длина может задаваться на этапе выполнения. Под такие массивы выделяется память из области стека, поэтому их необходимо использовать с осторожностью, если их размер может задаваться извне программы. В отличие от выделения динамической памяти, превышение допустимого размера в области стека может повлечь непредсказуемые последствия, а отрицательная длина массива — [[неопределённое поведение]]. Начиная с [[C11]] массивы переменной длины являются опциональными для компиляторов, а отсутствие поддержки определяется наличием макроса <code>__STDC_NO_VLA__</code><ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/ARR32-C.+Ensure+size+arguments+for+variable+length+arrays+are+in+a+valid+range|title=ARR32-C. Ensure size arguments for variable length arrays are in a valid range - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-02-18|archive-date=2019-02-19|archive-url=https://web.archive.org/web/20190219020028/https://wiki.sei.cmu.edu/confluence/display/c/ARR32-C.+Ensure+size+arguments+for+variable+length+arrays+are+in+a+valid+range|url-status=live}}</ref>.

Массивы фиксированного размера, объявляемые как локальные или глобальные переменные, можно инициализировать, задавая им начальное значение с помощью фигурных скобок и перечисления элементов массива через запятую. В инициализаторах глобальных массивов допускается использовать только такие выражения, которые вычисляются на этапе компиляции{{sfn|Черновик стандарта C17|loc=6.7.9 Initialization|с=101}}. Переменные, используемые в таких выражениях должны объявляться как константы, с модификатором <code>const</code>. У локальных массивов инициализаторы могут содержать выражения с вызовами функций и использованием других переменных, в том числе можно заносить указатель на сам объявляемый массив.

Со стандарта C99 последним элементом структур допускается объявлять массив произвольной длины, что широко используется на практике и поддерживается различными компиляторами. Размер такого массива зависит от объёма памяти, выделяемого под структуру. При этом нельзя объявлять массив таких структур и нельзя их помещать в другие структуры. В операциях над такой структурой массив произвольной длины обычно игнорируется, в том числе и при вычислении размера структуры, а выход за пределы массива влечёт за собой неопределённое поведение<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/DCL38-C.+Use+the+correct+syntax+when+declaring+a+flexible+array+member|title=DCL38-C. Use the correct syntax when declaring a flexible array member - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-02-21|archive-date=2019-02-22|archive-url=https://web.archive.org/web/20190222151926/https://wiki.sei.cmu.edu/confluence/display/c/DCL38-C.+Use+the+correct+syntax+when+declaring+a+flexible+array+member|url-status=live}}</ref>.

Язык Си не предусматривает какого-либо контроля выхода за пределы массива, поэтому программист сам должен следить за работой с массивами. Ошибки при обработке массивов не всегда явно влияют на ход исполнения программы, но могут приводить к [[Ошибка сегментации|ошибкам сегментирования]] и [[Уязвимость (компьютерная безопасность)|уязвимостям]]{{переход|Отсутствие контроля над адресной арифметикой}}.

==== Синонимы типов ====
Язык Си допускает создание собственных названий типов с помощью оператора <code>'''typedef'''</code>. Альтернативные названия можно задавать как системным типам, так и пользовательским. Такие названия объявляются в глобальном пространстве имён и не конфликтуют с названиями типов структур, перечислений и объединений.

Альтернативные названия могут применяться как для упрощения кода, так и для создания уровней абстракции. Например, некоторые системные типы можно сократить для повышения [[Читабельность|читабельности]] кода или унифицирования его написания в пользовательском коде:<syntaxhighlight lang="c" line="1">
#include <stdint.h>

typedef int32_t i32_t;
typedef int_fast32_t i32fast_t;
typedef int_least32_t i32least_t;

typedef uint32_t u32_t;
typedef uint_fast32_t u32fast_t;
typedef uint_least32_t u32least_t;
</syntaxhighlight>Примером абстрагирования могут служить названия типов в заголовочных файлах операционных системах. Так, стандарт [[POSIX]] определяет тип <code>pid_t</code>, предназначенный для хранения числового идентификатора процесса. На самом деле данный тип является альтернативным названием для какого-либо примитивного типа, например:<syntaxhighlight lang="c" line="1">
typedef int             __kernel_pid_t;
typedef __kernel_pid_t  __pid_t
typedef __pid_t         pid_t;

</syntaxhighlight>Поскольку типы с альтернативными названиями являются лишь синонимами оригинальным типам, то между ними сохраняется полная совместимость и взаимозаменяемость.

== Препроцессор ==
{{основная статья|Препроцессор Си}}
Препроцессор работает до компиляции и преобразует текст файла программы согласно встреченным в нём или переданным в препроцессор [[Директива (программирование)|директивам]]. Технически препроцессор может быть реализован по-разному, но логически его удобно представлять именно как отдельный модуль, целиком обрабатывающий каждый предназначенный для компиляции файл и формирующий текст, попадающий затем на вход компилятора. Препроцессор ищет в тексте строки, начинающиеся с символа <code>#</code>, вслед за которым должны следовать директивы препроцессора. Всё, что не относится к директивам препроцессора и не исключено из компиляции согласно директивам, передаётся на вход компилятора в неизменном виде.

В число возможностей препроцессора входит:

* подмена заданной лексемы текстом с помощью директивы <code>#define</code>, включая возможность создания параметризованных шаблонов текста (вызываются аналогично функциям), а также отменять подобные подмены, что даёт возможность осуществлять подмену на ограниченных участках текста программы;
* условное встраивание и удаление кусков из текста, включая сами директивы, с помощью условных команд <code>#ifdef</code>, <code>#ifndef</code>, <code>#if</code>, <code>#else</code> и <code>#endif</code>;
* встраивание в текущий файл текста из другого файла с помощью директивы <code>#include</code>.

Важно понимать, что препроцессор обеспечивает только подстановку текста, не учитывая синтаксис и семантику языка. Так, например, макроопределения <code><nowiki>#define</nowiki></code> могут встречаться внутри функций или определений типов, а директивы условной компиляции могут приводить к исключению из компилируемого текста программы любой части кода, без оглядки на грамматику языка. Вызов параметрического макроса также отличается от вызова функции, поскольку не происходит анализа семантики аргументов, разделяемых запятой. Так, например, в аргументы параметрического макроса невозможно передать инициализацию массива, поскольку его элементы тоже разделяются запятой:<syntaxhighlight lang="c" line="1">
#define array_of(type, array) (((type) []) (array))
int *a;
a = array_of(int, {1, 2, 3}); // ошибка компиляции:
// в макрос "array_of" передано 4 аргумента, но он принимает лишь 2
</syntaxhighlight>Макроопределения часто используются для обеспечения совместимости с разными версиями библиотек, у которых изменился [[программный интерфейс|API]], включая те или иные участки кода в зависимости от версии библиотеки. Для этих целей библиотеки часто предоставляют макроопределения с описанием своей версии<ref>{{Cite web|url=https://www.openssl.org/docs/manmaster/man3/OPENSSL_VERSION_NUMBER.html|title=OpenSSL_version|author=|website=|date=|publisher=www.openssl.org|lang=en|access-date=2018-12-09|archive-date=2018-12-09|archive-url=https://web.archive.org/web/20181209212918/https://www.openssl.org/docs/manmaster/man3/OPENSSL_VERSION_NUMBER.html|url-status=live}}</ref>, а иногда и макросы с параметрами для сравнения текущей версии с заданной в рамках препроцессора<ref>{{Cite web|url=https://developer.gnome.org/gtk3/stable/gtk3-Feature-Test-Macros.html|title=Version Information: GTK+ 3 Reference Manual|author=|website=|date=|publisher=developer.gnome.org|lang=en|access-date=2018-12-09|archive-date=2018-11-16|archive-url=https://web.archive.org/web/20181116122443/https://developer.gnome.org/gtk3/stable/gtk3-Feature-Test-Macros.html|url-status=live}}</ref>. Также макроопределения применяются для [[Препроцессор Си#Условная компиляция|условной компиляции]] отдельных кусков программы, например для включения поддержки какого-либо дополнительного функционала.

Макроопределения с параметрами широко используются в Си-программах для создания аналогов [[Обобщённое программирование|обобщённых функций]]. Ранее они также применялись для реализации встраиваемых функций, но начиная со стандарта С99 эта необходимость исчезла благодаря добавлению <code>inline</code>-функций. Однако в связи с тем, что макроопределения с параметрами функциями не являются, но вызываются аналогичным образом, по ошибке программиста могут возникать неожиданные проблемы, включая отработку только части кода из макроопределения<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/PRE10-C.+Wrap+multistatement+macros+in+a+do-while+loop|title=PRE10-C. Wrap multistatement macros in a do-while loop - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2018-12-09|archive-date=2018-12-09|archive-url=https://web.archive.org/web/20181209214433/https://wiki.sei.cmu.edu/confluence/display/c/PRE10-C.%20Wrap%20multistatement%20macros%20in%20a%20do-while%20loop|url-status=live}}</ref> и неправильные приоритеты выполнения операций<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/PRE01-C.+Use+parentheses+within+macros+around+parameter+names|title=PRE01-C. Use parentheses within macros around parameter names - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2018-12-09|archive-date=2018-12-09|archive-url=https://web.archive.org/web/20181209212827/https://wiki.sei.cmu.edu/confluence/display/c/PRE01-C.+Use+parentheses+within+macros+around+parameter+names|url-status=live}}</ref>. В качестве примера ошибочного кода можно привести макрос возведения числа в квадрат:
<syntaxhighlight lang="c" line="1">
#include <stdio.h>

int main(void)
{
    #define SQR(x) x * x
    printf("%d", SQR(5)); // всё верно, 5*5=25
    printf("%d", SQR(5 + 0)); // предполагалось 25, но будет выведено 5 (5+0*5+0)
    printf("%d", SQR(4 / 3)); // всё верно, 1 (т. к. 4/3=1, 1*4=4, 4/3=1)
    printf("%d", SQR(5 / 2)); // предполагалось 4 (2*2), но будет выведено 5 (5/2*5/2)
    return 0;
}
</syntaxhighlight>
В приведённом выше примере ошибкой является то, что содержимое аргумента макроса подставляется в текст как есть, без учёта приоритетов операций. В таких случаях необходимо использовать <code>inline</code>-функции либо явно расставлять приоритеты операций в выражениях, использующих параметры макроса, с помощью круглых скобок:
<syntaxhighlight lang="c" line="1">
#include <stdio.h>

int main(void)
{
    #define SQR(x) ((x) * (x))
    printf("%d", SQR(4 + 1)); // верно, 25
    return 0;
}
</syntaxhighlight>

== Программирование на Си ==

=== Структура программы ===

==== Модули ====
Программа представляет собой набор файлов с кодом на языке Си, которые могут компилироваться в [[Объектный модуль|объектные файлы]]. Объектные файлы затем проходят этап [[Компоновщик|компоновки]] друг с другом, а также со внешними библиотеками, в результате чего получается итоговый [[исполняемый файл]] или [[Библиотека (программирование)|библиотека]]. Связь файлов друг с другом, равно как и с библиотеками, требует описания прототипов используемых функций, внешних переменных и необходимых типов данных в каждом файле. Такие данные принято выносить в отдельные [[Заголовочный файл|заголовочные файлы]], которые подключаются с помощью [[Директива (программирование)|директивы]] <code>#include</code> в тех файлах, где требуется та или иная функциональность, и позволяют организовывать систему, похожую на систему модулей. Модулем в таком случае может выступать:

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

Поскольку директива <code>#include</code> лишь подставляет текст другого файла на этапе [[Препроцессор Си|препроцессора]], многократное подключение одного и того же файла может приводить к ошибкам этапа компиляции. Поэтому в таких файлах используется [[Include guard|защита от повторного включения]] с помощью [[Макрокоманда|макрокоманд]] <code>#define</code> и <code>#ifndef</code><ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/PRE06-C.+Enclose+header+files+in+an+include+guard|title=PRE06-C. Enclose header files in an include guard - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-05-25|archive-date=2019-05-25|archive-url=https://web.archive.org/web/20190525182337/https://wiki.sei.cmu.edu/confluence/display/c/PRE06-C.%2BEnclose%2Bheader%2Bfiles%2Bin%2Ban%2Binclude%2Bguard|url-status=live}}</ref>.

==== Файлы исходного кода ====
Текст файла исходного кода на языке Си состоит из набора глобальных определений данных, типов и функций. Глобальные переменные и функции, объявленные со спецификаторами <code>static</code> и <code>inline</code>, доступны только в пределах того файла, в котором они объявлены, либо при включении одного файла в другой через директиву <code>#include</code>. При этом функции и переменные, объявленные в заголовочном файле со словом <code>static</code>, будут создаваться заново при каждом подключении заголовочного файла к очередному файлу с исходным кодом. Глобальные переменные и прототипы функции, объявленные со спецификатором extern, считаются подключаемыми из других файлов. То есть их допускается использовать в соответствии с описанием; предполагается, что после сборки программы они будут связаны [[компоновщик]]ом с оригинальными объектами и функциями, описанными в своих файлах.

Глобальные переменные и функции, кроме <code>static</code> и <code>inline</code>, могут быть доступны из других файлов при условии их надлежащего объявления там со спецификатором <code>extern</code>. Переменные и функции, объявленные с модификатором <code>static</code>, также могут быть доступны в других файлах, но лишь при передаче их адреса по указателю. Объявления типов <code>typedef</code>, <code>struct</code> и <code>union</code> не могут импортироваться в других файлах. При необходимости использования в других файлах они должны быть там продублированы либо вынесены в отдельный заголовочный файл. То же самое относится и к <code>inline</code>-функциям.

==== Точка входа программы ====
Для исполняемой программы стандартной точкой входа является функция с именем <code>main</code>, которая не может быть статической и должна быть единственной в программе. Исполнение программы начинается с первого оператора функции <code>main()</code> и продолжается до выхода из неё, после чего программа завершается и возвращает операционной системе абстрактный целочисленный код результата своей работы.
{| class="wikitable"
|+Допустимые прототипы функции <code>main()</code>{{sfn|Черновик стандарта C17|loc=5.1.2.2 Hosted environment|с=10—11}}
!Без аргументов
!С аргументами командной строки
|-
|<syntaxhighlight lang="c" line="1">
int main(void);
</syntaxhighlight>
|<syntaxhighlight lang="c" line="1">
int main(int argc, char** argv);
</syntaxhighlight>
|}
В переменную <code>argc</code> при вызове передаётся количество аргументов, переданных программе, включая и путь к самой программе, поэтому обычно переменная argc содержит значение не меньшее, чем 1. В переменную <code>argv</code> передаётся сама строка запуска программы в виде массива текстовых строк, последним элементом которого является <code>NULL</code>. Компилятор гарантирует, что на момент запуска функции <code>main()</code> все глобальные переменные в программе будут инициализированы{{sfn|Черновик стандарта C17|loc=6.2.4 Storage durations of objects|с=30}}.

В качестве результата функция <code>main()</code> может вернуть любое целое число в диапазоне значений типа <code>int</code>, которое будет передано операционной системе или другому окружению в качестве [[Код возврата|кода возврата]] программы{{sfn|Черновик стандарта C17|loc=5.1.2.2 Hosted environment|с=10—11}}. Стандарт языка не определяет смысла кодов возврата{{sfn|Черновик стандарта C17|loc=7.22.4.4 The exit function|с=256}}. Обычно операционная система, где работают программы, имеет те или иные средства, позволяющие получить значение кода возврата и проанализировать его. Иногда существуют определённые соглашения о значениях этих кодов. Общим является соглашение о том, что нулевое значение кода возврата сигнализирует об успешном завершении программы, а ненулевое представляет собой код возникшей ошибки. Заголовочный файл <code>[[stdlib.h]]</code> определяет два общих макроопределения <code>EXIT_SUCCESS</code> и <code>EXIT_FAILURE</code>, которые соответствуют успешному и неуспешному завершению работы программы{{sfn|Черновик стандарта C17|loc=7.22.4.4 The exit function|с=256}}. Коды возврата также могут использоваться в рамках приложений, включающих в себя множество процессов, для обеспечения взаимодействия между этими процессами, в случае чего приложение само определяет смысловое значение для каждого кода возврата.

=== Работа с памятью ===

==== Модель памяти ====
В Си предусмотрено 4 способа выделения памяти, которые определяют время жизни переменной и момент её инициализации{{sfn|Черновик стандарта C17|loc=6.2.4 Storage durations of objects|с=30}}.
{| class="wikitable"
|+Способы выделения памяти{{sfn|Черновик стандарта C17|loc=6.2.4 Storage durations of objects|с=30}}
!Способ выделения
!Целевые объекты
!Время выделения
!Время освобождения
!Накладные расходы
|- style="background:#fafbfc;"
|Статическое выделение памяти
|Глобальные переменные и переменные, помеченные ключевым словом <code>static</code> (но без <code>_Thread_local</code>)
|При старте программы
|По завершении работы программы
|Отсутствуют
|- style="background:#f6f7f8;"
|Выделение памяти на уровне потока
|Переменные, помеченные ключевым словом <code>_Thread_local</code>
|При старте потока
|По завершении потока
|При создании потока
|- style="background:#fafbfc;"
|Автоматическое выделение памяти
|Аргументы функций и возвращаемые ими значения, локальные переменные функций, в том числе регистры и массивы переменной длины
|При вызове функций на уровне [[стек]]а.
|Автоматически по завершении функций
|Незначительны, поскольку изменяется лишь указатель на вершину стека
|- style="background:#f6f7f8;"
|Динамическое выделение памяти
|Память, выделяемая через функции <code>malloc()</code>, <code>calloc()</code> и <code>realloc()</code>
|Вручную из [[Куча (память)|кучи]] в момент вызова используемой функции.
|Вручную с помощью функции <code>free()</code>
|Большие как на выделение, так и на освобождение
|}
Все эти способы хранения данных пригодны в различных ситуациях и имеют свои преимущества и недостатки. Глобальные переменные не позволяют писать [[Реентерабельность|реентерабельные]] алгоритмы, а автоматическое выделение памяти не позволяет возвращать произвольную область памяти из вызова функции. Автоматическое выделение также не подходит для выделения больших объёмов памяти, поскольку может привести к порче стека или кучи<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/MEM05-C.+Avoid+large+stack+allocations|title=MEM05-C. Avoid large stack allocations - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-05-24|archive-date=2019-05-24|archive-url=https://web.archive.org/web/20190524192146/https://wiki.sei.cmu.edu/confluence/display/c/MEM05-C.%2BAvoid%2Blarge%2Bstack%2Ballocations|url-status=live}}</ref>. Динамическая память лишена этих недостатков, но имеет большие накладные расходы при её использовании и более сложна в использовании.

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

Для автоматически выделяемых переменных с помощью модификатора <code>register</code> можно давать подсказку компилятору о необходимости быстрого доступа к ним. Такие переменные могут помещаться в регистры процессора. Из-за ограниченного количества регистров и возможных оптимизаций компилятора переменные могут оказаться в обычной памяти, но тем не менее из программы на них невозможно будет получить указатель{{sfn|Черновик стандарта C17|loc=6.7.1 Storage-class specifiers|с=79}}. Модификатор <code>register</code> является единственным, который можно указывать в аргументах функций{{sfn|Черновик стандарта C17|loc=6.7.6.3 Function declarators (including prototypes)|с=96}}.

==== Адресация памяти ====
Язык Си унаследовал линейную адресацию памяти при работе со структурами, массивами и выделенными областями памяти. Стандарт языка также допускает выполнение операций сравнения над нулевым указателем и над адресами в рамках массивов, структур и выделенных областей памяти. Также допускается работа с адресом элемента массива, следующим за последним, что сделано для облегчения написания алгоритмов. Однако сравнение указателей адресов, полученных для разных переменных (или областей памяти) не должно осуществляться, так как результат будет зависеть от реализации конкретного компилятора<ref>{{Cite web|url=https://www.viva64.com/ru/b/0576/|title=Указатели в C абстрактнее, чем может показаться|publisher=www.viva64.com|access-date=2018-12-30|archive-date=2018-12-30|archive-url=https://web.archive.org/web/20181230233505/https://www.viva64.com/ru/b/0576/|url-status=live}}</ref>.

==== Представление в памяти ====
Представление памяти программы зависит от аппаратной архитектуры, от [[Операционная система|операционной системы]] и от компилятора. Так, например, на большинстве архитектур стек растёт вниз, но существуют архитектуры, где стек растёт вверх<ref>{{Книга|автор=Таненбаум Эндрю С, Бос Херберт|год=2019|isbn=9785446111558|страниц=1120|издательство=Издательский дом "Питер"|заглавие=Современные операционные системы. 4-е изд|ссылка=https://books.google.ru/books?id=eGGLDwAAQBAJ&pg=PA828&lpg=PA828|ответственный=|издание=|место=СПб|страницы=828|isbn2=|серия=Классика "Computer science"|access-date=2019-05-22|archive-date=2021-08-07|archive-url=https://web.archive.org/web/20210807210218/https://books.google.ru/books?id=eGGLDwAAQBAJ&pg=PA828&lpg=PA828|url-status=live}}</ref>. Граница между стеком и кучей может быть частично защищена от переполнения стека специальной областью памяти<ref>{{Cite web|url=https://lwn.net/Articles/726580/|title=Ripples from Stack Clash|author=Jonathan Corbet|date=2017-06-28|publisher=lwn.net|lang=en|access-date=2019-05-25|archive-date=2019-05-25|archive-url=https://web.archive.org/web/20190525143440/https://lwn.net/Articles/726580/|url-status=live}}</ref>. А расположение данных и кода библиотек может зависеть от параметров компиляции<ref>{{Cite web|url=https://www.redhat.com/en/blog/hardening-elf-binaries-using-relocation-read-only-relro|title=Hardening ELF binaries using Relocation Read-Only (RELRO)|author=|website=|date=|publisher=www.redhat.com|lang=en|access-date=2019-05-25|archive-date=2019-05-25|archive-url=https://web.archive.org/web/20190525122849/https://www.redhat.com/en/blog/hardening-elf-binaries-using-relocation-read-only-relro|url-status=live}}</ref>. Стандарт Си абстрагируется над реализацией и позволяет писать переносимый код, однако понимание устройства памяти процесса помогает в отладке и написании безопасных и отказоустойчивых приложений.

===== Типовое представление памяти процесса в Unix-подобных ОС =====
[[Файл:C-memlayout-ru.svg|thumb|300px|Типовое представление виртуальной памяти процесса в Unix-подобных ОС<ref>{{Cite web|url=https://www.openbsd.org/papers/nycbsdcon08-pie/mgp00009.html|title=Traditional Process Address Space — Static Program|author=|website=|date=|publisher=www.openbsd.org|lang=en|access-date=2019-03-04|archive-date=2019-12-08|archive-url=https://web.archive.org/web/20191208125349/http://www.openbsd.org/papers/nycbsdcon08-pie/mgp00009.html|url-status=live}}</ref>]]
При запуске программы из исполняемого файла в оперативную память импортируются инструкции процессора (машинный код) и инициализированные данные. В то же время в старшие адреса импортируются аргументы командной строки (доступные в функции <code>main()</code> со следующей сигнатурой во втором аргументе <code>int argc, char ** argv</code>) и переменные окружения.

Область неинициализированных данных содержит глобальные переменные (в том числе, объявленные как <code>static</code>), которые не были проинициализированы в программном коде. Такие переменные по умолчанию инициализируются нулями после старта программы. Область инициализированных данных — сегмент данных — тоже содержит глобальные переменные, но в эту область попадают те переменные, которым было задано начальное значение. Неизменяемые данные, включающие в себя переменные, объявленные с модификатором <code>const</code>, строковые литералы и другие составные литералы, помещаются в сегмент текста программы. Сегмент текста программы содержит также исполняемый код и доступен только на чтение, поэтому попытка изменения данных из этого сегмента приведёт к неопределённому поведению в виде [[Ошибка сегментации|ошибки сегментации]].

Область стека предназначена для размещения данных, связанных с [[Стековый кадр|вызовом функций]], и локальных переменных. Перед каждым запуском функции стек увеличивается для размещения в нём аргументов, передаваемых в функцию. В ходе своей работы функция может размещать в стеке локальные переменные и выделять в нём память под массивы переменной длины, а некоторые компиляторы предоставляют также средства выделения памяти в рамках стека посредством вызова <code>alloca()</code>, который не входит в стандарт языка. После завершения работы функции стек уменьшается до того значения, которое было перед вызовом, однако этого может не происходить при некорректной работе со стеком. Память, выделенная динамически, предоставляется из [[Куча (память)|кучи]]{{Переход|Модель памяти|back}}.

Немаловажной деталью является наличие [[ASLR|случайного отступа]] между стеком и верхней областью<ref>{{Книга|автор=Dr Thabang Mokoteli|год=2017-03|isbn=9781911218289|страниц=567|издательство=Academic Conferences and publishing limited|заглавие=ICMLG 2017 5th International Conference on Management Leadership and Governance|ссылка=https://books.google.ru/books?id=iXWQDgAAQBAJ&pg=PA42&lpg=PA42|ответственный=|издание=|место=|страницы=42|isbn2=|access-date=2019-05-25|archive-date=2021-08-07|archive-url=https://web.archive.org/web/20210807210219/https://books.google.ru/books?id=iXWQDgAAQBAJ&pg=PA42&lpg=PA42|url-status=live}}</ref>, а также между областью инициализированных данных и [[Куча (память)|кучей]]. Делается это в целях безопасности, например, для предотвращения встраивания в стек других функций.

[[Динамическая библиотека|Динамически подключаемые]] библиотеки и отображения файлов с файловой системы находятся между стеком и [[Куча (память)|кучей]]<ref>{{Cite web|url=https://www.openbsd.org/papers/nycbsdcon08-pie/mgp00010.html|title=Traditional Process Address Space — Program w/Shared Libs|author=|website=|date=|publisher=www.openbsd.org|lang=en|access-date=2019-03-04|archive-date=2019-12-08|archive-url=https://web.archive.org/web/20191208214754/http://www.openbsd.org/papers/nycbsdcon08-pie/mgp00010.html|url-status=live}}</ref>.

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

==== Маркеры ошибок и errno ====
В языке Си активно используется специальная переменная <code>errno</code> из заголовочного файла <code>[[errno.h]]</code>, в которую функции заносят код ошибки, возвращая при этом значение, являющееся маркером ошибки. Для проверки результата на ошибки результат сравнивают с маркером ошибки, и, если они совпадают, то можно проанализировать код ошибки, сохранённый в <code>errno</code>, для корректировки работы программы или вывода отладочного сообщения. В стандартной библиотеке стандарт зачастую лишь определяет возвращаемые маркеры ошибок, а выставление <code>errno</code> зависит от конкретной реализации<ref name=":13">{{Cite web|url=https://wiki.sei.cmu.edu/confluence/pages/viewpage.action?pageId=87152351|title=ERR30-C. Set errno to zero before calling a library function known to set errno, and check errno only after the function returns a value indicating failure - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-05-23|archive-date=2018-11-19|archive-url=https://web.archive.org/web/20181119051646/https://wiki.sei.cmu.edu/confluence/pages/viewpage.action?pageId=87152351|url-status=live}}</ref>.

В качестве маркеров ошибок обычно выступают следующие значения:

* <code>-1</code> для типа <code>int</code> в случаях, когда отрицательный диапазон результата не используется<ref name=":11">{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/ERR33-C.+Detect+and+handle+standard+library+errors|title=ERR33-C. Detect and handle standard library errors - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-05-23|archive-date=2019-05-23|archive-url=https://web.archive.org/web/20190523160720/https://wiki.sei.cmu.edu/confluence/display/c/ERR33-C.%2BDetect%2Band%2Bhandle%2Bstandard%2Blibrary%2Berrors|url-status=live}}</ref>;
* <code>-1</code> для типа <code>ssize_t</code> (POSIX)<ref>{{Cite web|url=http://man7.org/linux/man-pages/man0/sys_types.h.0p.html|title=sys_types.h.0p - Linux manual page|author=|website=|date=|publisher=man7.org|lang=en|access-date=2019-05-23|archive-date=2019-05-23|archive-url=https://web.archive.org/web/20190523161438/http://man7.org/linux/man-pages/man0/sys_types.h.0p.html|url-status=live}}</ref>;
* <code>(size_t) -1</code> для типа <code>size_t</code><ref name=":11" />;
* <code>(time_t) -1</code> при использовании некоторых функций для работы со временем<ref name=":11" />;
* <code>NULL</code> для указателей<ref name=":11" />;
* <code>EOF</code> при потоковой работе с файлами<ref name=":11" />;
* ненулевой код ошибки<ref name=":11" />.

Практика возвращения маркера ошибки, вместо кода ошибки, хоть и экономит количество передаваемых в функции аргументов, но в ряде случаев приводит к ошибкам в результате человеческого фактора. Например, программистами часто игнорируется проверка результата типа <code>ssize_t</code>, а сам результат используется дальше в вычислениях, что приводит к трудно уловимым ошибкам, если возвращается <code>-1</code><ref name=":12" />.

Ещё сильнее способствует появлению ошибок возврат в качестве маркера ошибки корректного значения<ref name=":12">{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/ERR02-C.+Avoid+in-band+error+indicators|title=ERR02-C. Avoid in-band error indicators - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-01-04|archive-date=2019-01-05|archive-url=https://web.archive.org/web/20190105042852/https://wiki.sei.cmu.edu/confluence/display/c/ERR02-C.+Avoid+in-band+error+indicators|url-status=live}}</ref>, что также вынуждает программиста делать больше проверок, а соответственно и писать больше однотипного повторяющегося кода. Такой подход практикуется в потоковых функциях, работающих с объектами типа <code>FILE *</code>: маркером ошибки является значение <code>EOF</code>, одновременно являясь и маркером конца файла. Поэтому по <code>EOF</code> иногда приходится проверять поток символов как на конец файла с помощью функции <code>feof()</code>, так и наличие ошибки с помощью <code>ferror()</code><ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/FIO34-C.+Distinguish+between+characters+read+from+a+file+and+EOF+or+WEOF|title=FIO34-C. Distinguish between characters read from a file and EOF or WEOF - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-01-04|archive-date=2019-01-04|archive-url=https://web.archive.org/web/20190104231127/https://wiki.sei.cmu.edu/confluence/display/c/FIO34-C.+Distinguish+between+characters+read+from+a+file+and+EOF+or+WEOF|url-status=live}}</ref>. При этом некоторые функции, которые могут вернуть <code>EOF</code> по стандарту не обязаны выставлять <code>errno</code><ref name=":13" />{{переход|Отсутствие унификации обработки ошибок}}.

Отсутствие единой практики обработки ошибок в стандартной библиотеке приводит к появлению собственных способов обработки ошибок и комбинированию часто используемых способов в сторонних проектах. Например, в проекте [[systemd]] совместили идеи возвращения кода ошибки и числа <code>-1</code> в качестве маркера — возвращается отрицательный код ошибки<ref>{{Cite web|url=https://github.com/systemd/systemd/blob/master/docs/CODING_STYLE.md|title=Coding Style|author=|website=The systemd System and Service Manager|date=|publisher=github.com|lang=en|access-date=2019-02-01|archive-date=2020-12-31|archive-url=https://web.archive.org/web/20201231161552/https://github.com/systemd/systemd/blob/master/docs/CODING_STYLE.md|url-status=live}}</ref>. А в библиотеке [[GLib]] ввели в практику возвращение в качестве маркера ошибки значение [[Логический тип|булева типа]], в то время как подробная информация об ошибке помещается в специальную структуру, указатель на которую возвращается через последний аргумент функции<ref>{{Cite web|url=https://developer.gnome.org/glib/stable/glib-Error-Reporting.html|title=Error Reporting: GLib Reference Manual|author=|website=|date=|publisher=developer.gnome.org|lang=en|access-date=2019-02-01|archive-date=2019-02-02|archive-url=https://web.archive.org/web/20190202041448/https://developer.gnome.org/glib/stable/glib-Error-Reporting.html|url-status=live}}</ref>. Схожее решение использует проект [[Enlightenment]], в котором в качестве маркера тоже используется булев тип, но информация об ошибке возвращается по аналогии со стандартной библиотекой — через отдельную функцию<ref>{{Cite web|url=https://docs.enlightenment.org/api/eina/doc/html/group__Eina__Error__Group.html|title=Eina: Error|author=|website=|date=|publisher=docs.enlightenment.org|lang=en|access-date=2019-02-01|archive-date=2019-02-02|archive-url=https://web.archive.org/web/20190202042558/https://docs.enlightenment.org/api/eina/doc/html/group__Eina__Error__Group.html|url-status=live}}</ref>, которую необходимо проверять, если был возвращён маркер.

==== Возврат кода ошибки ====
Альтернативой маркерам ошибок является возвращение кода ошибки напрямую, а результата работы функции — через аргументы по указателю. По такому пути пошли разработчики стандарта POSIX, в функциях которого принято возвращать код ошибки в виде числа типа <code>int</code>. Однако возвращение значения типа <code>int</code> явно не даёт понять, что возвращается именно код ошибки, а не маркер, что может вести к ошибкам, если результат таких функций будет проверяться на значение <code>-1</code>. В расширении K стандарта C11 представлен специальный тип <code>errno_t</code> для хранения кода ошибки. Существуют рекомендации использовать именно этот тип в пользовательском коде для возвращения ошибок, а если он не предоставлен стандартной библиотекой, то объявлять его самостоятельно<ref name=":3" />:<syntaxhighlight lang="c" line="1">
#ifndef __STDC_LIB_EXT1__
  typedef int errno_t;
#endif
</syntaxhighlight>Такой подход, помимо повышения качества кода, избавляет от необходимости использования <code>errno</code>, что позволяет делать библиотеки с [[Реентерабельность|реентерабельными]] функциями без необходимости подключения дополнительных библиотек, таких как [[POSIX Threads]] для правильного определения <code>errno</code>.

==== Ошибки в математических функциях ====
Более сложной является обработка ошибок в математических функциях из заголовочного файла <code>[[math.h]]</code>, в которых могут возникать 3 типа ошибок<ref name=":4">{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/FLP32-C.+Prevent+or+detect+domain+and+range+errors+in+math+functions|title=FLP32-C. Prevent or detect domain and range errors in math functions - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-01-05|archive-date=2019-01-05|archive-url=https://web.archive.org/web/20190105201154/https://wiki.sei.cmu.edu/confluence/display/c/FLP32-C.+Prevent+or+detect+domain+and+range+errors+in+math+functions|url-status=live}}</ref>:

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

Предотвращение двух из трёх типов ошибок сводится к проверкам входных данных на область допустимых значений. Однако предсказать выход результата за пределы типа крайне сложно. Поэтому стандартом языка предусмотрена возможность анализа математических функций на ошибки. Начиная со стандарта C99 такой анализ возможен двумя способами, в зависимости от значения, хранимого в макросе <code>math_errhandling</code>.

# Если выставлен бит <code>MATH_ERRNO</code>, то переменную <code>errno</code> необходимо предварительно сбросить в <code>0</code>, а после вызова математической функции — проверить на ошибки <code>EDOM</code> и <code>ERANGE</code>.
# Если выставлен бит <code>MATH_ERREXCEPT</code>, то возможные математические ошибки предварительно сбрасываются функцией <code>feclearexcept()</code> из заголовочного файла <code>[[fenv.h]]</code>, а после вызова математической функции —тестируются с помощью функции <code>fetestexcept()</code>.

При этом способ обработки ошибок определяется конкретной реализацией стандартной библиотеки и может отсутствовать совсем. Поэтому в платформонезависимом коде может потребоваться проверка результата сразу двумя способами, в зависимости от значения <code>math_errhandling</code><ref name=":4" />.

==== Освобождение ресурсов ====
Как правило возникновение ошибки требует завершения работы функции с возвращением индикатора ошибки. Если в функции ошибка может возникнуть в разных её частях, требуется освобождать ресурсы, выделенные в ходе её работы, чтобы предотвратить утечки. Хорошей практикой освобождения ресурсов считается их чистка в обратном порядке перед возвратом из функции, а в случае ошибок — освобождение в обратном порядке после основного <code>return</code>. В отдельные части такого освобождения можно сделать переход с помощью оператора <code>goto</code><ref name=":14">{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/MEM12-C.+Consider+using+a+goto+chain+when+leaving+a+function+on+error+when+using+and+releasing+resources?focusedCommentId=88016241#comment-88016241|title=MEM12-C. Consider using a goto chain when leaving a function on error when using and releasing resources - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-01-04|archive-date=2019-01-05|archive-url=https://web.archive.org/web/20190105043120/https://wiki.sei.cmu.edu/confluence/display/c/MEM12-C.+Consider+using+a+goto+chain+when+leaving+a+function+on+error+when+using+and+releasing+resources?focusedCommentId=88016241#comment-88016241|url-status=live}}</ref>. Подобный подход позволяет вынести не связанные с реализуемым алгоритмом участки кода за пределы самого алгоритма, повышая читабельность кода, и схож с работой оператора <code>defer</code> из языка программирования [[Go]]. Пример освобождения ресурсов приведён ниже, в разделе примеров{{переход|Обработка ошибок на примере чтения файла}}.

Для освобождения ресурсов в рамках программы предусмотрен механизм обработчиков выхода из программы. Обработчики назначаются с помощью функции <code>atexit()</code> и исполняются как по завершении функции <code>main()</code> через оператор <code>return</code>, так и по исполнению функции <code>exit()</code>. При этом обработчики не исполняются по функциям <code>abort()</code> и <code>_Exit()</code><ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/ERR04-C.+Choose+an+appropriate+termination+strategy|title=ERR04-C. Choose an appropriate termination strategy - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-01-04|archive-date=2019-01-05|archive-url=https://web.archive.org/web/20190105200919/https://wiki.sei.cmu.edu/confluence/display/c/ERR04-C.+Choose+an+appropriate+termination+strategy|url-status=live}}</ref>.

В качестве примера освобождения ресурсов по завершении программы можно привести освобождение памяти, выделенной под глобальные переменные. Несмотря на то, что память так или иначе освобождается по завершении работы программы операционной системой, и допускается не освобождать ту память, которая требуется на протяжении всей работы программы<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/MEM31-C.+Free+dynamically+allocated+memory+when+no+longer+needed|title=MEM31-C. Free dynamically allocated memory when no longer needed - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-01-06|archive-date=2019-01-06|archive-url=https://web.archive.org/web/20190106192228/https://wiki.sei.cmu.edu/confluence/display/c/MEM31-C.+Free+dynamically+allocated+memory+when+no+longer+needed|url-status=live}}</ref>, явное освобождение предпочтительнее, так как облегчает поиск утечек памяти сторонними средствами и уменьшает шанс на возникновение утечек памяти в результате ошибки:
{{Начало скрытого блока
 |Рамка = 1px solid black
 |Ссылка = left
 |Выравнивание_заголовка = center
 |Заголовок = Код примера программы с освобождением ресурсов
 |Фон_заголовка = transparent
}}
<syntaxhighlight lang="c" line="1">
#include <stdio.h>
#include <stdlib.h>

int numbers_count;
int *numbers;

void free_numbers(void)
{
    free(numbers);
}

int main(int argc, char **argv)
{
    if (argc < 2) {
        exit(EXIT_FAILURE);
    }
    numbers_count = atoi(argv[1]);
    if (numbers_count <= 0) {
        exit(EXIT_FAILURE);
    }
    
    numbers = calloc(numbers_count, sizeof(*numbers));
    if (!numbers) {
        perror("Ошибка выделения памяти под массив");
        exit(EXIT_FAILURE);
    }
    atexit(free_numbers);
    
    // ... работа с массивом numbers
    
    // Здесь будет автоматически вызван обработчик free_numbers()
    return EXIT_SUCCESS;
}
</syntaxhighlight>
{{Конец скрытого блока}}
Недостатком данного подхода является то, что формат назначаемых обработчиков не предусматривает передачу произвольных данных в функцию, что позволяет создавать обработчики только для глобальных переменных.

=== Примеры программ на Си ===

==== Минимальная программа на Си ====
Минимальная программа на Си, не требующая обработки аргументов, имеет следующий вид:
<source lang="c" line="1">
int main(void){}

</source>
Допускается не писать оператор <code>return</code> у функции <code>main()</code>. В таком случае, согласно стандарту, функция <code>main()</code> возвращает 0, исполняя все обработчики, назначенные на функцию <code>exit()</code>. При этом подразумевается, что программа успешно завершилась<ref name=":0">{{Книга|автор=Joint Technical Committee ISO/IEC JTC 1|заглавие=ISO/IEC 9899:201x. Programming languages — C|ссылка=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1539.pdf|ответственный=|издание=|место=|издательство=ISO/IEC|год=2011|страницы=14|страниц=678|isbn=|isbn2=|access-date=2017-05-22|archive-date=2017-05-30|archive-url=https://web.archive.org/web/20170530154804/http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1539.pdf|url-status=live}}</ref>.

==== Hello, world! ====
Программа [[Hello, world!]] приведена ещё в первом издании книги «[[Язык программирования Си (книга)|Язык программирования Си]]» Кернигана и Ритчи:
<source lang="c" line="1">
#include <stdio.h>

int main(void) // Не принимает аргументы
{  
    printf("Hello, world!\n"); // '\n' - новая строка
    return 0; // Удачное завершение программы
}
</source>
Эта программа печатает сообщение «[[Hello, world!]]» на стандартном [[устройство вывода|устройстве вывода]].

==== Обработка ошибок на примере чтения файла ====
Многие функции языка Си могут вернуть ошибку, не выполнив требуемых от них действий. Ошибки требуется проверять и правильно на них реагировать, в том числе часто требуется пробрасывать ошибку из функции на уровень выше для анализа. При этом функцию, в которой произошла ошибка, можно делать [[Реентерабельность|реентерабельной]], в таком случае по ошибке функция не должна изменять входные или выходные данные, что позволяет безопасно перезапускать её после исправления ошибочной ситуации.

В примере реализована функция чтения файла на языке Си, однако она требует соответствия функций <code>fopen()</code> и <code>fread()</code> стандарту [[POSIX]], иначе они могут не выставлять переменную <code>errno</code>, что сильно усложняет как отладку, так и написание универсального и безопасного кода. На платформах, не соответствующих POSIX, поведение данной программы будет неопределённым в случае ошибки{{переход|Отсутствие унификации обработки ошибок}}. Освобождение ресурсов по ошибкам находится за основным алгоритмом для повышения читабельности, а переход осуществляется с помощью <code>goto</code><ref name=":14" />.
{{Начало скрытого блока
 |Рамка = 1px solid black
 |Ссылка = left
 |Выравнивание_заголовка = center
 |Заголовок = Код примера программы чтения файла с обработкой ошибок
 |Фон_заголовка = transparent
}}
<syntaxhighlight lang="c" line="1">
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

// Определяем тип для хранения кода ошибки, если он не определён
#ifndef __STDC_LIB_EXT1__
  typedef int errno_t;
#endif
enum {
    EOK = 0, // значение errno_t при успешном завершении
};

// Функция чтения содержимого файла
errno_t get_file_contents(const char *filename,
                          void **contents_ptr,
                          size_t *contents_size_ptr)
{
    FILE *f;
    f = fopen(filename, "rb");
    if (!f) {
        // В POSIX fopen() выставляет errno по ошибке
        return errno;
    }

    // Получаем размер файла
    fseek(f, 0, SEEK_END);
    long contents_size = ftell(f);
    if (contents_size == 0) {
        *contents_ptr = NULL;
        *contents_size_ptr = 0;
        goto cleaning_fopen;
    }
    rewind(f);

    // Переменная для хранения возвращаемого кода ошибки
    errno_t saved_errno;

    void *contents;
    contents = malloc(contents_size);
    if (!contents) {
        saved_errno = errno;
        goto aborting_fopen;
    }

    // Читаем содержимое файла целиком по указателю contents
    size_t n;
    n = fread(contents, contents_size, 1, f);
    if (n == 0) {
        // Не проверяем на feof(), т. к. буферизировано после fseek()
        // В POSIX fread() выставляет errno по ошибке
        saved_errno = errno;
        goto aborting_contents;
    }

    // Возвращаем выделенную память и её размер
    *contents_ptr = contents;
    *contents_size_ptr = contents_size;

    // Секция освобождения ресурсов по успешному завершению
cleaning_fopen:
    fclose(f);
    return EOK;

    // Отдельная секция для освобождения ресурсов по ошибке
aborting_contents:
    free(contents);
aborting_fopen:
    fclose(f);
    return saved_errno;
}

int main(int argc, char **argv)
{
    if (argc < 2) {
        return EXIT_FAILURE;
    }
    const char *filename = argv[1];
    
    errno_t errnum;
    
    void *contents;
    size_t contents_size;
    errnum = get_file_contents(filename, &contents, &contents_size);
    if (errnum) {
        char buf[1024];
        const char *error_text = strerror_r(errnum, buf, sizeof(buf));
        fprintf(stderr, "%s\n", error_text);
        exit(EXIT_FAILURE);
    }
    
    printf("%.*s", (int) contents_size, contents);
    
    free(contents);
    
    return EXIT_SUCCESS;
}
</syntaxhighlight>
{{Конец скрытого блока}}

=== Средства разработки ===

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

* [[GNU Compiler Collection]] (GCC) полностью поддерживает стандарты [[C99]] и C17 ([[C11]] с исправлениями)<ref>{{Cite web|url=https://gcc.gnu.org/onlinedocs/gcc/Standards.html|title=Using the GNU Compiler Collection (GCC): Standards|author=|website=|date=|publisher=gcc.gnu.org|lang=en|access-date=2019-02-23|archive-date=2012-06-17|archive-url=https://web.archive.org/web/20120617213251/http://gcc.gnu.org/onlinedocs/gcc/Standards.html|url-status=live}}</ref>. Также поддерживает расширения GNU, защиту кода с помощью санитайзеров и набор дополнительных возможностей, в том числе атрибуты.
* [[Clang]] также полностью поддерживает стандарты C99<ref>{{Cite web|url=https://clang.llvm.org/compatibility.html|title=Language Compatibility|author=|website=|date=|publisher=clang.llvm.org|lang=en|access-date=2019-02-23|archive-date=2019-02-19|archive-url=https://web.archive.org/web/20190219134229/http://clang.llvm.org/compatibility.html|url-status=live}}</ref> и C17<ref>{{Cite web|url=https://releases.llvm.org/6.0.0/tools/clang/docs/ReleaseNotes.html|title=Clang 6.0.0 Release Notes — Clang 6 documentation|publisher=releases.llvm.org|access-date=2019-02-23|archive-date=2019-02-23|archive-url=https://web.archive.org/web/20190223032847/http://releases.llvm.org/6.0.0/tools/clang/docs/ReleaseNotes.html|url-status=live}}</ref>. Разрабатывается во многом совместимым с компилятором GCC, в том числе поддерживает расширения GNU и защиту кода санитайзерами.
{{col-begin}}
{{col-3}}
* [[BDS C]]
* [[Borland C++]]
* [[C++ Builder]]
* [[Digital Mars]]
* [[DJGPP]]
{{col-3}}
* [[Intel C++ compiler]]
* [[LCC]]
* [[Microsoft Visual Studio]]
* [[MinGW]]
* [[Open Watcom]]
{{col-3}}
* [[Oracle Solaris Studio]]
* [[Pelles C]]
* [[Portable C Compiler]]
* [[Tiny C Compiler]]
* Topspeed [[JPI]] C
{{col-end}}

==== Реализации стандартной библиотеки ====
Несмотря на то, что [[Стандартная библиотека языка Си|стандартная библиотека]] входит в стандарт языка, её реализации идут отдельно от компиляторов. Поэтому стандарты языка, поддерживаемые компилятором и библиотекой, могут различаться.

* Открытая библиотека [[glibc]] является основной во многих дистрибутивах [[Linux|GNU/Linux]], поддерживает стандарты C11 и [[POSIX#POSIX.1-2008|POSIX.1-2008]]<ref>{{Cite web|url=https://sourceware.org/ml/libc-alpha/2019-01/msg00723.html|title=Siddhesh Poyarekar - The GNU C Library version 2.29 is now available|author=|website=|date=|publisher=sourceware.org|lang=en|access-date=2019-02-02|archive-date=2019-02-02|archive-url=https://web.archive.org/web/20190202042424/https://sourceware.org/ml/libc-alpha/2019-01/msg00723.html|url-status=live}}</ref>, а также предоставляет набор исправлений и дополнительных возможностей от [[GNU]].
* Открытая библиотека [[musl]] задумывалась в качестве более легковесной замены для glibc, используется как библиотека по умолчанию в дистрибутиве [[Alpine Linux]]<ref>{{Cite web|url=https://alpinelinux.org/posts/Alpine-Linux-has-switched-to-musl-libc.html|title=Alpine Linux has switched to musl libc {{!}} Alpine Linux|author=|website=|date=|publisher=alpinelinux.org|lang=en|access-date=2019-02-02|archive-date=2019-02-03|archive-url=https://web.archive.org/web/20190203030716/https://alpinelinux.org/posts/Alpine-Linux-has-switched-to-musl-libc.html|url-status=live}}</ref>, Void Linux<ref>{{Cite web|url=https://docs.voidlinux.org/installation/musl.html|title=musl - Void Linux Handbook|website=docs.voidlinux.org|access-date=2022-01-29|archive-date=2021-12-09|archive-url=https://web.archive.org/web/20211209181843/https://docs.voidlinux.org/installation/musl.html|url-status=live}}</ref>.
* Библиотека CRT от [[Microsoft]] поддерживает стандарт C99, поставляется как компонент в составе [[Windows 10]]<ref>{{Cite web|url=https://docs.microsoft.com/ru-ru/cpp/c-runtime-library/crt-library-features|title=Особенности библиотеки CRT|author=|website=|date=|publisher=docs.microsoft.com|lang=ru|access-date=2019-02-02|archive-date=2021-08-07|archive-url=https://web.archive.org/web/20210807210221/https://docs.microsoft.com/ru-ru/cpp/c-runtime-library/crt-library-features?view=msvc-160|url-status=live}}</ref>.

==== [[Интегрированная среда разработки|Интегрированные среды разработки]] ====
* [[CLion]] полностью поддерживает C99, но поддержка С11 — частичная<ref>{{Cite web|url=https://www.jetbrains.com/clion/features/supported-languages.html|title=Supported Languages - Features {{!}} CLion|author=|website=|date=|publisher=JetBrains|lang=en|access-date=2019-02-23|archive-date=2019-03-25|archive-url=https://web.archive.org/web/20190325032025/https://www.jetbrains.com/clion/features/supported-languages.html|url-status=live}}</ref>, сборка основана на CMake.
* [[Code::Blocks]] — свободная кроссплатформенная интегрированная среда разработки для языков Си, C++, D, Fortran. Поддерживает более двух десятков компиляторов. С компилятором [[GCC]] доступен Си всех версий от C90 до C17.
* [[Eclipse (среда разработки)|Eclipse]] — [[Свободное программное обеспечение|свободная]] интегрированная среда разработки, поддерживающая язык Си стандарта С99. Имеет модульную архитектуру, что даёт возможность подключения поддержки разных языков программирования и дополнительных возможностей. Доступен модуль для интеграции с [[Git]], однако отсутствует интеграция с [[CMake]].
* [[KDevelop]] — свободная интегрированная среда разработки, поддерживающая некоторые особенности языка Си из стандарта C11. Позволяет управлять проектами, использующими разные языки программирования, включая [[C++]] и [[Python]], поддерживает систему сборки CMake. Имеет встроенную поддержку Git на уровне работы с файлами и настраиваемое форматирование исходного кода для разных языков.
* [[Microsoft Visual Studio]] лишь частично поддерживает стандарты C99 и C11, поскольку ориентируется на разработку под C++, однако имеет встроенную поддержку CMake.
* [[STM32CubeIDE]] — среда разработки, созданная [[STMicroelectronics]], ориентированная на создание кода для микроконтроллеров [[STM32]]. Имеет инструмент для автоматической генерации кода, адаптированного под конкретное оборудование и дополнительное программное обеспечение.

==== Средства модульного тестирования ====
Поскольку язык Си не предоставляет средств для безопасного написания кода, а многие элементы языка способствуют появлению ошибок, написание качественного и отказоустойчивого кода можно гарантировать только с помощью создания автоматизированных тестов. Для упрощения такого тестирования существуют различные реализации сторонних библиотек [[Модульное тестирование|модульного тестирования]].

* Библиотека [[Check (библиотека модульного тестирования)|Check]] предоставляет [[фреймворк]] для тестирования программного кода на языке Си в общепринятом стиле [[xUnit]]. Среди возможностей можно упомянуть запуск тестов в отдельных процессах через <code>[[Fork|fork()]]</code>, что позволяет распознавать в тестах [[Ошибка сегментации|ошибки сегментирования]]<ref name=":8">{{Cite web|url=http://check.sourceforge.net/doc/check_html/check_2.html#Unit-Testing-in-C|title=Check 0.10.0: 2. Unit Testing in C|author=|website=|date=|publisher=check.sourceforge.net|lang=en|access-date=2019-02-23|archive-date=2018-06-05|archive-url=https://web.archive.org/web/20180605092714/http://check.sourceforge.net/doc/check_html/check_2.html#Unit-Testing-in-C|url-status=live}}</ref>, а также даёт возможность задавать максимальное время исполнения отдельных тестов.
* Библиотека [[Google C++ Testing Framework|Google Test]] также предоставляет тестирование по принципам xUnit, но предназначена для тестирования кода на языке [[C++]], что позволяет её использовать для тестирования кода и на языке Си. Также поддерживает изолированное тестирование отдельных частей программы. Одним из достоинств библиотеки является разделение макросов тестирования на утверждения и ошибки, что может облегчить отладку кода.

Существует также много других систем для тестирования кода на Си, таких как AceUnit, GNU Autounit, cUnit и других, но они либо не осуществляют тестирование в изолированных окружениях, либо предоставляют мало возможностей<ref name=":8" />, либо перестали развиваться.

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

* [[GNU Debugger|Gdb]] — интерактивный консольный отладчик для различных языков, в том числе и для Си.
* [[Valgrind]] является средством [[Динамический анализ кода|динамического анализа кода]], может выявлять ошибки в коде непосредственно во время выполнения программы. Поддерживает выявление: утечек, обращений в неинициализированную память, обращений по неверным адресам (в том числе переполнение буфера). Также поддерживает исполнение в режиме профилирования с помощью профайлера callgrind<ref>{{Cite web|url=http://valgrind.org/docs/manual/cl-manual.html|title=6. Callgrind: a call-graph generating cache and branch prediction profiler|author=|website=Valgrind Documentation|date=|publisher=valgrind.org|lang=en|access-date=2019-05-21|archive-date=2019-05-23|archive-url=https://web.archive.org/web/20190523084746/http://valgrind.org/docs/manual/cl-manual.html|url-status=live}}</ref>.
* [[KCacheGrind]] — графический интерфейс для визуализации результатов профилирования, полученных с помощью [[Профилирование (информатика)|профайлера]] callgrind<ref>{{Cite web|url=http://kcachegrind.sourceforge.net/html/Home.html|title=KCachegrind|publisher=kcachegrind.sourceforge.net|access-date=2019-05-21|archive-date=2019-04-06|archive-url=https://web.archive.org/web/20190406232239/http://kcachegrind.sourceforge.net/html/Home.html|url-status=live}}</ref>.

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

* [[Emscripten]]<ref>{{Cite web |url=https://github.com/kripken/emscripten/ |title=Emscripten LLVM-to-JavaScript compiler |access-date=2012-09-25 |archive-date=2012-12-17 |archive-url=https://web.archive.org/web/20121217214800/https://github.com/kripken/emscripten/ |url-status=live }}</ref> — компилятор из LLVM-байт-кода (например, полученный из [[C++]]) в [[JavaScript]].
* {{iw|Flascc}} (старое название — Alchemy)<ref>{{Cite web |url=http://gaming.adobe.com/technologies/flascc/ |title=Flash C++ Compiler |access-date=2013-01-25 |archive-date=2013-05-25 |archive-url=https://web.archive.org/web/20130525005202/http://gaming.adobe.com/technologies/flascc/ |url-status=live }}</ref> — компилятор из Си/[[C++]] в [[ActionScript]] Virtual Machine (AVM2). Позволяет использовать Си-библиотеки в [[Adobe Flash|Flash]]- и [[Adobe Integrated Runtime|Adobe AIR]]-приложениях.
* Clue<ref>{{sourceforge|cluecc|Clue}}</ref> — компилятор из ANSI Си в [[Lua]], [[JavaScript]], [[Perl]], [[Java]], [[Common Lisp]].
* AMPC<ref>{{Cite web |url=http://www.axiomsol.com/ |title=Axiomatic Solutions Sdn Bhd |access-date=2009-03-07 |archive-date=2009-02-23 |archive-url=https://web.archive.org/web/20090223214737/http://axiomsol.com/ |url-status=live }}</ref> — компилятор из Си в виртуальную машину [[Java]].

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

* [[Cppcheck]] — статический анализатор кода для языков Си и C++ с [[Открытое программное обеспечение|открытыми исходными текстами]], иногда выдаёт ложные срабатывания, которые можно подавлять специально оформленными комментариями в коде.
* [[Clang-format]] — утилита командной строки для форматирования исходного кода согласно заданному стилю, который может указываться в специально оформленном файле конфигурации. Обладает множеством параметров и несколькими встроенными стилями. Разрабатывается в рамках проекта [[Clang]]<ref>{{Cite web|url=https://clang.llvm.org/docs/ClangFormat.html|title=ClangFormat — Clang 9 documentation|author=|website=|date=|publisher=clang.llvm.org|lang=en|access-date=2019-03-05|archive-date=2019-03-06|archive-url=https://web.archive.org/web/20190306044642/https://clang.llvm.org/docs/ClangFormat.html|url-status=live}}</ref>.
* Утилиты [[Indent (Unix)|Indent]] и GNU Indent также предоставляют форматирование кода, но параметры форматирования задаются в виде опций командной строки<ref>{{Cite web|url=https://linux.die.net/man/1/indent|title=indent(1) - Linux man page|author=|website=|date=|publisher=linux.die.net|lang=en|access-date=2019-03-05|archive-date=2019-05-13|archive-url=https://web.archive.org/web/20190513205457/https://linux.die.net/man/1/indent|url-status=live}}</ref>.

== Область применения ==
[[Файл:The C Programming Language.png|thumb|The C Programming Language]]
Язык широко применяется при разработке операционных систем, на уровне прикладного интерфейса операционных систем, во встраиваемых системах, а также для создания высокопроизводительного или критического в плане обработки ошибок кода. Одной из причин широкого распространения для программирования на низком уровне является возможность писать кроссплатформенный код, который может по-разному обрабатываться на разном оборудовании и на разных операционных системах.

Возможность писать высокопроизводительный код обеспечивается за счёт полной свободы действий программиста и отсутствия строгого контроля со стороны компилятора. Так, например, на языке Си написаны первые реализации языков [[Java]], [[Python]], [[Perl]] и [[PHP]]. При этом во многих программах наиболее требовательные к ресурсам части принято писать на языке Си. Ядро программы [[Mathematica]]<ref>{{Cite web|url=http://library.wolfram.com/infocenter/Books/8515/SystemsInterfacesAndDeployment.pdf|title=SYSTEMS INTERFACES AND DEPLOYMENT|author=Wolfram Research, Inc.|website=Wolfram Mathematica® Tutorial Collection|date=2008|pages=36—37|publisher=library.wolfram.com|lang=en|access-date=2019-05-29|archive-date=2015-09-06|archive-url=https://web.archive.org/web/20150906070114/http://library.wolfram.com/infocenter/Books/8515/SystemsInterfacesAndDeployment.pdf|url-status=live}}</ref> написано на Си, а [[MATLAB]], изначально написанный на [[Фортран]]е, был переписан на Си в 1984 году<ref>{{Cite web|url=https://www.mathworks.com/tagteam/72887_92020v00Cleve_Growth_MATLAB_MathWorks_Two_Decades_Jan_2006.pdf|title=The Growth of MATLAB and The MathWorks over Two Decades|author=Cleve Moler|website=TheMathWorks News&Notes|date=2006-01|publisher=www.mathworks.com|access-date=2019-05-29|archive-date=2016-03-04|archive-url=https://web.archive.org/web/20160304022710/http://www.mathworks.com/tagteam/72887_92020v00Cleve_Growth_MATLAB_MathWorks_Two_Decades_Jan_2006.pdf|url-status=live}}</ref>.

Также Си иногда используется как промежуточный язык при компиляции более высокоуровневых языков. Например, по такому принципу работали первые реализации языков [[C++]], [[Objective-C]] и [[Go]], — код, написанный на этих языках, транслировался в промежуточное представление на языке Си. Современными языками, работающими по такому же принципу, являются язык [[Vala]] и [[Nim]].

Ещё одной областью применения языка Си являются приложения [[Система реального времени|реального времени]], которые требовательны по части отзывчивости кода и времени его исполнения. Такие приложения должны начинать исполнение действий в жёстко ограниченных временных рамках, а сами действия должны укладываться в определённый временной промежуток. В частности, стандарт [[POSIX|POSIX.1]] предоставляет набор функций и возможностей для создания приложений реального времени<ref>{{Cite web|url=http://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_setscheduler.html|title=sched_setscheduler|author=|website=|date=|publisher=pubs.opengroup.org|lang=en|access-date=2019-02-04|archive-date=2019-02-24|archive-url=https://web.archive.org/web/20190224025306/http://pubs.opengroup.org/onlinepubs/9699919799/functions/sched_setscheduler.html|url-status=live}}</ref><ref>{{Cite web|url=http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_gettime.html|title=clock_gettime|author=|website=|date=|publisher=pubs.opengroup.org|lang=en|access-date=2019-02-04|archive-date=2019-02-24|archive-url=https://web.archive.org/web/20190224011136/http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_gettime.html|url-status=live}}</ref><ref>{{Cite web|url=http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_nanosleep.html|title=clock_nanosleep|author=|website=|date=|publisher=pubs.opengroup.org|lang=en|access-date=2019-02-04|archive-date=2019-02-24|archive-url=https://web.archive.org/web/20190224021208/http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_nanosleep.html|url-status=live}}</ref>, однако поддержка жёсткого реального времени должна быть также реализована и со стороны [[Операционная система реального времени|операционной системы]]<ref>{{Cite web|url=http://www.ibm.com/developerworks/ru/library/l-real-time-linux/index.html|title=Анатомия Linux-архитектур реального времени|author=М. Джонс|website=|date=2008-10-30|publisher=www.ibm.com|lang=ru|access-date=2019-02-04|archive-date=2019-02-07|archive-url=https://web.archive.org/web/20190207072445/https://www.ibm.com/developerworks/ru/library/l-real-time-linux/index.html|url-status=live}}</ref>.

== Языки-потомки ==
[[Файл:Tiobe index.png|thumb|upright=1.9|График [[Индекс TIOBE|индекса TIOBE]], показывающий сравнение популярности различных языков программирования<ref>{{Cite web|url=https://www.tiobe.com/tiobe-index/|title=TIOBE Index|author=|website=www.tiobe.com|date=|publisher=|lang=en|access-date=2019-02-02|archive-date=2018-02-25|archive-url=https://web.archive.org/web/20180225101948/https://www.tiobe.com/tiobe-index/|url-status=live}}</ref>]]
Язык Си был и остаётся одним из самых распространённых языков программирования в течение более чем сорока лет. Естественно, что его влияние можно проследить в той или иной мере во многих более поздних языках. Тем не менее среди языков, достигших определённого распространения, прямых потомков у Си немного.

Часть языков-потомков надстраивает Си дополнительными средствами и механизмами, добавляющими поддержку новых парадигм программирования ([[Объектно-ориентированное программирование|ООП]], [[функциональное программирование]], [[обобщённое программирование]] и пр.). К таким языкам относятся, прежде всего, [[C++]] и [[Objective-C]], а опосредованно — их потомки [[Swift (язык программирования)|Swift]] и [[D (язык программирования)|D]]. Также известны попытки улучшить Си, исправив его наиболее существенные недостатки, но сохранив его привлекательные черты. Среди них можно упомянуть исследовательский язык [[Cyclone (язык программирования)|Cyclone]] (и его потомок [[Rust (язык программирования)|Rust]]). Иногда оба направления развития объединяются в одном языке, примером может служить [[Go]].

Отдельно необходимо упомянуть о целой группе языков, которые в большей или меньшей мере унаследовали базовый синтаксис Си (использование фигурных скобок в качестве ограничителей блоков кода, описание переменных, характерные формы операторов <code>for</code>, <code>while</code>, <code>if</code>, <code>switch</code> с параметрами в скобках, комбинированные операции <code>++</code>, <code>--</code>, <code>+=</code>, <code>-=</code> и другие), из-за чего программы на этих языках имеют характерный внешний вид, ассоциирующийся именно с Си. Это такие языки как [[Java]], [[JavaScript]], [[PHP]], [[Perl]], [[AWK]], [[C Sharp|C#]]. В действительности структура и семантика этих языков сильно отличается от Си, и обычно они предназначены для тех сфер применения, где оригинальный Си никогда не использовался.

=== C++ ===
Язык программирования [[C++]] был создан из Си и унаследовал его синтаксис, дополнив его новыми конструкциями в духе языков Simula-67, Smalltalk, Modula-2, Ada, Mesa и Clu<ref name="evolving">{{cite web|url = http://stroustrup.com/hopl-almost-final.pdf|title = Evolving a language in and for the real world: C++ 1991-2006|first = Bjarne|last = Stroustrup|access-date = 2018-07-09|archive-date = 2007-11-20|archive-url = https://web.archive.org/web/20071120015600/http://www.research.att.com/~bs/hopl-almost-final.pdf|url-status = live}}</ref>. Основными дополнениями стали поддержка [[Объектно-ориентированное программирование|ООП]] (описание классов, множественное наследование, полиморфизм, основанный на виртуальных функциях) и обобщённого программирования (механизм шаблонов). Но помимо этого в язык внесено множество самых различных дополнений. На данный момент C++ является одним из наиболее распространённых языков программирования в мире и позиционируется как язык общего назначения с уклоном в системное программирование<ref>{{Cite web|url=http://www.stroustrup.com/bs_faq.html|title=Stroustrup: FAQ|publisher=www.stroustrup.com|access-date=2019-06-03|archive-date=2016-02-06|archive-url=https://web.archive.org/web/20160206214150/http://www.stroustrup.com/bs_faq.html|url-status=live}}</ref>.

Изначально C++ сохранял совместимость с Си, которая была заявлена как одно из преимуществ нового языка. Первые реализации C++ просто переводили новые конструкции в чистый Си, после чего код обрабатывался обычным Си-компилятором. Для сохранения совместимости создатели C++ отказались от исключения из него некоторых часто критикуемых особенностей Си, вместо этого создав новые, «параллельные» механизмы, которые рекомендуется применять при разработке нового кода на C++ (шаблоны вместо макроопределений, явное приведение типов вместо автоматического, контейнеры стандартной библиотеки вместо ручного динамического выделения памяти и так далее). Однако в дальнейшем языки развивались независимо, и сейчас Си и C++ последних выпущенных стандартов являются лишь частично совместимыми: не гарантируется успешная компиляция программы на Си компилятором C++, а в случае успеха нет гарантии, что откомпилированная программа будет работать правильно. Особенно неприятны некоторые тонкие семантические различия, которые могут приводить к разному поведению одного и того же кода, синтаксически корректного для обоих языков. Например, символьные константы (символы, заключённые в одинарные кавычки) имеют тип <code>int</code> в Си и тип <code>char</code> в [[C++]], так что объём памяти, занимаемый такими константами, в разных языках различается<ref>{{cite web|url=http://www.open-std.org/jtc1/sc22/open/n2356/diff.html#diff.iso|title=Annex 0: Compatibility. 1.2. C++ and ISO C|work=Working Paper for Draft Proposed International Standard for Information Systems — Programming Language [[C++]]|date=1996-12-02|access-date=2009-06-06|description=см. 1.2.1p3 (параграф 3 в разделе 1.2.1)|archive-url=https://www.webcitation.org/618HTMqKA?url=http://www.open-std.org/jtc1/sc22/open/n2356/diff.html#diff.iso|archive-date=2011-08-22|url-status=live}}</ref>. Если программа чувствительна к размеру символьной константы, она будет работать по-разному, будучи откомпилирована трансляторами Си и C++.

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

=== Objective-C ===
Ещё одним вариантом расширения Си объектными средствами является язык [[Objective-C]], созданный в 1983 году. Объектная подсистема была заимствована из [[Smalltalk]], причём все элементы, связанные с этой подсистемой, реализованы в собственном синтаксисе, достаточно резко отличающемся от синтаксиса Си (вплоть до того, что в описании классов синтаксис объявления полей противоположен синтаксису описания переменных в Си: сначала пишется имя поля, затем его тип). В отличие от C++, Objective-C является надмножеством классического Си, то есть сохраняет совместимость с исходным языком; правильная программа на Си является правильной программой на Objective-C. Другим существенным отличием от идеологии C++ является то, что Objective-C реализует взаимодействие объектов путём обмена полноценными сообщениями, тогда как в C++ реализована концепция «отправка сообщения как вызов метода». Полноценная обработка сообщений является значительно более гибкой, к тому же она естественным образом сочетается с параллельными вычислениями. Objective-C, а также его прямой потомок [[Swift (язык программирования)|Swift]] являются одними из самых популярных на платформах, поддерживаемых [[Apple]].

== Проблемы и критика ==
Язык Си уникален с той точки зрения, что именно он стал первым [[Высокоуровневый язык программирования|языком высокого уровня]], всерьёз потеснившим [[Язык ассемблера|ассемблер]] в разработке [[Системное программное обеспечение|системного программного обеспечения]]. Он остаётся языком, реализованным на максимальном количестве [[Аппаратная платформа компьютера|аппаратных платформ]], и одним из самых популярных [[Язык программирования|языков программирования]], особенно в мире [[Свободное программное обеспечение|свободного программного обеспечения]]{{Sfn|Столяров|2010|loc = 1. Предисловие|p = 79}}. Тем не менее язык имеет множество недостатков, он с момента появления подвергается критике многих специалистов.

=== Общая критика ===
Язык весьма сложен и наполнен опасными элементами, которые очень легко использовать неправильно. Своей структурой и правилами он никак не поддерживает программирование, нацеленное на создание надёжного и удобного в сопровождении программного кода, напротив, рождённый в эпоху прямого программирования под различные процессоры, язык способствует написанию [[Ошибка (программирование)|небезопасного]] и [[Обфускация (программное обеспечение)|запутанного]] кода{{sfn|Столяров|2010|loc=1. Предисловие|p=79}}. Многие профессиональные программисты склонны считать, что язык Си ''—'' мощный инструмент для создания элегантных программ, но в то же время с его помощью можно создавать крайне некачественные решения<ref>{{Cite web|url=https://www.osp.ru/pcworld/2001/08/162103/|title=Летопись языков. Си|author=|website=|date=|publisher=Издательство «Открытые системы»|lang=ru|access-date=2018-12-08|archive-date=2018-12-09|archive-url=https://web.archive.org/web/20181209123846/https://www.osp.ru/pcworld/2001/08/162103/|url-status=live}}</ref><ref>{{Книга|автор=Allen I. Holub|заглавие=Enough Rope to Shoot Yourself in the Foot: Rules for C and C++ Programming|ссылка=https://books.google.ru/books?id=uiJRAAAAMAAJ&dq=Enough+Rope+to+Shoot+Yourself+in+the+Foot:+Rules+for+C+and+C+++Programming+(Unix/C)&hl=ru&source=gbs_navlinks_s|издательство=McGraw-Hill|год=1995|страниц=214|isbn=9780070296893|access-date=2021-08-07|archive-date=2018-12-09|archive-url=https://web.archive.org/web/20181209165151/https://books.google.ru/books?id=uiJRAAAAMAAJ&dq=Enough+Rope+to+Shoot+Yourself+in+the+Foot%3A+Rules+for+C+and+C+++Programming+%28Unix%2FC%29&hl=ru&source=gbs_navlinks_s|url-status=live}}</ref>.

Из-за различных допущений в языке программы могут компилироваться со множественными ошибками, что часто приводит к [[Непредсказуемое поведение|непредсказуемому поведению]] программы. Современные компиляторы предоставляют опции для статического анализа кода<ref>{{Cite web|url=https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html|title=Using the GNU Compiler Collection (GCC): Warning Options|publisher=gcc.gnu.org|access-date=2018-12-08|archive-date=2018-12-05|archive-url=https://web.archive.org/web/20181205035654/http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html|url-status=live}}</ref><ref>{{Cite web|url=https://clang.llvm.org/docs/DiagnosticsReference.html|title=Diagnostic flags in Clang — Clang 8 documentation|publisher=clang.llvm.org|access-date=2018-12-08|archive-date=2018-12-09|archive-url=https://web.archive.org/web/20181209124713/https://clang.llvm.org/docs/DiagnosticsReference.html|url-status=live}}</ref>, но даже они не способны выявить все возможные ошибки. Результатом неграмотного программирования на Си могут стать [[уязвимость (компьютерная безопасность)|уязвимости]] программного обеспечения, что может сказаться на [[информационная безопасность|безопасности]] его использования.

У Си высокий порог вхождения{{sfn|Столяров|2010|loc=1. Предисловие|p=79}}. Спецификация его занимает более 500 страниц текста, которые необходимо изучить полностью, так как для создания безошибочного и качественного кода приходится учитывать многие неочевидные особенности языка. Например, автоматическое приведение операндов целочисленных выражений к типу <code>int</code> может давать трудно предсказуемые результаты при использовании бинарных операторов<ref name=":7" />:

<syntaxhighlight lang="c" line="1">
    unsigned char x = 0xFF;
    unsigned char y = (~x | 0x1) >> 1; // Интуитивно здесь ожидается 0x00
    printf("y = 0x%hhX\n", y);         // Будет выведено 0x80, если sizeof(int) > sizeof(char)
</syntaxhighlight>

Недостаточное понимание подобных нюансов может приводить к появлению многочисленных ошибок и уязвимостей. Ещё одним фактором, увеличивающим сложность освоения Си, является отсутствие обратной связи от компилятора: язык даёт программисту полную свободу действий и позволяет компилировать программы с явными логическими ошибками. Всё это затрудняет использование Си [[Учебный язык программирования|в обучении]] в качестве первого языка программирования{{Sfn|Столяров|2010|loc = 1. Предисловие|p = 79}}

Наконец, за более чем 40 лет существования язык успел несколько устареть, и в нём достаточно проблематично использовать многие современные приёмы и [[Парадигма программирования|парадигмы программирования]].

=== Недостатки отдельных элементов языка ===

==== Примитивная поддержка модульности ====
В синтаксисе Си нет модулей и механизмов их взаимодействия. Файлы исходного кода компилируются раздельно и должны включать прототипы импортируемых из других файлов переменных, функций и типов данных. Для этого используется включение заголовочных файлов через макроподстановку <code><nowiki>#include</nowiki></code>{{Переход|Модули}}. В случае нарушения соответствия между файлами кода и заголовочными файлами могут возникать как ошибки этапа компоновки, так и всевозможные ошибки времени исполнения: от порчи [[стек]]а и [[Куча (память)|кучи]] до [[Ошибка сегментации|ошибок сегментирования]]. Поскольку директива <code>#include</code> лишь подставляет текст одного файла в другой, включение большого количества заголовочных файлов приводит к тому, что многократно возрастает фактический объём кода, попадающего на компиляцию, что является причиной относительно низкой скорости работы компиляторов языка Си. Необходимость согласования описаний в основном модуле и заголовочных файлах затрудняет сопровождение программы.

==== Предупреждения вместо ошибок ====
Стандарт языка даёт программисту большую свободу действий и тем самым — высокие шансы на допущение ошибок. Многое из того, что чаще всего нельзя делать, дозволено языком, и компилятор в лучшем случае выдаёт предупреждения. Хотя современные компиляторы позволяют переводить все предупреждения в класс ошибок, эта возможность используется редко, гораздо чаще предупреждения игнорируются, если программа работает удовлетворительно.

Так, например, до стандарта C99 вызов функции <code>[[malloc]]</code> без подключения заголовочного файла [[Stdlib.h|<code>stdlib.h</code>]] мог привести к порче стека, поскольку в отсутствие прототипа функция вызывалась как возвращающая тип <code>int</code>, тогда как фактически она возвращала тип <code>void*</code> (ошибка возникала, когда размеры типов на целевой платформе различались). Но даже при этом выдавалось всего лишь предупреждение.

==== Отсутствие контроля инициализации переменных ====
Автоматически и динамически создаваемые объекты по умолчанию не инициализируются и после создания содержат значения, оставшиеся в памяти от ранее находившихся там объектов. Такое значение полностью непредсказуемо, оно меняется от одной машины к другой, от запуска к запуску, от вызова функции к вызову. Если программа из-за случайного пропуска инициализации использует такое значение, то результат будет непредсказуемым и может проявиться не сразу. Современные компиляторы пытаются диагностировать эту проблему статическим анализом исходного кода, хотя в общем случае статическим анализом данную проблему решить крайне сложно. Для выявления данных проблем на этапе тестирования в ходе исполнения программы могут использоваться дополнительные инструменты: [[Valgrind]] и [[MemorySanitizer]]<ref>{{Cite web|url=https://clang.llvm.org/docs/MemorySanitizer.html|title=MemorySanitizer — Clang 8 documentation|author=|website=|date=|publisher=clang.llvm.org|lang=en|access-date=2018-12-08|archive-date=2018-12-01|archive-url=https://web.archive.org/web/20181201020916/http://clang.llvm.org/docs/MemorySanitizer.html|url-status=live}}</ref>.

==== Отсутствие контроля над адресной арифметикой ====
Источником опасных ситуаций служит совместимость указателей с числовыми типами и возможность использования адресной арифметики без строгого контроля на этапах компиляции и исполнения. Это даёт возможность получить указатель на любой объект, включая исполняемый код, и обратиться по этому указателю, если только [[Защита памяти|механизм защиты памяти системы]] этому не воспрепятствует.

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

Доступ к массивам в Си также реализован посредством адресной арифметики и не предполагает средств проверки корректности обращения к элементам массива по индексу. Например, выражения <code>a[i]</code> и <code>i[a]</code> идентичны и просто транслируются к виду <code>*(a + i)</code>, а проверка на выход за границы массива не проводится. Обращение по индексу, превышающему верхнюю границу массива, приводит к обращению к данным, размещённым в памяти после массива, что называют [[переполнение буфера|переполнением буфера]]. Когда подобное обращение происходит ошибочно, оно может привести к непредсказуемому поведению программы<ref name=":16" />. Нередко данная особенность используется в [[Эксплойт|эксплоитах]], используемых для нелегального доступа к памяти другого приложения или памяти ядра операционной системы.

==== Побуждающая к ошибкам динамическая память ====
Системные функции для работы с динамически выделяемой памятью не обеспечивают контроля за правильностью и своевременностью её выделения и освобождения, соблюдение правильного порядка работы с динамической памятью полностью возлагается на программиста. Его ошибки, соответственно, могут приводить к обращению по некорректным адресам, к преждевременному освобождению либо к [[утечка памяти|утечке]] памяти (последнее возможно, например, если разработчик забыл вызвать <code>free()</code> или вызывающую <code>free()</code> функцию, когда это требовалось)<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/MEM00-C.+Allocate+and+free+memory+in+the+same+module,+at+the+same+level+of+abstraction|title=MEM00-C. Allocate and free memory in the same module, at the same level of abstraction - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-06-04|archive-date=2019-06-04|archive-url=https://web.archive.org/web/20190604045730/https://wiki.sei.cmu.edu/confluence/display/c/MEM00-C.%2BAllocate%2Band%2Bfree%2Bmemory%2Bin%2Bthe%2Bsame%2Bmodule,%2Bat%2Bthe%2Bsame%2Blevel%2Bof%2Babstraction|url-status=live}}</ref>.

Одной из частых ошибок является отсутствие проверок результата работы функций выделения памяти (<code>malloc()</code>, <code>calloc()</code> и прочие) на <code>NULL</code>, в то время как память может не выделиться, если её не хватает, или если был запрошен слишком большой объём, например, из-за приведения числа <code>-1</code> , полученного в результате каких-либо ошибочных математических операций, к беззнаковому типу <code>size_t</code>, с последующими операциями над ним{{Переход|Приведение целочисленных типов|back}}. Ещё одной проблемой системных функций работы с памятью является неспецифицированное поведение при запросе выделения блока нулевого размера: функции могут вернуть как <code>NULL</code>, так и действительное значение указателя, в зависимости от конкретной реализации<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/MEM04-C.+Beware+of+zero-length+allocations|title=MEM04-C. Beware of zero-length allocations - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-01-11|archive-date=2019-01-12|archive-url=https://web.archive.org/web/20190112044320/https://wiki.sei.cmu.edu/confluence/display/c/MEM04-C.+Beware+of+zero-length+allocations|url-status=live}}</ref>.

Некоторые конкретные реализации и сторонние библиотеки предоставляют такие средства, как подсчёт ссылок и [[Слабая ссылка|слабые ссылки]]<ref>{{Cite web|url=https://developer.gnome.org/gobject/stable/gobject-memory.html|title=Object memory management: GObject Reference Manual|publisher=developer.gnome.org|access-date=2018-12-09|archive-date=2018-09-07|archive-url=https://web.archive.org/web/20180907184846/https://developer.gnome.org/gobject/stable/gobject-memory.html|url-status=live}}</ref>, [[Умный указатель|умные указатели]]<ref name="smart_ptr">Например, [https://github.com/Snaipe/libcsptr snai.pe c-smart-pointers] {{Wayback|url=https://github.com/Snaipe/libcsptr |date=20180814031755 }}</ref>, а также ограниченные формы [[Сборка мусора|сборки мусора]]<ref name="grb_cll">{{Cite web |url=https://www.linuxjournal.com/article/6679 |title=Garbage Collection in C Programs |access-date=2019-05-16 |archive-date=2019-03-27 |archive-url=https://web.archive.org/web/20190327231517/https://www.linuxjournal.com/article/6679 |url-status=live }}</ref>, но все эти средства не являются стандартными, что, естественно, ограничивает их применение.

==== Неэффективные и небезопасные строки ====
Для языка стандартными являются [[Нуль-терминированная строка|нуль-терминированные строки]]{{переход|Нуль-терминированные строки}}, соответственно все стандартные функции работают именно с ними. Это решение приводит к значительной потере эффективности за счёт малозначительной экономии памяти (по сравнению с явным хранением размера): вычисление длины строки (функция <code>strlen()</code>) требует обхода в цикле всей строки от начала до конца, копирование строк также сложно оптимизировать из-за наличия терминирующего нуля<ref name=":15">{{Cite web|url=https://queue.acm.org/detail.cfm?id=2010365|title=The Most Expensive One-byte Mistake - ACM Queue|author=Poul-Henning Kamp|website=|date=2011-07-25|publisher=queue.acm.org|lang=en|access-date=2019-05-28|archive-date=2019-04-30|archive-url=https://web.archive.org/web/20190430114822/https://queue.acm.org/detail.cfm?id=2010365|url-status=live}}</ref>. Из-за необходимости добавлять к данным строки терминирующий нуль становится невозможным эффективное получение подстрок в виде срезов и работа с ними как с обычными строками; выделение частей строк и манипуляции с ними обычно требуют ручного выделения и освобождения памяти, что дополнительно повышает вероятность ошибки.

Нуль-терминированные строки являются частым источником ошибок<ref name=":5">{{Cite web|url=https://security.web.cern.ch/security/recommendations/en/codetools/c.shtml|title=CERN Computer Security Information|publisher=security.web.cern.ch|access-date=2019-01-12|archive-date=2019-01-05|archive-url=https://web.archive.org/web/20190105062632/https://security.web.cern.ch/security/recommendations/en/codetools/c.shtml|url-status=live}}</ref>. Даже стандартные функции обычно не выполняют проверки на размер целевого буфера<ref name=":5"/> и могут не добавлять в конце строки нулевой символ<ref>{{Cite web | url=https://cwe.mitre.org/data/definitions/170.html | title=CWE - CWE-170: Improper Null Termination (3.2) | publisher=cwe.mitre.org | lang=en | access-date=2019-01-12 | archive-date=2019-01-13 | archive-url=https://web.archive.org/web/20190113062710/https://cwe.mitre.org/data/definitions/170.html | url-status=live }}</ref>, помимо того, что он может быть не добавлен или затёрт из-за ошибки программиста<ref>{{Cite web| url=https://wiki.sei.cmu.edu/confluence/display/c/STR32-C.+Do+not+pass+a+non-null-terminated+character+sequence+to+a+library+function+that+expects+a+string| title=STR32-C. Do not pass a non-null-terminated character sequence to a library function that expects a string - SEI CERT C Coding Standard - Confluence| publisher=wiki.sei.cmu.edu| lang=en| access-date=2019-01-12| archive-date=2019-01-13| archive-url=https://web.archive.org/web/20190113062800/https://wiki.sei.cmu.edu/confluence/display/c/STR32-C.+Do+not+pass+a+non-null-terminated+character+sequence+to+a+library+function+that+expects+a+string| url-status=live}}</ref>.

==== Небезопасная реализация функций с переменным числом аргументов ====
Поддерживая [[Вариативная функция|функции с переменным числом аргументов]], Си не содержит ни средств определения числа и типов фактических параметров, переданных такой функции, ни механизма безопасного доступа к ним<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/cplusplus/DCL50-CPP.+Do+not+define+a+C-style+variadic+function|title=DCL50-CPP. Do not define a C-style variadic function - SEI CERT C++ Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-05-25|archive-date=2019-05-25|archive-url=https://web.archive.org/web/20190525111734/https://wiki.sei.cmu.edu/confluence/display/cplusplus/DCL50-CPP.%2BDo%2Bnot%2Bdefine%2Ba%2BC-style%2Bvariadic%2Bfunction|url-status=live}}</ref>. Информирование функции о составе фактических параметров лежит на программисте, а для доступа к их значениям необходимо отсчитать правильное количество байтов от адреса последнего фиксированного параметра в стеке либо вручную, либо пользуясь набором макросов <code>va_arg</code> из заголовочного файла <code>[[stdarg.h]]</code>. При этом необходимо учитывать работу механизма автоматического неявного повышения типов при вызове функций<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/EXP47-C.+Do+not+call+va_arg+with+an+argument+of+the+incorrect+type|title=EXP47-C. Do not call va_arg with an argument of the incorrect type - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2018-12-08|archive-date=2018-12-09|archive-url=https://web.archive.org/web/20181209165220/https://wiki.sei.cmu.edu/confluence/display/c/EXP47-C.%20Do%20not%20call%20va_arg%20with%20an%20argument%20of%20the%20incorrect%20type|url-status=live}}</ref>, согласно которому целочисленные типы аргументов размером менее <code>int</code> приводятся к <code>int</code> (или <code>unsigned int</code>), а <code>float</code> приводится к <code>double</code>. Ошибка в вызове или в работе с параметрами внутри функции проявится только во время исполнения программы, приводя к непредсказуемым последствиям, от чтения неверных данных до порчи стека.

При этом стандартным средством форматированного ввода-вывода являются именно функции с переменным числом параметров (<code>[[printf]]()</code>, <code>scanf()</code> и другие), не способные проверить соответствие списка аргументов строке формата. Многие современные компиляторы проводят такую проверку для каждого их вызова, генерируя предупреждения при обнаружении несоответствия, однако в общем случае подобная проверка невозможна, так как каждая функция с переменным числом аргументов обрабатывает этот список по-своему. Невозможно статически проконтролировать даже все вызовы функции <code>printf()</code>, поскольку строка формата может создаваться в программе динамически.

==== Отсутствие унификации обработки ошибок ====
Синтаксис Си не включает специального механизма обработки ошибок. Стандартная библиотека поддерживает лишь простейшие средства: переменная (в случае [[POSIX]] — макрос) <code>errno</code> из заголовочного файла <code>[[errno.h]]</code> для установки кода последней ошибки и функции для получения сообщений об ошибках согласно кодам{{переход|Обработка ошибок}}. Такой подход приводит к необходимости писать большой объём повторяющегося кода, смешивая основной алгоритм с обработкой ошибок, к тому же он не является потокобезопасным. Причём даже в этом механизме нет единого порядка:
* большинство функций стандартной библиотеки при ошибке возвращает маркер <code>-1</code>{{Переход|Маркеры ошибок и errno}}, а сам код требуется получать из <code>errno</code>, если функция его выставляет;
* в стандарте POSIX принято возвращать код ошибки напрямую, но не все функции этого стандарта так делают;
* во многих функциях, например, <code>fopen()</code>, <code>fread()</code> и <code>fwrite()</code>, выставление <code>errno</code> не стандартизировано и может отличаться в разных реализациях<ref name=":13" /> (в POSIX требования более строгие и указаны некоторые из вариантов возможных ошибок{{переход|Обработка ошибок на примере чтения файла}});
* есть функции, у которых маркер ошибки является одним из допустимых возвращаемых значений, и перед их вызовом приходится обнулять <code>errno</code>, чтобы быть уверенным, что код ошибки был установлен именно этой функцией<ref name=":13" />.

В стандартной библиотеке коды <code>errno</code> обозначаются через макроопределения и могут иметь одинаковые значения, что не даёт возможности анализировать коды ошибок через оператор <code>switch</code>. В языке нет специального типа данных для флагов и кодов ошибок, они передаются как значения типа <code>int</code>. Отдельный тип <code>errno_t</code> для хранения кода ошибки появился лишь в расширении K стандарта C11 и может не поддерживаться компиляторами<ref name=":3">{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/DCL09-C.+Declare+functions+that+return+errno+with+a+return+type+of+errno_t|title=DCL09-C. Declare functions that return errno with a return type of errno_t - SEI CERT C Coding Standard - Confluence|publisher=wiki.sei.cmu.edu|access-date=2018-12-21|archive-date=2018-12-21|archive-url=https://web.archive.org/web/20181221230534/https://wiki.sei.cmu.edu/confluence/display/c/DCL09-C.+Declare+functions+that+return+errno+with+a+return+type+of+errno_t|url-status=live}}</ref>.

=== Способы преодоления недостатков языка ===
Недостатки Си давно и хорошо известны, и с момента появления языка предпринималось множество попыток повысить качество и безопасность кода на Си, не принося в жертву его возможности.

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

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

==== Стандарты безопасного программирования ====
Выпущено значительное количество исследований о правильном программировании на Си, от небольших статей до объёмных книг. Для поддержания качества кода на Си принимаются корпоративные и отраслевые стандарты. В частности:
* [[MISRA C]] — стандарт, разработанный Motor Industry Software Reliability Association для использования Си в разработке встроенных систем транспортных средств. Сейчас MISRA C используется во многих отраслях, в том числе в военной, медицинской и аэрокосмической. Редакция 2013 года содержит 16 директив и 143 правила, включающие требования к коду и ограничения на использование определённых языковых средств (например, запрещено использование функций с переменным числом параметров). На рынке имеется около десятка инструментов проверки кода на соответствие MISRA C и несколько компиляторов со встроенной проверкой ограничений этого стандарта.
* [[CERT C Coding Standard]] — стандарт, разрабатываемый [[Координационный центр CERT|координационным центром CERT]]<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/SEI+CERT+C+Coding+Standard|title=SEI CERT C Coding Standard - SEI CERT C Coding Standard - Confluence|publisher=wiki.sei.cmu.edu|access-date=2018-12-09|archive-date=2018-12-08|archive-url=https://web.archive.org/web/20181208151631/https://wiki.sei.cmu.edu/confluence/display/c/SEI+CERT+C+Coding+Standard|url-status=live}}</ref>. Он также имеет целью обеспечение надёжного и безопасного программирования на Си. Включает правила и рекомендации для разработчиков, в том числе примеры неправильного и правильного кода по каждому отдельно взятому случаю. Стандарт используется в разработке продуктов такими компаниями как [[Cisco]] и [[Oracle]]<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/Introduction|title=Introduction - SEI CERT C Coding Standard - Confluence|publisher=wiki.sei.cmu.edu|access-date=2019-05-24|archive-date=2019-05-24|archive-url=https://web.archive.org/web/20190524063951/https://wiki.sei.cmu.edu/confluence/display/c/Introduction|url-status=live}}</ref>.

==== Стандарты POSIX ====
Компенсации некоторых недостатков языка способствует набор стандартов [[POSIX]]. Стандартизируется установка <code>errno</code> многими функциями, позволяя обрабатывать ошибки, возникающие, например, в функциях работы с файлами, а также вводятся [[Thread-safety|потокобезопасные]] аналоги некоторых функций стандартной библиотеки, безопасные варианты которых в стандарте языка присутствуют лишь в расширении K<ref>{{Cite web|url=https://wiki.sei.cmu.edu/confluence/display/c/CON33-C.+Avoid+race+conditions+when+using+library+functions|title=CON33-C. Avoid race conditions when using library functions - SEI CERT C Coding Standard - Confluence|author=|website=|date=|publisher=wiki.sei.cmu.edu|lang=en|access-date=2019-01-23|archive-date=2019-01-23|archive-url=https://web.archive.org/web/20190123223449/https://wiki.sei.cmu.edu/confluence/display/c/CON33-C.+Avoid+race+conditions+when+using+library+functions|url-status=live}}</ref>.

== См. также ==
* [[C++]]
* [[C--]]
* [[Objective-C]]
* [[Cyclone (язык программирования)]]
* [[Стандартная библиотека языка Си]]
* [[Go]]

== Примечания ==

=== Комментарии ===
{{комментарии}}

=== Источники ===
{{примечания|2}}

== Литература ==
* {{Cite web
|url=http://www.open-std.org/jtc1/sc22/wg14/www/abq/c17_updated_proposed_fdis.pdf
|title=ISO/IEC9899:2017
|author=ISO/IEC
|subtitle=Programming languages — C
|date=2017
|publisher=www.open-std.org
|url-status=dead
|archive-url=https://web.archive.org/web/20181024175400/http://www.open-std.org/jtc1/sc22/wg14/www/abq/c17_updated_proposed_fdis.pdf
|ref=Черновик стандарта C17
|archive-date=2018-10-24
|access-date=2018-12-03
}}
* {{книга
|автор = [[Керниган, Брайан|Керниган Б.]], [[Ритчи, Деннис|Ритчи Д.]]
|заглавие = Язык программирования Си
|оригинал = The C programming language
|издание = 2-е изд
|место = М. 
|издательство = [[Вильямс (издательство)|Вильямс]]
|год = 2007
|страницы = 304
|isbn = 0-13-110362-8
|ref=Керниган, Ритчи}}
<!-- Прочие публикации в алфавитном порядке: -->
* {{книга
|автор = {{comment|Гукин Д.|Гукин, Дэн}}
|заглавие = Язык программирования Си для «чайников»
|оригинал = C For Dummies
|место = М. 
|издательство = [[Диалектика (издательство)|Диалектика]]
|год = 2006
|страницы = 352
|isbn = 0-7645-7068-4
|ref=Гукин}}
* {{книга
 | автор         = Подбельский В. В., Фомин С. С.
 | заглавие      = Курс программирования на языке Си: учебник
 | ссылка = https://books.google.ru/books?id=EKVXAwAAQBAJ
 | место         = М.
 | издательство  = ДМК Пресс
 | год           = 2012
 | страниц       = 318
 | isbn          = 978-5-94074-449-8
 | ref           = Подбельский, Фомин
}}
* {{книга
|автор = {{comment|Прата С.|Прата, Стивен}}
|заглавие = Язык программирования С: Лекции и упражнения
|оригинал = C Primer Plus
|место = М. 
|издательство = Вильямс
|год = 2006
|страницы = 960
|isbn = 5-8459-0986-4
|ref=Прата}}
* {{книга
|заглавие = Язык программирования C (C11). Лекции и упражнения, 6-е издание 
|оригинал = C Primer Plus, 6th Edition 
|автор = Прата С. 
|страниц = 928 
|isbn = 978-5-8459-1950-2 
|год = 2015 
|место =  М.
|издательство = Вильямс 
|ref=Прата}}
* {{Статья|автор=Столяров А. В. |заглавие=Язык Си и начальное обучение программированию |ссылка=http://www.croco.net/croco/papers/stolyarov_2010.pdf |издание=Сборник статей молодых учёных факультета ВМК МГУ |год=2010 |номер=7| страницы=78—90 |издательство=Издательский отдел факультета ВМК МГУ|ref=Столяров}}
* {{книга
|заглавие = C: полное руководство, классическое издание 
|оригинал = C: The Complete Reference, 4th Edition 
|автор = {{comment|Шилдт Г.|Шилдт, Герберт}} 
|страницы = 704 
|isbn = 978-5-8459-1709-6 
|год = 2010
|место = М.
|издательство = [[Вильямс (издательство)|Вильямс]] 
}}
* {{Книга |заглавие=Языки программирования Ада, Си, Паскаль |ответственный=А. Фьюэр, Н. Джехани |место=М. |издательство=Радио и Саязь |год=1989 |страниц=368 |isbn=5-256-00309-7 |оригинал=Comparing and Assessong Programming Languages Ada, C, and Pascal|тираж = 50000 |ref=Фьюэр, Джехани}}
* {{Источник информации
 |авторы = N. S. Papaspyrou
 |заглавие = A Formal Semantics for the C Programming Language|тип=doctoral dissertation
 |дата = 1998-02
 |ссылка = http://www.softlab.ntua.gr/~nickie/Papers/papaspyrou-1998-fscpl.pdf
 |издатель = National Technical University of Athens
 |язык = en
 |ref = Papaspyrou
 |архивная ссылка = https://web.archive.org/web/20181024071841/http://www.softlab.ntua.gr/~nickie/Papers/papaspyrou-1998-fscpl.pdf
 |дата архивирования = 2023-01-22
}}

== Ссылки ==
{{Навигация|Тема=Си|Викиучебник=Язык Си в примерах}}
* {{cite web|url=http://www.open-std.org/JTC1/SC22/WG14/|title=ISO/IEC JTC1/SC22/WG14 official home|access-date=2009-02-20|description=Официальная страница международной рабочей группы по стандартизации языка программирования Си|lang=en|archive-url=https://www.webcitation.org/618HTpjNt?url=http://www.open-std.org/JTC1/SC22/WG14/|archive-date=2011-08-22|url-status=live}}
** {{cite web|url=http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1124.pdf|title=WG14 N1124|work=ISO/IEC 9899 — Programming languages — C — Approved standards|publisher=ISO/IEC JTC1/SC22/WG14|date=2005-05-06|access-date=2009-02-20|description=Стандарт ISO/IEC 9899:1999 (C99) + ISO/IEC 9899:1999 Cor. 1:2001(E) (TC1 — Technical Corrigendum 1 от 2001 года) + ISO/IEC 9899:1999 Cor. 2:2004(E) (TC2 — Technical Corrigendum 2 от 2004 года)|lang=en|archive-url=https://www.webcitation.org/618HUIDTw?url=http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1124.pdf|archive-date=2011-08-22|url-status=live}}
<!-- Technical Corrigendum 3 (ISO/IEC 9899:1999 Cor. 3:2007(E)) was published in 2007. It can be obtained free of charge fro ISO. -->
** {{cite web|url=http://www.open-std.org/JTC1/SC22/WG14/www/docs/C99RationaleV5.10.pdf|title=C — The ISO Standard — Rationale, Revision 5.10|date=2004-04|access-date=2009-02-20|description=Обоснование и пояснения для стандарта C99|lang=en|archive-url=https://www.webcitation.org/618HUxvqA?url=http://www.open-std.org/JTC1/SC22/WG14/www/docs/C99RationaleV5.10.pdf|archive-date=2011-08-22|url-status=live}}
* [https://en.cppreference.com/w/ Cppreference.com] — поддерживаемый энтузиастами [[вики]]-справочник с большой подборкой данных по языкам [https://en.cppreference.com/w/c Си] и [https://en.cppreference.com/w/cpp C++], их стандартам, а также материалам, связанным с этими языками и их разработкой.
* [https://wiki.sei.cmu.edu/confluence/display/c SEI CERT C Coding Standard] (или [https://resources.sei.cmu.edu/downloads/secure-coding/assets/sei-cert-c-coding-standard-2016-v01.pdf SEI CERT C Coding Standard, 2016 Edition]) — стандарт [[Безопасное программирование|безопасного программирования]] на языке Си.
* {{cite web |url=http://ermak.cs.nstu.ru/cprog/HTML/index.htm |title=Си/Си++. От дилетанта до профессионала|author=Романов Е.|work= |publisher=ermak.cs.nstu.ru |access-date=2015-05-25 |ref=Романов, Си/Си++ }}

{{внешние ссылки}}

{{Язык программирования Си}}

[[Категория:Си (язык программирования)| ]]