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

Не путать с C++ или C# .

С

Логотип, использованный на обложке первого издания The C Programming Language.
Парадигма	Мультипарадигмальность : императивная ( процедурная ), структурированная.
Разработано	Деннис Ричи
Разработчик	ANSI X3J11 ( ANSI C ); ISO/IEC JTC 1 (Объединенный технический комитет 1) / SC 22 (Подкомитет 22) / WG 14 (Рабочая группа 14) (ISO C)
Впервые появился	1972 год ( 1972 )
Stable release	C17 / June 2018 (2018-06)
Preview release	C23 (N3220) / February 21, 2024 (2024-02-21)
Typing discipline	Static, weak, manifest, nominal
OS	Cross-platform
Filename extensions	.c, .h
Website	www.iso.org/standard/74528.html www.open-std.org/jtc1/sc22/wg14/
Major implementations
pcc, GCC, Clang, Intel C, C++Builder, Microsoft Visual C++, Watcom C
Dialects
Cyclone, Unified Parallel C, Split-C, Cilk, C*
Influenced by
B (BCPL, CPL), ALGOL 68, PL/I, FORTRAN
Influenced
Numerous: AMPL, AWK, csh, C++, C--, C#, Objective-C, D, Go, Java, JavaScript, JS++, Julia, Limbo, LPC, Perl, PHP, Pike, Processing, Python, Rust, Seed7, V (Vlang), Vala, Verilog (HDL), Nim, Zig
C Programming at Wikibooks

C ( произносится / ˈ s iː / – как буква c ) — язык программирования общего назначения . Он был создан в 1970-х годах Деннисом Ритчи и остается очень широко используемым и влиятельным. По замыслу функции C четко отражают возможности целевых процессоров. Он нашел прочное применение в операционных систем коде (особенно в ядрах) . ), драйверы устройств и стеки протоколов , но его использование в прикладном программном обеспечении сокращается. C обычно используется в компьютерных архитектурах, от крупнейших суперкомпьютеров до самых маленьких микроконтроллеров и встроенных систем .

Преемник языка программирования B , C был первоначально разработан в Bell Labs Ритчи между 1972 и 1973 годами для создания утилит, работающих на Unix . Он был применен для повторной реализации ядра операционной системы Unix. В 1980-е годы C постепенно набирал популярность. Он стал одним из наиболее широко используемых языков программирования. с компиляторами C, доступными практически для всех современных компьютерных архитектур и операционных систем. Книга «Язык программирования C» , соавтором которой является первоначальный разработчик языка, в течение многих лет служила фактическим стандартом для языка. C стандартизируется с 1989 года Американским национальным институтом стандартов (ANSI), а затем совместно Международной организацией по стандартизации (ISO) и Международной электротехнической комиссией (IEC).

C is an imperative procedural language, supporting structured programming, lexical variable scope, and recursion, with a static type system. It was designed to be compiled to provide low-level access to memory and language constructs that map efficiently to machine instructions, all with minimal runtime support. Despite its low-level capabilities, the language was designed to encourage cross-platform programming. A standards-compliant C program written with portability in mind can be compiled for a wide variety of computer platforms and operating systems with few changes to its source code.

Since 2000, C has consistently ranked among the top two languages in the TIOBE index, a measure of the popularity of programming languages.

Overview

Dennis Ritchie (right), the inventor of the C programming language, with Ken Thompson

C is an imperative, procedural language in the ALGOL tradition. It has a static type system. In C, all executable code is contained within subroutines (also called "functions", though not in the sense of functional programming). Function parameters are passed by value, although arrays are passed as pointers, i.e. the address of the first item in the array. Pass-by-reference is simulated in C by explicitly passing pointers to the thing being referenced.

C program source text is free-form code. Semicolons terminate statements, while curly braces are used to group statements into blocks.

The C language also exhibits the following characteristics:

• The language has a small, fixed number of keywords, including a full set of control flow primitives: if/else, for, do/while, while, and switch. User-defined names are not distinguished from keywords by any kind of sigil.
• It has a large number of arithmetic, bitwise, and logic operators: +,+=,++,&,||, etc.
• More than one assignment may be performed in a single statement.
• Functions:
  • Function return values can be ignored, when not needed.
  • Function and data pointers permit ad hoc run-time polymorphism.
  • Functions may not be defined within the lexical scope of other functions.
  • Variables may be defined within a function, with scope.
  • A function may call itself, so recursion is supported.
• Data typing is static, but weakly enforced; all data has a type, but implicit conversions are possible.
• User-defined (typedef) and compound types are possible.
  • Heterogeneous aggregate data types (struct) allow related data elements to be accessed and assigned as a unit. The contents of whole structs cannot be compared using a single built-in operator (the elements must be compared individually).
  • Union is a structure with overlapping members; it allows multiple data types to share the same memory location.
  • Array indexing is a secondary notation, defined in terms of pointer arithmetic. Whole arrays cannot be assigned or compared using a single built-in operator. There is no "array" keyword in use or definition; instead, square brackets indicate arrays syntactically, for example month[11].
  • Enumerated types are possible with the enum keyword. They are freely interconvertible with integers.
  • Strings are not a distinct data type, but are conventionally implemented as null-terminated character arrays.
• Low-level access to computer memory is possible by converting machine addresses to pointers.
• Procedures (subroutines not returning values) are a special case of function, with an empty return type void.
• Memory can be allocated to a program with calls to library routines.
• A preprocessor performs macro definition, source code file inclusion, and conditional compilation.
• There is a basic form of modularity: files can be compiled separately and linked together, with control over which functions and data objects are visible to other files via static and extern attributes.
• Complex functionality such as I/O, string manipulation, and mathematical functions are consistently delegated to library routines.
• The generated code after compilation has relatively straightforward needs on the underlying platform, which makes it suitable for creating operating systems and for use in embedded systems.

While C does not include certain features found in other languages (such as object orientation and garbage collection), these can be implemented or emulated, often through the use of external libraries (e.g., the GLib Object System or the Boehm garbage collector).

Relations to other languages

Main article: List of C-family programming languages

Many later languages have borrowed directly or indirectly from C, including C++, C#, Unix's C shell, D, Go, Java, JavaScript (including transpilers), Julia, Limbo, LPC, Objective-C, Perl, PHP, Python, Ruby, Rust, Swift, Verilog and SystemVerilog (hardware description languages). These languages have drawn many of their control structures and other basic features from C. Most of them also express highly similar syntax to C, and they tend to combine the recognizable expression and statement syntax of C with underlying type systems, data models, and semantics that can be radically different.

History

Early developments

Timeline of C language

Year	Informal name	Official standard
1972	first release	—
1978	K&R C	—
1989, 1990	ANSI C, C89, ISO C, C90	ANSI X3.159-1989 ISO/IEC 9899:1990
1999	C99, C9X	ISO/IEC 9899:1999
2011	C11, C1X	ISO/IEC 9899:2011
2018	C17	ISO/IEC 9899:2018
2024	C23, C2X	ISO/IEC 9899:2024
Future	C2Y	—

The origin of C is closely tied to the development of the Unix operating system, originally implemented in assembly language on a PDP-7 by Dennis Ritchie and Ken Thompson, incorporating several ideas from colleagues. Eventually, they decided to port the operating system to a PDP-11. The original PDP-11 version of Unix was also developed in assembly language.

B

Main article: B (programming language)

Thompson wanted a programming language for developing utilities for the new platform. At first he tried to write a Fortran compiler, but he soon gave up the idea. Instead, he created a cut-down version of the recently developed systems programming language called BCPL. The official description of BCPL was not available at the time, and Thompson modified the syntax to be less wordy and similar to a simplified ALGOL known as SMALGOL. Thompson called the result B. He described B as "BCPL semantics with a lot of SMALGOL syntax". Like BCPL, B had a bootstrapping compiler to facilitate porting to new machines. However, few utilities were ultimately written in B because it was too slow and could not take advantage of PDP-11 features such as byte addressability.

New B and first C release

In 1971, Ritchie started to improve B, to utilise the features of the more-powerful PDP-11. A significant addition was a character data type. He called this New B (NB). Thompson started to use NB to write the Unix kernel, and his requirements shaped the direction of the language development. Through to 1972, richer types were added to the NB language: NB had arrays of int and char. Pointers, the ability to generate pointers to other types, arrays of all types, and types to be returned from functions were all also added. Arrays within expressions became pointers. A new compiler was written, and the language was renamed C.

The C compiler and some utilities made with it were included in Version 2 Unix, which is also known as Research Unix.

Structures and Unix kernel re-write

At Version 4 Unix, released in November 1973, the Unix kernel was extensively re-implemented in C. By this time, the C language had acquired some powerful features such as struct types.

The preprocessor was introduced around 1973 at the urging of Alan Snyder and also in recognition of the usefulness of the file-inclusion mechanisms available in BCPL and PL/I. Its original version provided only included files and simple string replacements: #include and #define of parameterless macros. Soon after that, it was extended, mostly by Mike Lesk and then by John Reiser, to incorporate macros with arguments and conditional compilation.

Unix was one of the first operating system kernels implemented in a language other than assembly. Earlier instances include the Multics system (which was written in PL/I) and Master Control Program (MCP) for the Burroughs B5000 (which was written in ALGOL) in 1961. In around 1977, Ritchie and Stephen C. Johnson made further changes to the language to facilitate portability of the Unix operating system. Johnson's Portable C Compiler served as the basis for several implementations of C on new platforms.

K&R C

The cover of the book The C Programming Language, first edition, by Brian Kernighan and Dennis Ritchie

In 1978, Brian Kernighan and Dennis Ritchie published the first edition of The C Programming Language. Known as K&R from the initials of its authors, the book served for many years as an informal specification of the language. The version of C that it describes is commonly referred to as "K&R C". As this was released in 1978, it is now also referred to as C78. The second edition of the book covers the later ANSI C standard, described below.

K&R introduced several language features:

• Standard I/O library
• long int data type
• unsigned int data type
• Compound assignment operators of the form =op (such as =-) were changed to the form op= (that is, -=) to remove the semantic ambiguity created by constructs such as i=-10, which had been interpreted as i =- 10 (decrement i by 10) instead of the possibly intended i = -10 (let i be −10).

Even after the publication of the 1989 ANSI standard, for many years K&R C was still considered the "lowest common denominator" to which C programmers restricted themselves when maximum portability was desired, since many older compilers were still in use, and because carefully written K&R C code can be legal Standard C as well.

In early versions of C, only functions that return types other than int must be declared if used before the function definition; functions used without prior declaration were presumed to return type int.

For example:

long some_function(); /* This is a function declaration, so the compiler can know the name and return type of this function. */
/* int */ other_function(); /* Another function declaration.  Because this is an early version of C, there is an implicit 'int' type here.  A comment shows where the explicit 'int' type specifier would be required in later versions. */

/* int */ calling_function() /* This is a function definition, including the body of the code following in the { curly brackets }. Because no return type is specified, the function implicitly returns an 'int' in this early version of C. */
{
    long test1;
    register /* int */ test2; /* Again, note that 'int' is not required here. The 'int' type specifier */
                              /* in the comment would be required in later versions of C. */
                              /* The 'register' keyword indicates to the compiler that this variable should */
                              /* ideally be stored in a register as opposed to within the stack frame. */
    test1 = some_function();
    if (test1 > 1)
          test2 = 0;
    else
          test2 = other_function();
    return test2;
}

The int type specifiers which are commented out could be omitted in K&R C, but are required in later standards.

Since K&R function declarations did not include any information about function arguments, function parameter type checks were not performed, although some compilers would issue a warning message if a local function was called with the wrong number of arguments, or if different calls to an external function used different numbers or types of arguments. Separate tools such as Unix's lint utility were developed that (among other things) could check for consistency of function use across multiple source files.

In the years following the publication of K&R C, several features were added to the language, supported by compilers from AT&T (in particular PCC) and some other vendors. These included:

• void functions (i.e., functions with no return value)
• functions returning struct or union types (previously only a single pointer, integer or float could be returned)
• assignment for struct data types
• enumerated types (previously, preprocessor definitions for integer fixed values were used, e.g. #define GREEN 3)

The large number of extensions and lack of agreement on a standard library, together with the language popularity and the fact that not even the Unix compilers precisely implemented the K&R specification, led to the necessity of standardization.

ANSI C and ISO C

Main article: ANSI C

During the late 1970s and 1980s, versions of C were implemented for a wide variety of mainframe computers, minicomputers, and microcomputers, including the IBM PC, as its popularity began to increase significantly.

In 1983, the American National Standards Institute (ANSI) formed a committee, X3J11, to establish a standard specification of C. X3J11 based the C standard on the Unix implementation; however, the non-portable portion of the Unix C library was handed off to the IEEE working group 1003 to become the basis for the 1988 POSIX standard. In 1989, the C standard was ratified as ANSI X3.159-1989 "Programming Language C". This version of the language is often referred to as ANSI C, Standard C, or sometimes C89.

In 1990, the ANSI C standard (with formatting changes) was adopted by the International Organization for Standardization (ISO) as ISO/IEC 9899:1990, which is sometimes called C90. Therefore, the terms "C89" and "C90" refer to the same programming language.

ANSI, like other national standards bodies, no longer develops the C standard independently, but defers to the international C standard, maintained by the working group ISO/IEC JTC1/SC22/WG14. National adoption of an update to the international standard typically occurs within a year of ISO publication.

One of the aims of the C standardization process was to produce a superset of K&R C, incorporating many of the subsequently introduced unofficial features. The standards committee also included several additional features such as function prototypes (borrowed from C++), void pointers, support for international character sets and locales, and preprocessor enhancements. Although the syntax for parameter declarations was augmented to include the style used in C++, the K&R interface continued to be permitted, for compatibility with existing source code.

C89 is supported by current C compilers, and most modern C code is based on it. Any program written only in Standard C and without any hardware-dependent assumptions will run correctly on any platform with a conforming C implementation, within its resource limits. Without such precautions, programs may compile only on a certain platform or with a particular compiler, due, for example, to the use of non-standard libraries, such as GUI libraries, or to a reliance on compiler- or platform-specific attributes such as the exact size of data types and byte endianness.

In cases where code must be compilable by either standard-conforming or K&R C-based compilers, the __STDC__ macro can be used to split the code into Standard and K&R sections to prevent the use on a K&R C-based compiler of features available only in Standard C.

After the ANSI/ISO standardization process, the C language specification remained relatively static for several years. In 1995, Normative Amendment 1 to the 1990 C standard (ISO/IEC 9899/AMD1:1995, known informally as C95) was published, to correct some details and to add more extensive support for international character sets.

C99

Main article: C99

The C standard was further revised in the late 1990s, leading to the publication of ISO/IEC 9899:1999 in 1999, which is commonly referred to as "C99". It has since been amended three times by Technical Corrigenda.

C99 introduced several new features, including inline functions, several new data types (including long long int and a complex type to represent complex numbers), variable-length arrays and flexible array members, improved support for IEEE 754 floating point, support for variadic macros (macros of variable arity), and support for one-line comments beginning with //, as in BCPL or C++. Many of these had already been implemented as extensions in several C compilers.

C99 is for the most part backward compatible with C90, but is stricter in some ways; in particular, a declaration that lacks a type specifier no longer has int implicitly assumed. A standard macro __STDC_VERSION__ is defined with value 199901L to indicate that C99 support is available. GCC, Solaris Studio, and other C compilers now support many or all of the new features of C99. The C compiler in Microsoft Visual C++, however, implements the C89 standard and those parts of C99 that are required for compatibility with C++11.

In addition, the C99 standard requires support for identifiers using Unicode in the form of escaped characters (e.g. \u0040 or \U0001f431) and suggests support for raw Unicode names.

C11

Main article: C11 (C standard revision)

In 2007, work began on another revision of the C standard, informally called "C1X" until its official publication of ISO/IEC 9899:2011 on 2011-12-08. The C standards committee adopted guidelines to limit the adoption of new features that had not been tested by existing implementations.

The C11 standard adds numerous new features to C and the library, including type generic macros, anonymous structures, improved Unicode support, atomic operations, multi-threading, and bounds-checked functions. It also makes some portions of the existing C99 library optional, and improves compatibility with C++. The standard macro __STDC_VERSION__ is defined as 201112L to indicate that C11 support is available.

C17

Main article: C17 (C standard revision)

Published in June 2018 as ISO/IEC 9899:2018, C17 is the current standard for the C programming language. It introduces no new language features, only technical corrections, and clarifications to defects in C11. The standard macro __STDC_VERSION__ is defined as 201710L to indicate that C17 support is available.

C23

Main article: C23 (C standard revision)

C23 is the informal name for the next (after C17) major C language standard revision. It was informally known as "C2X" through most of its development. C23 is expected to be published in early 2024 as ISO/IEC 9899:2024. The standard macro __STDC_VERSION__ is defined as 202311L to indicate that C23 support is available.

C2Y

C2Y is a temporary informal name for the next major C language standard revision, after C23 (C2X), that is hoped to be released later in the 2020s decade, per the two in "C2Y". An early working draft of C2Y was released in February 2024 as N3220 by the working group ISO/IEC JTC1/SC22/WG14.

Embedded C

Main article: Embedded C

Historically, embedded C programming requires nonstandard extensions to the C language in order to support exotic features such as fixed-point arithmetic, multiple distinct memory banks, and basic I/O operations.

In 2008, the C Standards Committee published a technical report extending the C language to address these issues by providing a common standard for all implementations to adhere to. It includes a number of features not available in normal C, such as fixed-point arithmetic, named address spaces, and basic I/O hardware addressing.

Syntax

Main article: C syntax

C has a formal grammar specified by the C standard. Line endings are generally not significant in C; however, line boundaries do have significance during the preprocessing phase. Comments may appear either between the delimiters /* and */, or (since C99) following // until the end of the line. Comments delimited by /* and */ do not nest, and these sequences of characters are not interpreted as comment delimiters if they appear inside string or character literals.

C source files contain declarations and function definitions. Function definitions, in turn, contain declarations and statements. Declarations either define new types using keywords such as struct, union, and enum, or assign types to and perhaps reserve storage for new variables, usually by writing the type followed by the variable name. Keywords such as char and int specify built-in types. Sections of code are enclosed in braces ({ and }, sometimes called "curly brackets") to limit the scope of declarations and to act as a single statement for control structures.

As an imperative language, C uses statements to specify actions. The most common statement is an expression statement, consisting of an expression to be evaluated, followed by a semicolon; as a side effect of the evaluation, functions may be called and variables may be assigned new values. To modify the normal sequential execution of statements, C provides several control-flow statements identified by reserved keywords. Structured programming is supported by if ... [else] conditional execution and by do ... while, while, and for iterative execution (looping). The for statement has separate initialization, testing, and reinitialization expressions, any or all of which can be omitted. break and continue can be used within the loop. Break is used to leave the innermost enclosing loop statement and continue is used to skip to its reinitialisation. There is also a non-structured goto statement which branches directly to the designated label within the function. switch selects a case to be executed based on the value of an integer expression. Different from many other languages, control-flow will fall through to the next case unless terminated by a break.

Expressions can use a variety of built-in operators and may contain function calls. The order in which arguments to functions and operands to most operators are evaluated is unspecified. The evaluations may even be interleaved. However, all side effects (including storage to variables) will occur before the next "sequence point"; sequence points include the end of each expression statement, and the entry to and return from each function call. Sequence points also occur during evaluation of expressions containing certain operators (&&, ||, ?: and the comma operator). This permits a high degree of object code optimization by the compiler, but requires C programmers to take more care to obtain reliable results than is needed for other programming languages.

Kernighan and Ritchie say in the Introduction of The C Programming Language: "C, like any other language, has its blemishes. Some of the operators have the wrong precedence; some parts of the syntax could be better." The C standard did not attempt to correct many of these blemishes, because of the impact of such changes on already existing software.

Character set

The basic C source character set includes the following characters:

• Lowercase and uppercase letters of ISO Basic Latin Alphabet: a–z A–Z
• Decimal digits: 0–9
• Graphic characters: ! " # % & ' ( ) * + , - . / : ; < = > ? [ \ ] ^ _ { | } ~
• Whitespace characters: space, horizontal tab, vertical tab, form feed, newline

Newline indicates the end of a text line; it need not correspond to an actual single character, although for convenience C treats it as one.

Additional multi-byte encoded characters may be used in string literals, but they are not entirely portable. The latest C standard (C11) allows multi-national Unicode characters to be embedded portably within C source text by using \uXXXX or \UXXXXXXXX encoding (where the X denotes a hexadecimal character), although this feature is not yet widely implemented.

The basic C execution character set contains the same characters, along with representations for alert, backspace, and carriage return. Run-time support for extended character sets has increased with each revision of the C standard.

Reserved words

The following reserved words are case sensitive.

C89 has 32 reserved words, also known as keywords, which are the words that cannot be used for any purposes other than those for which they are predefined:

• auto
• break
• case
• char
• const
• continue
• default
• do
• double
• else
• enum
• extern
• float
• for
• goto
• if
• int
• long
• register
• return
• short
• signed
• sizeof
• static
• struct
• switch
• typedef
• union
• unsigned
• void
• volatile
• while

C99 reserved five more words: (‡ is an alternative spelling alias for a C23 keyword)

• inline
• restrict
• _Bool ‡
• _Complex
• _Imaginary

C11 reserved seven more words: (‡ is an alternative spelling alias for a C23 keyword)

• _Alignas ‡
• _Alignof ‡
• _Atomic
• _Generic
• _Noreturn
• _Static_assert ‡
• _Thread_local ‡

C23 reserved fifteen more words:

• alignas
• alignof
• bool
• constexpr
• false
• nullptr
• static_assert
• thread_local
• true
• typeof
• typeof_unqual
• _BitInt
• _Decimal32
• _Decimal64
• _Decimal128

Most of the recently reserved words begin with an underscore followed by a capital letter, because identifiers of that form were previously reserved by the C standard for use only by implementations. Since existing program source code should not have been using these identifiers, it would not be affected when C implementations started supporting these extensions to the programming language. Some standard headers do define more convenient synonyms for underscored identifiers. Some of those words were added as keywords with their conventional spelling in C23 and the corresponding macros were removed.

Prior to C89, entry was reserved as a keyword. In the second edition of their book The C Programming Language, which describes what became known as C89, Kernighan and Ritchie wrote, "The ... [keyword] entry, formerly reserved but never used, is no longer reserved." and "The stillborn entry keyword is withdrawn."

Operators

Main article: Operators in C and C++

C supports a rich set of operators, which are symbols used within an expression to specify the manipulations to be performed while evaluating that expression. C has operators for:

• arithmetic: +, -, *, /, %
• assignment: =
• augmented assignment: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
• bitwise logic: ~, &, |, ^
• bitwise shifts: <<, >>
• Boolean logic: !, &&, ||
• conditional evaluation: ? :
• equality testing: ==, !=
• calling functions: ( )
• increment and decrement: ++, --
• member selection: ., ->
• object size: sizeof
• type: typeof, typeof_unqual since C23
• order relations: <, <=, >, >=
• reference and dereference: &, *, [ ]
• sequencing: ,
• subexpression grouping: ( )
• type conversion: (typename)

C uses the operator = (used in mathematics to express equality) to indicate assignment, following the precedent of Fortran and PL/I, but unlike ALGOL and its derivatives. C uses the operator == to test for equality. The similarity between these two operators (assignment and equality) may result in the accidental use of one in place of the other, and in many cases, the mistake does not produce an error message (although some compilers produce warnings). For example, the conditional expression if (a == b + 1) might mistakenly be written as if (a = b + 1), which will be evaluated as true unless the value of a is 0 after the assignment.

The C operator precedence is not always intuitive. For example, the operator == binds more tightly than (is executed prior to) the operators & (bitwise AND) and | (bitwise OR) in expressions such as x & 1 == 0, which must be written as (x & 1) == 0 if that is the coder's intent.

Пример «Привет, мир»

См. также: Привет, мир

"Привет, мир!" программа Брайана Кернигана (1978)

Пример « hello, world », появившийся в первом издании K&R , стал образцом вводной программы в большинстве учебников по программированию. Программа выводит «привет, мир» на стандартный вывод , который обычно представляет собой терминал или экран.

Оригинальная версия была:

main()
{
    printf("hello, world\n");
}

Соответствующая стандарту программа «Привет, мир»:

#include <stdio.h>

int main(void)
{
    printf("hello, world\n");
}

Первая строка программы содержит директиву предварительной обработки , обозначенную #include. Это приводит к тому, что компилятор заменяет эту строку всем текстом stdio.h стандартный заголовок, который содержит объявления для стандартных функций ввода и вывода, таких как printf и scanf. Угловые скобки, окружающие stdio.h указать, что stdio.h можно найти с помощью стратегии поиска, которая предпочитает заголовки, предоставленные компилятором, другим заголовкам с тем же именем, в отличие от двойных кавычек, которые обычно включают локальные или специфичные для проекта файлы заголовков.

Следующая строка указывает, что функция с именем main определяется. main функция служит специальной цели в программах на языке C; среда выполнения вызывает main функция для начала выполнения программы. Спецификатор типа int указывает, что значение, возвращаемое вызывающей стороне (в данном случае среде выполнения) в результате оценки main функция, является целым числом. Ключевое слово void поскольку список параметров указывает, что эта функция не принимает аргументов.

Открывающая фигурная скобка указывает на начало определения main функция.

Следующая строка вызывает (перенаправляет выполнение) функцию с именем printf, который в данном случае предоставляется из системной библиотеки . В этом звонке printf функции передается (предоставляется) один аргумент — адрес первого символа строкового литерала. "hello, world\n". Строковый литерал представляет собой безымянный массив с элементами типа char, автоматически устанавливается компилятором с последним символом NULL (значение ASCII 0) для обозначения конца массива (для printf чтобы узнать длину строки). Символ NULL также можно записать как escape-последовательность , записанную как \0. \n — это escape-последовательность , которую C преобразует в символ новой строки , который на выходе означает конец текущей строки. Возвращаемое значение printf функция имеет тип int, но он молча отбрасывается, поскольку не используется. (Более осторожная программа могла бы проверить возвращаемое значение, чтобы определить, действительно ли printf функция завершилась успешно.) Точка с запятой ; завершает заявление.

Закрывающая фигурная скобка указывает на конец кода для main функция. Согласно спецификации C99 и новее, main функция, в отличие от любой другой функции, неявно возвращает значение 0 по достижении } это завершает функцию. (Раньше явное return 0; требовался оператор.) Это интерпретируется системой времени выполнения как код выхода, указывающий на успешное выполнение.

Типы данных

Основная статья: Типы и объявления переменных C

Система типов в C статична и слабо типизирована , что делает ее похожей на систему типов потомков АЛГОЛА, таких как Паскаль . Существуют встроенные типы для целых чисел различных размеров, как знаковых, так и беззнаковых, чисел с плавающей запятой и перечислимых типов ( enum). Целочисленный тип char часто используется для однобайтовых символов. В C99 добавлен логический тип данных . Существуют также производные типы, включая массивы , указатели , записи ( struct) и союзы ( union).

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

Некоторые считают синтаксис объявления C неинтуитивным, особенно для указателей на функции . (Идея Ричи заключалась в том, чтобы объявлять идентификаторы в контексте, напоминающем их использование: « объявление отражает использование ».)

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

Указатели

C поддерживает использование указателей — типа ссылки , которая записывает адрес или расположение объекта или функции в памяти. Указатели можно разыменовать для доступа к данным, хранящимся по указанному адресу, или для вызова указанной функции. Указателями можно манипулировать с помощью присваивания или арифметики указателей . Представление значения указателя во время выполнения обычно представляет собой необработанный адрес памяти (возможно, дополненный полем смещения внутри слова), но поскольку тип указателя включает тип объекта, на который он указывает, выражения, включающие указатели, могут быть проверены по типу. во время компиляции. Арифметика указателей автоматически масштабируется в соответствии с размером типа данных, на который указывает.

Указатели используются в C для многих целей. Текстовые строки обычно обрабатываются с помощью указателей на массивы символов. Динамическое выделение памяти осуществляется с помощью указателей; результат malloc обычно приводится к типу сохраняемых данных. Многие типы данных, такие как деревья , обычно реализуются как динамически выделяемые. struct объекты, связанные между собой с помощью указателей. Указатели на другие указатели часто используются в многомерных массивах и массивах struct объекты. Указатели на функции ( указатели функций ) полезны для передачи функций в качестве аргументов функциям более высокого порядка (таким как qsort или bsearch ), в таблицах диспетчеризации или в качестве обратных вызовов обработчикам событий .

нулевого указателя Значение явно указывает на отсутствие допустимого местоположения. Разыменование значения нулевого указателя не определено, что часто приводит к ошибке сегментации . Значения нулевого указателя полезны для указания особых случаев, таких как отсутствие указателя «следующий» в конечном узле связанного списка или в качестве индикации ошибки в функциях, возвращающих указатели. В соответствующих контекстах исходного кода, например, при присвоении переменной указателя, константа нулевого указателя может быть записана как 0, с явным приведением к типу указателя или без него, поскольку NULL макрос, определенный несколькими стандартными заголовками или, начиная с C23, с константой nullptr. В условных контекстах значения нулевого указателя оцениваются как false, в то время как все остальные значения указателя оцениваются как true.

Пустые указатели ( void *) указывают на объекты неопределенного типа и поэтому могут использоваться как «универсальные» указатели данных. Поскольку размер и тип объекта, на который указывает указатель, неизвестны, указатели void не могут быть разыменованы, а арифметика указателей на них не допускается, хотя их можно легко (и во многих контекстах неявно так и делают) преобразовать в указатель любого другого объекта и из него. тип.

Неосторожное использование указателей потенциально опасно. Поскольку они обычно не отмечены флажком, переменную-указатель можно указать на любое произвольное место, что может вызвать нежелательные эффекты. Хотя правильно используемые указатели указывают на безопасные места, их можно заставить указывать на небезопасные места, используя недопустимую арифметику указателей ; объекты, на которые они указывают, могут продолжать использоваться после освобождения ( висячие указатели ); их можно использовать без инициализации ( дикие указатели ); или им может быть напрямую присвоено небезопасное значение с помощью приведения, объединения или другого поврежденного указателя. В общем, C позволяет манипулировать типами указателей и преобразовывать их между собой, хотя компиляторы обычно предоставляют опции для различных уровней проверки. Некоторые другие языки программирования решают эти проблемы, используя более ограничительные ссылочные типы.

Массивы

См. также: Обработка строк C.

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

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

В C нет специального средства для объявления многомерных массивов , а скорее полагается на рекурсию внутри системы типов для объявления массивов массивов, что фактически выполняет то же самое. Значения индекса результирующего «многомерного массива» можно рассматривать как увеличивающиеся в порядке возрастания строк . Многомерные массивы обычно используются в числовых алгоритмах (в основном из прикладной линейной алгебры ) для хранения матриц. Структура массива C хорошо подходит для этой конкретной задачи. Однако в ранних версиях C границы массива должны быть известны фиксированными значениями или явно передаваться в любую подпрограмму, которая их требует, а к массивам массивов с динамическим размером нельзя получить доступ с помощью двойной индексации. (Обходным решением этой проблемы было выделение массива с дополнительным «вектором-строкой» указателей на столбцы.) C99 представил «массивы переменной длины», которые решают эту проблему.

В следующем примере с использованием современного C (C99 или более поздней версии) показано размещение двумерного массива в куче и использование индексации многомерного массива для доступа (которая может использовать проверку границ во многих компиляторах C):

int func(int N, int M)
{
  float (*p)[N][M] = malloc(sizeof *p);
  if (p == 0)
    return -1;
  for (int i = 0; i < N; i++)
    for (int j = 0; j < M; j++)
      (*p)[i][j] = i + j;
  print_array(N, M, p);
  free(p);
  return 1;
}

А вот аналогичная реализация с использованием функции Auto VLA C99 :

int func(int N, int M)
{
  // Caution: checks should be made to ensure N*M*sizeof(float) does NOT exceed limitations for auto VLAs and is within available size of stack.
  float p[N][M]; // auto VLA is held on the stack, and sized when the function is invoked
  for (int i = 0; i < N; i++)
    for (int j = 0; j < M; j++)
      p[i][j] = i + j;
  print_array(N, M, p);
  // no need to free(p) since it will disappear when the function exits, along with the rest of the stack frame
  return 1;
}

Взаимозаменяемость массива и указателя

Индексное обозначение x[i] (где x обозначает указатель) является синтаксическим сахаром для *(x+i). Воспользовавшись знанием компилятора типа указателя, адреса, который x + i указывает на не базовый адрес (на который указывает x) увеличивается на i байт, а скорее определяется как базовый адрес, увеличенный на i умножается на размер элемента, который x указывает на. Таким образом, x[i] обозначает i+1-й элемент массива.

Более того, в большинстве контекстов выражений (заметным исключением является операнд sizeof), выражение типа массива автоматически преобразуется в указатель на первый элемент массива. Это означает, что массив никогда не копируется целиком, если он назван в качестве аргумента функции, а передается только адрес его первого элемента. Таким образом, хотя вызовы функций в C используют семантику передачи по значению , массивы фактически передаются по ссылке .

Общий размер массива x можно определить, применив sizeof к выражению типа массива. Размер элемента можно определить, применив оператор sizeof к любому разыменованному элементу массива A, как в n = sizeof A[0]. Таким образом, количество элементов в объявленном массиве A может быть определен как sizeof A / sizeof A[0]. Обратите внимание: если доступен только указатель на первый элемент, как это часто бывает в коде C из-за описанного выше автоматического преобразования, информация о полном типе массива и его длине теряется.

Управление памятью

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

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

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

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

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

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

Библиотеки

Язык программирования C использует библиотеки в качестве основного метода расширения. В языке C библиотека — это набор функций, содержащихся в одном «архивном» файле. Каждая библиотека обычно имеет заголовочный файл , который содержит прототипы функций, содержащихся в библиотеке, которые могут использоваться программой, а также объявления специальных типов данных и макросимволов, используемых с этими функциями. Чтобы программа могла использовать библиотеку, она должна включать заголовочный файл библиотеки, а библиотека должна быть связана с программой, что во многих случаях требует флагов компилятора (например, -lm, сокращение от «связать математическую библиотеку»).

Наиболее распространенной библиотекой C является стандартная библиотека C , которая определяется стандартами ISO и ANSI C и поставляется с каждой реализацией C (реализации, предназначенные для ограниченных сред, таких как встроенные системы, могут предоставлять только подмножество стандартной библиотеки). Эта библиотека поддерживает потоковый ввод и вывод, распределение памяти, математические операции, строки символов и значения времени. Несколько отдельных стандартных заголовков (например, stdio.h) определяют интерфейсы для этих и других стандартных библиотечных средств.

Другой распространенный набор функций библиотеки C — это те, которые используются приложениями, специально предназначенными для Unix и Unix-подобных систем, особенно функции, которые обеспечивают интерфейс с ядром . Эти функции подробно описаны в различных стандартах, таких как POSIX и Единая спецификация UNIX .

Поскольку многие программы написаны на языке C, существует множество других доступных библиотек. Библиотеки часто пишутся на C, поскольку компиляторы C генерируют эффективный объектный код ; затем программисты создают интерфейсы для библиотеки, чтобы подпрограммы можно было использовать из языков более высокого уровня, таких как Java , Perl и Python .

Обработка файлов и потоки

Ввод и вывод файлов (I/O) не являются частью самого языка C, а обрабатываются библиотеками (такими как стандартная библиотека C) и связанными с ними заголовочными файлами (например, stdio.h). Обработка файлов обычно реализуется посредством ввода-вывода высокого уровня, который работает через потоки . С этой точки зрения поток — это поток данных, независимый от устройств, тогда как файл — это конкретное устройство. Ввод-вывод высокого уровня осуществляется посредством ассоциации потока с файлом. В стандартной библиотеке C буфер (область памяти или очередь) временно используется для хранения данных перед их отправкой в ​​конечный пункт назначения. Это сокращает время ожидания более медленных устройств, например жесткого или твердотельного накопителя . Функции ввода-вывода низкого уровня не являются частью стандартной библиотеки C. но, как правило, являются частью программирования на «голом железе» (программирование, независимое от какой-либо операционной системы, например, большинство встроенных программ ). За некоторыми исключениями, реализации включают низкоуровневый ввод-вывод.

Языковые инструменты

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

Автоматизированная проверка и аудит исходного кода полезны на любом языке, и для C существует множество таких инструментов, например Lint . Обычной практикой является использование Lint для обнаружения сомнительного кода при первом написании программы. Как только программа проходит Lint, она компилируется с помощью компилятора C. Кроме того, многие компиляторы могут дополнительно предупреждать о синтаксически допустимых конструкциях, которые на самом деле могут оказаться ошибками. MISRA C — это собственный набор правил, позволяющий избегать использования такого сомнительного кода, разработанный для встроенных систем.

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

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

Использует

использования в

Некоторое программное обеспечение, написанное на C

C широко используется для системного программирования при реализации операционных систем и встроенных системных приложений. Это происходит по нескольким причинам:

• Язык C обеспечивает доступ к аппаратному обеспечению и памяти платформы с помощью указателей и каламбура типов , поэтому специфичные для системы функции (например, регистры управления/состояния , регистры ввода-вывода ) могут быть настроены и использованы с кодом, написанным на C – это обеспечивает наиболее полный контроль над платформа, на которой он работает.
• Код, сгенерированный после компиляции, не требует многих системных функций и может быть напрямую вызван из некоторого загрузочного кода — его просто выполнить.
• Операторы и выражения языка C обычно хорошо сопоставляются с последовательностями инструкций для целевого процессора, и, следовательно, во время выполнения требуется мало системных ресурсов — они выполняются быстро.
• Благодаря богатому набору операторов язык C может использовать многие функции целевых процессоров. Если конкретный ЦП имеет более экзотические инструкции, можно создать языковой вариант с, возможно, встроенными функциями для использования этих инструкций - он может использовать практически все функции целевого ЦП.
• Язык позволяет легко накладывать структуры на блоки двоичных данных, позволяя понимать данные, перемещаться по ним и изменять их — он может записывать структуры данных, даже файловые системы.
• Язык поддерживает богатый набор операторов, включая битовые манипуляции, для целочисленной арифметики и логики, а также, возможно, различные размеры чисел с плавающей запятой — он может эффективно обрабатывать соответствующим образом структурированные данные.
• C — довольно небольшой язык, содержащий всего несколько операторов и не имеющий слишком большого количества функций, которые генерируют обширный целевой код — он понятен.
• C имеет прямой контроль над выделением и освобождением памяти, что обеспечивает разумную эффективность и предсказуемое время операций обработки памяти, без каких-либо проблем со спорадическими событиями остановки мира - он имеет предсказуемую производительность.
• C позволяет использовать и реализовывать различные схемы распределения памяти , включая типичную. malloc и free; более сложный механизм с аренами ; или версию для ядра ОС , которая может подходить для DMA , использоваться в обработчиках прерываний или интегрироваться с системой виртуальной памяти .
• В зависимости от компоновщика и среды код C также может вызывать библиотеки, написанные на языке ассемблера , и может вызываться из языка ассемблера — он хорошо взаимодействует с другим кодом более низкого уровня.
• C, его соглашения о вызовах и структуры компоновщика обычно используются в сочетании с другими языками высокого уровня, при этом поддерживаются вызовы как на C, так и из C — он хорошо взаимодействует с другим кодом высокого уровня.
• C имеет очень зрелую и обширную экосистему, включающую библиотеки, фреймворки, компиляторы с открытым исходным кодом, отладчики и утилиты, и является фактическим стандартом. Вполне вероятно, что драйверы на C уже существуют или существует архитектура ЦП, аналогичная внутренней части компилятора C, поэтому стимулы для выбора другого языка уменьшаются.

Используется для библиотек с интенсивными вычислениями

C позволяет программистам создавать эффективные реализации алгоритмов и структур данных, поскольку уровень абстракции от аппаратного обеспечения тонкий, а его накладные расходы невелики, что является важным критерием для программ с интенсивными вычислениями. Например, библиотека арифметики множественной точности GNU , научная библиотека GNU , Mathematica и MATLAB полностью или частично написаны на C. Многие языки поддерживают вызов библиотечных функций на C, например, Python на основе фреймворк NumPy использует C для высокой точности. -Аспекты производительности и взаимодействия с оборудованием.

C как промежуточный язык

C иногда используется в качестве промежуточного языка в реализациях других языков. Этот подход можно использовать для портативности или удобства; используя C в качестве промежуточного языка, дополнительные генераторы кода, специфичные для машины, не нужны. В C есть некоторые функции, такие как директивы препроцессора с номерами строк и необязательные лишние запятые в конце списков инициализаторов, которые поддерживают компиляцию сгенерированного кода. Однако некоторые недостатки C побудили разработку других языков на основе C, специально предназначенных для использования в качестве промежуточных языков, таких как C-- . Кроме того, современные основные компиляторы GCC и LLVM имеют промежуточное представление , отличное от C, и эти компиляторы поддерживают интерфейсы для многих языков, включая C.

Другие языки, написанные на C

Следствием широкой доступности и эффективности C является то, что компиляторы , библиотеки и интерпретаторы других языков программирования часто реализуются на C. Например, реализации Python эталонные , Перл , Руби , и PHP написаны на языке С.

Когда-то использовался для веб-разработки

Исторически C иногда использовался для веб-разработки с использованием Common Gateway Interface (CGI) в качестве «шлюза» для передачи информации между веб-приложением, сервером и браузером. Си, возможно, был предпочтительнее интерпретируемых языков из-за его скорости, стабильности и почти универсальной доступности. Веб-разработка на языке C больше не является обычной практикой. и существует множество других инструментов веб-разработки .

Веб-серверы

Два самых популярных веб-сервера , Apache HTTP Server и Nginx , написаны на C. Эти веб-серверы взаимодействуют с операционной системой, прослушивают TCP-порты на предмет HTTP-запросов, а затем обслуживают статический веб-контент или вызывают выполнение других языки, обрабатывающие «рендеринг» контента, такие как PHP , который сам по себе в основном написан на C. «близкий к металлу» подход C позволяет создавать такие высокопроизводительные программные системы.

Приложения для конечных пользователей

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

Ограничения

мощь языка ассемблера и удобство... языка ассемблера

— Деннис Ричи

Хотя C был популярен, влиятельн и чрезвычайно успешен, у него есть недостатки, в том числе:

• Стандартная обработка динамической памяти с помощью malloc и free подвержен ошибкам. К ошибкам относятся: Утечки памяти, когда память выделяется, но не освобождается; и доступ к ранее освобожденной памяти.
• Использование указателей и прямое манипулирование памятью означает, что возможно повреждение памяти, возможно, из-за ошибки программиста или недостаточной проверки неверных данных.
• Существует некоторая проверка типов , но она не применима к таким областям, как вариативные функции , и проверку типов можно тривиально или непреднамеренно обойти. Он слабо типизирован .
• Поскольку код, сгенерированный компилятором, сам по себе содержит мало проверок, на программиста ложится обязанность учитывать все возможные результаты, защищать от переполнения буфера, проверки границ массива, переполнения стека , исчерпания памяти, а также учитывать условия гонки , изоляцию потоков и т. д. .
• Использование указателей и манипулирование ими во время выполнения означает, что может быть два способа доступа к одним и тем же данным (псевдонимы), которые невозможно определить во время компиляции. Это означает, что некоторые оптимизации, доступные для других языков, невозможны в C. FORTRAN считается более быстрым.
• Некоторые функции стандартной библиотеки, например scanf или strncat, может привести к переполнению буфера .
• Существует ограниченная стандартизация поддержки низкоуровневых вариантов сгенерированного кода, например: различные соглашения о вызове функций и ABI ; различные по упаковке структур соглашения ; различный порядок байтов в больших целых числах (включая порядок байтов). Во многих реализациях языка некоторые из этих параметров могут обрабатываться с помощью директивы препроцессора. #pragma, а некоторые с дополнительными ключевыми словами, например, используйте __cdecl соглашение о вызовах. Но директива и параметры не поддерживаются последовательно.
• Обработка строк с использованием стандартной библиотеки требует большого количества кода и требует явного управления памятью.
• Язык напрямую не поддерживает объектную ориентацию, интроспекцию , оценку выражений во время выполнения, дженерики и т. д.
• Существует мало средств защиты от ненадлежащего использования возможностей языка, которое может привести к неподдерживаемому коду. В частности, препроцессор C может скрывать такие тревожные эффекты, как двойное вычисление и многое другое. Эта возможность создания сложного кода была отмечена такими соревнованиями, как International Obfuscated C Code Contest и Underhanded C Contest .
• В C отсутствует стандартная поддержка обработки исключений , и он предлагает только коды возврата для проверки ошибок. setjmp и longjmp использовались стандартные библиотечные функции реализовать механизм try-catch с помощью макросов.

Для некоторых целей были приняты ограниченные стили C, например MISRA C или CERT C , в попытке уменьшить вероятность ошибок. Базы данных, такие как CWE, пытаются подсчитать количество уязвимостей C и т. д., а также дать рекомендации по их устранению.

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

Родственные языки

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

Основная статья: Список языков программирования семейства C

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

Существует несколько интерпретаторов C или близких к C, включая Ch и CINT , которые также можно использовать для написания сценариев.

Когда объектно-ориентированные языки программирования стали популярными, C++ и Objective-C были двумя разными расширениями C, предоставлявшими объектно-ориентированные возможности. Оба языка изначально были реализованы как компиляторы исходного кода ; исходный код был переведен на C, а затем скомпилирован компилятором C.

Язык программирования C++ (первоначально называвшийся «C с классами ») был разработан Бьярном Страуструпом как подход к обеспечению объектно-ориентированной функциональности с синтаксисом, подобным C. C++ добавляет большую силу типизации, область видимости и другие инструменты, полезные в объектно-ориентированном программировании, а также допускает универсальное программирование с помощью шаблонов. Теперь это почти расширенный набор C, C++. поддерживает большую часть C, за некоторыми исключениями .

Objective-C изначально был очень «тонким» слоем поверх C и остается строгим надмножеством C, которое позволяет объектно-ориентированное программирование с использованием гибридной парадигмы динамической/статической типизации. Синтаксис Objective-C заимствован как из C, так и из Smalltalk : синтаксис, включающий предварительную обработку, выражения, объявления функций и вызовы функций, унаследован от C, тогда как синтаксис объектно-ориентированных функций изначально был взят из Smalltalk.

Помимо C++ и Objective-C , Ch , Cilk и Unified Parallel C являются почти надмножествами C.

См. также

• Совместимость C и C++
• Сравнение Паскаля и C
• Сравнение языков программирования
• Международный конкурс запутанного кода C
• Список языков программирования на основе C
• Список компиляторов C

Источники

• Ричи, Деннис М. (март 1993 г.). «Развитие языка Си» . Уведомления ACM SIGPLAN . 28 (3). АКМ: 201–208. дои : 10.1145/155360.155580 .
  • С любезного разрешения автора, также по адресу Ричи, Деннис М. «Чистори» . www.bell-labs.com . Проверено 29 марта 2022 г.
• Ричи, Деннис М. (1993). «Развитие языка Си» . Вторая конференция ACM SIGPLAN по истории языков программирования (HOPL-II) . АКМ . стр. 201–208. дои : 10.1145/154766.155580 . ISBN  0-89791-570-4 . Проверено 4 ноября 2014 г.
• Керниган, Брайан В .; Ричи, Деннис М. (1988). Язык программирования C (2-е изд.). Прентис Холл . ISBN  0-13-110362-8 .

Дальнейшее чтение

• Плаугер, П.Дж. (1992). Стандартная библиотека C (1-е изд.). Прентис Холл. ISBN  978-0131315099 . (источник)
• Банахан, М.; Брэди, Д.; Доран, М. (1991). Книга C: Показ стандарта ANSI C (2-е изд.). Аддисон-Уэсли. ISBN  978-0201544336 . (бесплатно)
• Харбисон, Сэмюэл; Стил, Гай младший (2002). C: Справочное руководство (5-е изд.). Пирсон. ISBN  978-0130895929 . (архив)
• Кинг, КН (2008). Программирование на C: современный подход (2-е изд.). WW Нортон. ISBN  978-0393979503 . (архив)
• Гриффитс, Дэвид; Гриффитс, Рассвет (2012). Head First C (1-е изд.). О'Рейли. ISBN  978-1449399917 .
• Перри, Грег; Миллер, Дин (2013). Программирование на C: Абсолютное руководство для начинающих (3-е изд.). Que. ISBN  978-0789751980 .
• Дейтел, Пол; Дейтел, Харви (2015). C: Как программировать (8-е изд.). Пирсон. ISBN  978-0133976892 .
• Гуштедт, Йенс (2019). Современный C (2-е изд.). Мэннинг. ISBN  978-1617295812 . (бесплатно)

Внешние ссылки

• Официальный сайт рабочей группы ISO C
  • ISO/IEC 9899 , ​​общедоступные официальные документы C, включая обоснование C99.
  • «C99 с техническими исправлениями TC1, TC2 и TC3» (PDF) . Архивировано (PDF) из оригинала 25 октября 2007 г.   (3,61 МБ).
• comp.lang.c Часто задаваемые вопросы
• История C , Деннис Ритчи
• Справочник по библиотеке C и примеры