A | B | C | D | E | F | G | H | CH | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these template messages)
|
The syntax of the C programming language is the set of rules governing writing of software in C. It is designed to allow for programs that are extremely terse, have a close relationship with the resulting object code, and yet provide relatively high-level data abstraction. C was the first widely successful high-level language for portable operating-system development.
C syntax makes use of the maximal munch principle.
Data structures
Primitive data types
The C programming language represents numbers in three forms: integral, real and complex. This distinction reflects similar distinctions in the instruction set architecture of most central processing units. Integral data types store numbers in the set of integers, while real and complex numbers represent numbers (or pair of numbers) in the set of real numbers in floating point form.
All C integer types have signed
and unsigned
variants. If signed
or unsigned
is not specified explicitly, in most circumstances, signed
is assumed. However, for historic reasons, plain char
is a type distinct from both signed char
and unsigned char
. It may be a signed type or an unsigned type, depending on the compiler and the character set (C guarantees that members of the C basic character set have positive values). Also, bit field types specified as plain int
may be signed or unsigned, depending on the compiler.
Integer types
C's integer types come in different fixed sizes, capable of representing various ranges of numbers. The type char
occupies exactly one byte (the smallest addressable storage unit), which is typically 8 bits wide. (Although char
can represent any of C's "basic" characters, a wider type may be required for international character sets.) Most integer types have both signed and unsigned varieties, designated by the signed
and unsigned
keywords. Signed integer types may use a two's complement, ones' complement, or sign-and-magnitude representation. In many cases, there are multiple equivalent ways to designate the type; for example, signed short int
and short
are synonymous.
The representation of some types may include unused "padding" bits, which occupy storage but are not included in the width. The following table provides a complete list of the standard integer types and their minimum allowed widths (including any sign bit).
Shortest form of specifier | Minimum width (bits) |
---|---|
_Bool
|
1 |
char
|
8 |
signed char
|
8 |
unsigned char
|
8 |
short
|
16 |
unsigned short
|
16 |
int
|
16 |
unsigned int
|
16 |
long
|
32 |
unsigned long
|
32 |
long long [note 1]
|
64 |
unsigned long long [note 1]
|
64 |
The char
type is distinct from both signed char
and unsigned char
, but is guaranteed to have the same representation as one of them. The _Bool
and long long
types are standardized since 1999, and may not be supported by older C compilers. Type _Bool
is usually accessed via the typedef
name bool
defined by the standard header stdbool.h
.
In general, the widths and representation scheme implemented for any given platform are chosen based on the machine architecture, with some consideration given to the ease of importing source code developed for other platforms. The width of the int
type varies especially widely among C implementations; it often corresponds to the most "natural" word size for the specific platform. The standard header limits.h defines macros for the minimum and maximum representable values of the standard integer types as implemented on any specific platform.
In addition to the standard integer types, there may be other "extended" integer types, which can be used for typedef
s in standard headers. For more precise specification of width, programmers can and should use typedef
s from the standard header stdint.h.
Integer constants may be specified in source code in several ways. Numeric values can be specified as decimal (example: 1022
), octal with zero (0
) as a prefix (01776
), or hexadecimal with 0x
(zero x) as a prefix (0x3FE
). A character in single quotes (example: 'R'
), called a "character constant," represents the value of that character in the execution character set, with type int
. Except for character constants, the type of an integer constant is determined by the width required to represent the specified value, but is always at least as wide as int
. This can be overridden by appending an explicit length and/or signedness modifier; for example, 12lu
has type unsigned long
. There are no negative integer constants, but the same effect can often be obtained by using a unary negation operator "-
".
Enumerated type
The enumerated type in C, specified with the enum
keyword, and often just called an "enum" (usually pronounced /ˈiːnʌm/ EE-num or /ˈiːnuːm/ EE-noom), is a type designed to represent values across a series of named constants. Each of the enumerated constants has type int
. Each enum
type itself is compatible with char
or a signed or unsigned integer type, but each implementation defines its own rules for choosing a type.
Some compilers warn if an object with enumerated type is assigned a value that is not one of its constants. However, such an object can be assigned any values in the range of their compatible type, and enum
constants can be used anywhere an integer is expected. For this reason, enum
values are often used in place of preprocessor #define
directives to create named constants. Such constants are generally safer to use than macros, since they reside within a specific identifier namespace.
An enumerated type is declared with the enum
specifier and an optional name (or tag) for the enum, followed by a list of one or more constants contained within curly braces and separated by commas, and an optional list of variable names. Subsequent references to a specific enumerated type use the enum
keyword and the name of the enum. By default, the first constant in an enumeration is assigned the value zero, and each subsequent value is incremented by one over the previous constant. Specific values may also be assigned to constants in the declaration, and any subsequent constants without specific values will be given incremented values from that point onward.
For example, consider the following declaration:
enum colors { RED, GREEN, BLUE = 5, YELLOW } paint_color;
This declares the enum colors
type; the int
constants RED
(whose value is 0), GREEN
(whose value is one greater than RED
, 1), BLUE
(whose value is the given value, 5), and YELLOW
(whose value is one greater than BLUE
, 6); and the enum colors
variable paint_color
. The constants may be used outside of the context of the enum
(where any integer value is allowed), and values other than the constants may be assigned to paint_color
, or any other variable of type enum colors
.
Floating point types
The floating-point form is used to represent numbers with a fractional component. They do not, however, represent most rational numbers exactly; they are instead a close approximation. There are three types of real values, denoted by their specifiers: single precision (float
), double precision (double
), and double extended precision (long double
). Each of these may represent values in a different form, often one of the IEEE floating-point formats.
Type specifiers | Precision (decimal digits) | Exponent range | ||
---|---|---|---|---|
Minimum | IEEE 754 | Minimum | IEEE 754 | |
float
|
6 | 7.2 (24 bits) | ±37 | ±38 (8 bits) |
double
|
10 | 15.9 (53 bits) | ±37 | ±307 (11 bits) |
long double
|
10 | 34.0 (113 bits) | ±37 | ±4931 (15 bits) |
Floating-point constants may be written in decimal notation, e.g. 1.23
. Decimal scientific notation may be used by adding e
or E
followed by a decimal exponent, also known as E notation, e.g. 1.23e2
(which has the value 1.23 × 102 = 123.0). Either a decimal point or an exponent is required (otherwise, the number is parsed as an integer constant). Hexadecimal floating-point constants follow similar rules, except that they must be prefixed by 0x
and use p
or P
to specify a binary exponent, e.g. 0xAp-2
(which has the value 2.5, since Ah × 2−2 = 10 × 2−2 = 10 ÷ 4). Both decimal and hexadecimal floating-point constants may be suffixed by f
or F
to indicate a constant of type float
, by l
(letter l
) or L
to indicate type long double
, or left unsuffixed for a double
constant.
The standard header file float.h
defines the minimum and maximum values of the implementation's floating-point types float
, double
, and long double
. It also defines other limits that are relevant to the processing of floating-point numbers.
Storage class specifiers
Every object has a storage class. This specifies most basically the storage duration, which may be static (default for global), automatic (default for local), or dynamic (allocated), together with other features (linkage and register hint).
Specifiers | Lifetime | Scope | Default initializer |
---|---|---|---|
auto
|
Block (stack) | Block | Uninitialized |
register
|
Block (stack or CPU register) | Block | Uninitialized |
static
|
Program | Block or compilation unit | Zero |
extern
|
Program | Global (entire program) | Zero |
_Thread_local
|
Thread | ||
(none)1 | Dynamic (heap) | Uninitialized (initialized to 0 if using calloc() )
|
- 1 Allocated and deallocated using the
malloc()
andfree()
library functions.
Variables declared within a block by default have automatic storage, as do those explicitly declared with the auto
[note 2] or register
storage class specifiers. The auto
and register
specifiers may only be used within functions and function argument declarations; as such, the auto
specifier is always redundant. Objects declared outside of all blocks and those explicitly declared with the static
storage class specifier have static storage duration. Static variables are initialized to zero by default by the compiler.
Objects with automatic storage are local to the block in which they were declared and are discarded when the block is exited. Additionally, objects declared with the register
storage class may be given higher priority by the compiler for access to registers; although the compiler may choose not to actually store any of them in a register. Objects with this storage class may not be used with the address-of (&
) unary operator. Objects with static storage persist for the program's entire duration. In this way, the same object can be accessed by a function across multiple calls. Objects with allocated storage duration are created and destroyed explicitly with malloc
, free
, and related functions.
The extern
storage class specifier indicates that the storage for an object has been defined elsewhere. When used inside a block, it indicates that the storage has been defined by a declaration outside of that block. When used outside of all blocks, it indicates that the storage has been defined outside of the compilation unit. The extern
storage class specifier is redundant when used on a function declaration. It indicates that the declared function has been defined outside of the compilation unit.
The _Thread_local
(thread_local
in C++, since C23, and in earlier versions of C if the header <threads.h>
is included) storage class specifier, introduced in C11, is used to declare a thread-local variable. It can be combined with static
or extern
to determine linkage.
Note that storage specifiers apply only to functions and objects; other things such as type and enum declarations are private to the compilation unit in which they appear. Types, on the other hand, have qualifiers (see below).
Type qualifiers
Types can be qualified to indicate special properties of their data. The type qualifier const
indicates that a value does not change once it has been initialized. Attempting to modify a const
qualified value yields undefined behavior, so some C compilers store them in rodata or (for embedded systems) in read-only memory (ROM). The type qualifier volatile
indicates to an optimizing compiler that it may not remove apparently redundant reads or writes, as the value may change even if it was not modified by any expression or statement, or multiple writes may be necessary, such as for memory-mapped I/O.
Incomplete types
An incomplete type is a structure or union type whose members have not yet been specified, an array type whose dimension has not yet been specified, or the void
type (the void
type cannot be completed). Such a type may not be instantiated (its size is not known), nor may its members be accessed (they, too, are unknown); however, the derived pointer type may be used (but not dereferenced).
They are often used with pointers, either as forward or external declarations. For instance, code could declare an incomplete type like this:
struct thing *pt;
This declares pt
as a pointer to struct thing
and the incomplete type struct thing
. Pointers to data always have the same byte-width regardless of what they point to, so this statement is valid by itself (as long as pt
is not dereferenced). The incomplete type can be completed later in the same scope by redeclaring it:
struct thing {
int num;
}; /* thing struct type is now completed */
Incomplete types are used to implement recursive structures; the body of the type declaration may be deferred to later in the translation unit:
typedef struct Bert Bert;
typedef struct Wilma Wilma;
struct Bert {
Wilma *wilma;
};
struct Wilma {
Bert *bert;
};
Incomplete types are also used for data hiding; the incomplete type is defined in a header file, and the body only within the relevant source file.
Pointers
In declarations the asterisk modifier (*
) specifies a pointer type. For example, where the specifier int
would refer to the integer type, the specifier int*
refers to the type "pointer to integer". Pointer values associate two pieces of information: a memory address and a data type. The following line of code declares a pointer-to-integer variable called ptr:
int *ptr;
Referencing
When a non-static pointer is declared, it has an unspecified value associated with it. The address associated with such a pointer must be changed by assignment prior to using it. In the following example, ptr is set so that it points to the data associated with the variable a:
int a = 0;
int *ptr = &a;
In order to accomplish this, the "address-of" operator (unary &
) is used. It produces the memory location of the data object that follows.
Dereferencing
The pointed-to data can be accessed through a pointer value. In the following example, the integer variable b is set to the value of integer variable a, which is 10:
int a=10;
int *p;
p = &a;
int b = *p;
Zdroj:https://en.wikipedia.org?pojem=C_syntax
Text je dostupný za podmienok Creative Commons Attribution/Share-Alike License 3.0 Unported; prípadne za ďalších podmienok. Podrobnejšie informácie nájdete na stránke Podmienky použitia.
Antropológia
Aplikované vedy
Bibliometria
Dejiny vedy
Encyklopédie
Filozofia vedy
Forenzné vedy
Humanitné vedy
Knižničná veda
Kryogenika
Kryptológia
Kulturológia
Literárna veda
Medzidisciplinárne oblasti
Metódy kvantitatívnej analýzy
Metavedy
Metodika
Text je dostupný za podmienok Creative
Commons Attribution/Share-Alike License 3.0 Unported; prípadne za ďalších
podmienok.
Podrobnejšie informácie nájdete na stránke Podmienky
použitia.
www.astronomia.sk | www.biologia.sk | www.botanika.sk | www.dejiny.sk | www.economy.sk | www.elektrotechnika.sk | www.estetika.sk | www.farmakologia.sk | www.filozofia.sk | Fyzika | www.futurologia.sk | www.genetika.sk | www.chemia.sk | www.lingvistika.sk | www.politologia.sk | www.psychologia.sk | www.sexuologia.sk | www.sociologia.sk | www.veda.sk I www.zoologia.sk