Английская Википедия:C string handling

Содержание

Текст

Текст

Текст

Текст

Текст

Текст

Текст

Текст

Текст

The C programming language has a set of functions implementing operations on strings (character strings and byte strings) in its standard library. Various operations, such as copying, concatenation, tokenization and searching are supported. For character strings, the standard library uses the convention that strings are null-terminated: a string of Шаблон:Mvar characters is represented as an array of Шаблон:Math elements, the last of which is a "Шаблон:Tt character" with numeric value 0.

The only support for strings in the programming language proper is that the compiler translates quoted string constants into null-terminated strings.

Definitions

A string is defined as a contiguous sequence of code units terminated by the first zero code unit (often called the NUL code unit). This means a string cannot contain the zero code unit, as the first one seen marks the end of the string. The length of a string is the number of code units before the zero code unit. The memory occupied by a string is always one more code unit than the length, as space is needed to store the zero terminator.

Generally, the term string means a string where the code unit is of type char, which is exactly 8 bits on all modern machines. C90 defines wide strings which use a code unit of type wchar_t, which is 16 or 32 bits on modern machines. This was intended for Unicode but it is increasingly common to use UTF-8 in normal strings for Unicode instead.

Strings are passed to functions by passing a pointer to the first code unit. Since char* and wchar_t* are different types, the functions that process wide strings are different than the ones processing normal strings and have different names.

String literals ("text" in the C source code) are converted to arrays during compilation. The result is an array of code units containing all the characters plus a trailing zero code unit. In C90 L"text" produces a wide string. A string literal can contain the zero code unit (one way is to put \0 into the source), but this will cause the string to end at that point. The rest of the literal will be placed in memory (with another zero code unit added to the end) but it is impossible to know those code units were translated from the string literal, therefore such source code is not a string literal.

Character encodings

Each string ends at the first occurrence of the zero code unit of the appropriate kind (char or wchar_t). Consequently, a byte string (Шаблон:Code) can contain non-NUL characters in ASCII or any ASCII extension, but not characters in encodings such as UTF-16 (even though a 16-bit code unit might be nonzero, its high or low byte might be zero). The encodings that can be stored in wide strings are defined by the width of wchar_t. In most implementations, wchar_t is at least 16 bits, and so all 16-bit encodings, such as UCS-2, can be stored. If wchar_t is 32-bits, then 32-bit encodings, such as UTF-32, can be stored. (The standard requires a "type that holds any wide character", which on Windows no longer holds true since the UCS-2 to UTF-16 shift. This was recognized as a defect in the standard and fixed in C++.) C++11 and C11 add two types with explicit widths Шаблон:Code and Шаблон:Code.

Variable-width encodings can be used in both byte strings and wide strings. String length and offsets are measured in bytes or wchar_t, not in "characters", which can be confusing to beginning programmers. UTF-8 and Shift JIS are often used in C byte strings, while UTF-16 is often used in C wide strings when wchar_t is 16 bits. Truncating strings with variable-width characters using functions like strncpy can produce invalid sequences at the end of the string. This can be unsafe if the truncated parts are interpreted by code that assumes the input is valid.

Support for Unicode literals such as Шаблон:Code (UTF-8) or Шаблон:Code (UTF-16 or UTF-32, depends on Шаблон:Code) is implementation defined, and may require that the source code be in the same encoding, especially for Шаблон:Code where compilers might just copy whatever is between the quotes. Some compilers or editors will require entering all non-ASCII characters as \xNN sequences for each byte of UTF-8, and/or \uNNNN for each word of UTF-16. Since C11 (and C++11), a new literal prefix Шаблон:Code is available that guarantees UTF-8 for a bytestring literal, as in Шаблон:Code. Since C++20 and C23, a char8_t type was added that is meant to store UTF-8 characters and the types of u8 prefixed character and string literals were changed to char8_t and char8_t[] respectively.

Features

Terminology

In historical documentation the term "character" was often used instead of "byte" for C strings, which leads manyШаблон:Who to believe that these functions somehow do not work for UTF-8. In fact all lengths are defined as being in bytes and this is true in all implementations, and these functions work as well with UTF-8 as with single-byte encodings. The BSD documentation has been fixed to make this clear, but POSIX, Linux, and Windows documentation still uses "character" in many places where "byte" or "wchar_t" is the correct term.

Functions for handling memory buffers can process sequences of bytes that include null-byte as part of the data. Names of these functions typically start with mem, as opposite to the str prefix.

Headers

Most of the functions that operate on C strings are declared in the string.h header (cstring in C++), while functions that operate on C wide strings are declared in the wchar.h header (cwchar in C++). These headers also contain declarations of functions used for handling memory buffers; the name is thus something of a misnomer.

Functions declared in string.h are extremely popular since, as a part of the C standard library, they are guaranteed to work on any platform which supports C. However, some security issues exist with these functions, such as potential buffer overflows when not used carefully and properly, causing the programmers to prefer safer and possibly less portable variants, out of which some popular ones are listed below. Some of these functions also violate const-correctness by accepting a const string pointer and returning a non-const pointer within the string. To correct this, some have been separated into two overloaded functions in the C++ version of the standard library.

Constants and types

Name	Notes
Шаблон:Mono	Macro expanding to the null pointer constant; that is, a constant representing a pointer value which is guaranteed not to be a valid address of an object in memory.
Шаблон:AnchorШаблон:Mono	Type used for a code unit in "wide" strings. On Windows, the only platform to use Шаблон:Mono extensively, it's defined as 16-bit which was enough to represent any Unicode (UCS-2) character, but is now only enough to represent a UTF-16 code unit, which can be half a code point. On other platforms it is defined as 32-bit and a Unicode code point always fits. The C standard only requires that Шаблон:Mono be wide enough to hold the widest character set among the supported system locales and be greater or equal in size to Шаблон:Mono,
Шаблон:AnchorШаблон:Mono	Integer type that can hold any value of a wchar_t as well as the value of the macro WEOF. This type is unchanged by integral promotions. Usually a 32 bit signed value.
Шаблон:AnchorШаблон:Mono	Part of the C standard since C23, in Шаблон:Mono, a type that is suitable for storing UTF-8 characters.
Шаблон:AnchorШаблон:Mono	Part of the C standard since C11, in Шаблон:Mono, a type capable of holding 16 bits even if Шаблон:Mono is another size. If the macro __STDC_UTF_16__ is defined as 1, the type is used for UTF-16 on that system. This is always the case in C23. C++ does not define such a macro, but the type is always used for UTF-16 in that language.
Шаблон:AnchorШаблон:Mono	Part of the C standard since C11, in Шаблон:Mono, a type capable of holding 32 bits even if Шаблон:Mono is another size. If the macro __STDC_UTF_32__ is defined as 1, the type is used for UTF-32 on that system. This is always the case in C23. C++ does not define such a macro, but the type is always used for UTF-32 in that language.
Шаблон:AnchorШаблон:Mono	Contains all the information about the conversion state required from one call to a function to the other.

Functions

	Byte string	Wide string	Description
String manipulation	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Copies one string to another
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Writes exactly Шаблон:Mvar bytes, copying from source or adding nulls
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Appends one string to another
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Appends no more than Шаблон:Mvar bytes from one string to another
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Transforms a string according to the current locale
String examination	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Returns the length of the string
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Compares two strings (three-way comparison)
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Compares a specific number of bytes in two strings
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Compares two strings according to the current locale
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Finds the first occurrence of a byte in a string
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Finds the last occurrence of a byte in a string
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Returns the number of initial bytes in a string that are in a second string
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Returns the number of initial bytes in a string that are not in a second string
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Finds in a string the first occurrence of a byte in a set
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Finds the first occurrence of a substring in a string
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Splits a string into tokens
Miscellaneous	Шаблон:AnchorШаблон:Mono	Шаблон:N/a	Returns a string containing a message derived from an error code
Memory manipulation	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Fills a buffer with a repeated byte. Since C23, Шаблон:Mono was added to erase sensitive data.
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Copies one buffer to another. Since C23, Шаблон:Mono was added to efficiently concatenate strings.
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Copies one buffer to another, possibly overlapping, buffer
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Compares two buffers (three-way comparison)
	Шаблон:AnchorШаблон:Mono	Шаблон:AnchorШаблон:Mono	Finds the first occurrence of a byte in a buffer

Multibyte functions

Name	Description
Шаблон:AnchorШаблон:Mono	Returns the number of bytes in the next multibyte character
Шаблон:AnchorШаблон:Mono	Converts the next multibyte character to a wide character
Шаблон:AnchorШаблон:Mono	Converts a wide character to its multibyte representation
Шаблон:AnchorШаблон:Mono	Converts a multibyte string to a wide string
Шаблон:AnchorШаблон:Mono	Converts a wide string to a multibyte string
Шаблон:AnchorШаблон:Mono	Converts a single-byte character to wide character, if possible
Шаблон:AnchorШаблон:Mono	Converts a wide character to a single-byte character, if possible
Шаблон:AnchorШаблон:Mono	Checks if a state object represents initial state
Шаблон:AnchorШаблон:Mono	Returns the number of bytes in the next multibyte character, given state
Шаблон:AnchorШаблон:Mono	Converts the next multibyte character to a wide character, given state
Шаблон:AnchorШаблон:Mono	Converts a wide character to its multibyte representation, given state
Шаблон:AnchorШаблон:Mono	Converts a multibyte string to a wide string, given state
Шаблон:AnchorШаблон:Mono	Converts a wide string to a multibyte string, given state
Шаблон:AnchorШаблон:Mono	Converts the next multibyte character to a UTF-8 character, given state
Шаблон:AnchorШаблон:Mono	Converts a single code point from UTF-8 to a narrow multibyte character representation, given state
Шаблон:AnchorШаблон:Mono	Converts the next multibyte character to a UTF-16 character, given state
Шаблон:AnchorШаблон:Mono	Converts a single code point from UTF-16 to a narrow multibyte character representation, given state
Шаблон:AnchorШаблон:Mono	Converts the next multibyte character to a UTF-32 character, given state
Шаблон:AnchorШаблон:Mono	Converts a single code point from UTF-32 to a narrow multibyte character representation, given state

These functions all need a Шаблон:Samp object, originally in static memory (making the functions not be thread-safe) and in later additions the caller must maintain. This was originally intended to track shift states in the Шаблон:Samp encodings, but modern ones such as UTF-8 do not need this. However these functions were designed on the assumption that the Шаблон:Samp encoding is not a variable-width encoding and thus are designed to deal with exactly one Шаблон:Samp at a time, passing it by value rather than using a string pointer. As UTF-16 is a variable-width encoding, the Шаблон:Samp has been reused to keep track of surrogate pairs in the wide encoding, though the caller must still detect and call Шаблон:Samp twice for a single character. Later additions to the standard admit that the only conversion programmers are interested in is between UTF-8 and UTF-16 and directly provide this.

Шаблон:AnchorNumeric conversions

Byte string	Wide string	Description
Шаблон:AnchorШаблон:Mono	Шаблон:N/a	converts a string to a floating-point value ('atof' means 'ASCII to float')
Шаблон:AnchorШаблон:Mono Шаблон:Mono Шаблон:Mono	Шаблон:N/a	converts a string to an integer (C99) ('atoi' means 'ASCII to integer')
Шаблон:AnchorШаблон:Mono (C99) Шаблон:Mono Шаблон:Mono (C99)	Шаблон:AnchorШаблон:Mono (C99) Шаблон:Mono Шаблон:Mono (C99)	converts a string to a floating-point value
Шаблон:AnchorШаблон:Mono Шаблон:Mono	Шаблон:AnchorШаблон:Mono Шаблон:Mono	converts a string to a signed integer
Шаблон:AnchorШаблон:Mono Шаблон:Mono	Шаблон:AnchorШаблон:Mono Шаблон:Mono	converts a string to an unsigned integer

The C standard library contains several functions for numeric conversions. The functions that deal with byte strings are defined in the Шаблон:Code header (Шаблон:Code header in C++). The functions that deal with wide strings are defined in the Шаблон:Code header (Шаблон:Code header in C++).

The functions Шаблон:Code, Шаблон:Code, Шаблон:Code, Шаблон:Code, Шаблон:Code, Шаблон:Code and their wide counterparts are not const-correct, since they accept a Шаблон:Code string pointer and return a non-Шаблон:Code pointer within the string. This has been fixed in C23.

Also, since the Normative Amendment 1 (C95), Шаблон:Code functions are considered subsumed by Шаблон:Code functions, for which reason neither C95 nor any later standard provides wide-character versions of these functions. The argument against Шаблон:Code is that they do not differentiate between an error and a Шаблон:Code.

Popular extensions

Name	Platform	Description
Шаблон:AnchorШаблон:Mono	POSIX, BSD	Fills a buffer with zero bytes, deprecated by Шаблон:Mono
Шаблон:AnchorШаблон:Mono	SVID, POSIX	Part of the C standard since C23, copies between two non-overlapping memory areas, stopping when a given byte is found.
Шаблон:AnchorШаблон:Mono	GNU	a variant of [[#memcpy|Шаблон:Mono]] returning a pointer to the byte following the last written byte
Шаблон:AnchorШаблон:Mono	POSIX, BSD	case-insensitive versions of Шаблон:Mono
Шаблон:AnchorШаблон:Mono	Windows	a variant of [[#strcat|Шаблон:Mono]] that checks the destination buffer size before copying
Шаблон:AnchorШаблон:Mono	Windows	a variant of [[#strcpy|Шаблон:Mono]] that checks the destination buffer size before copying
Шаблон:AnchorШаблон:Mono & Шаблон:Mono	POSIX	Part of the C standard since C23, allocates and duplicates a string
Шаблон:AnchorШаблон:Mono	POSIX 1, GNU	a variant of [[#strerror|Шаблон:Mono]] that is thread-safe. The GNU version is incompatible with the POSIX one.
Шаблон:AnchorШаблон:Mono	Windows	case-insensitive versions of Шаблон:Mono
Шаблон:AnchorШаблон:Mono	BSD, Solaris	a variant of [[#strcpy|Шаблон:Mono]] that truncates the result to fit in the destination buffer
Шаблон:AnchorШаблон:Mono	BSD, Solaris	a variant of [[#strcat|Шаблон:Mono]] that truncates the result to fit in the destination buffer
Шаблон:AnchorШаблон:Mono	POSIX:2008	returns string representation of a signal code. Not thread safe.
Шаблон:AnchorШаблон:Mono	POSIX	a variant of [[#strtok|Шаблон:Mono]] that is thread-safe

Replacements

Despite the well-established need to replace strcat and strcpy with functions that do not allow buffer overflows, no accepted standard has arisen. This is partly due to the mistaken belief by many C programmers that strncat and strncpy have the desired behavior; however, neither function was designed for this (they were intended to manipulate null-padded fixed-size string buffers, a data format less commonly used in modern software), and the behavior and arguments are non-intuitive and often written incorrectly even by expert programmers.

The most popularШаблон:Efn replacement are the strlcat and strlcpy functions, which appeared in OpenBSD 2.4 in December, 1998. These functions always write one NUL to the destination buffer, truncating the result if necessary, and return the size of buffer that would be needed, which allows detection of the truncation and provides a size for creating a new buffer that will not truncate. They have been criticized on the basis of allegedly being inefficient, encouraging the use of C strings (instead of some superior alternative form of string), and hiding other potential errors. Consequently, for years, they have not been included in the GNU C library (used by software on Linux), although that did get changed. The glibc Wiki FAQ about strlc{py|at} inclusion notes that as of glibc 2.3.8, the code has been committed and thereby added . The glibc 2.38 availability announcement cited the functions "are expected to be added to a future POSIX version." (The Austin Group Defect Tracker, ID 986 tracked some discussion about such plans for POSIX.) Even while glibc hadn't added support, strlcat and strlcpy have been implemented in a number of other C libraries including ones for OpenBSD, FreeBSD, NetBSD, Solaris, OS X, and QNX, as well as in alternative C libraries for Linux, such as libbsd, introduced in 2008, and musl, introduced in 2011. The lack of GNU C library support had not stopped various software authors from using it and bundling a replacement, among other SDL, GLib, ffmpeg, rsync, and even internally in the Linux kernel. Open source implementations for these functions are available.

Sometimes memcpy or memmove are used, as they may be more efficient than strcpy as they do not repeatedly check for NUL (this is less true on modern processors). Since they need a buffer length as a parameter, correct setting of this parameter can avoid buffer overflows.

As part of its 2004 Security Development Lifecycle, Microsoft introduced a family of "secure" functions including strcpy_s and strcat_s (along with many others). These functions were standardized with some minor changes as part of the optional C11 (Annex K) proposed by ISO/IEC WDTR 24731. These functions perform various checks including whether the string is too long to fit in the buffer. If the checks fail, a user-specified "runtime-constraint handler" function is called, which usually aborts the program. Some functions perform destructive operations before calling the runtime-constraint handler; for example, strcat_s sets the destination to the empty string, which can make it difficult to recover from error conditions or debug them. These functions attracted considerable criticism because initially they were implemented only on Windows and at the same time warning messages started to be produced by Microsoft Visual C++ suggesting use of these functions instead of standard ones. This has been speculated by some to be an attempt by Microsoft to lock developers into its platform. Although open-source implementations of these functions are available, these functions are not present in common Unix C libraries. Experience with these functions has shown significant problems with their adoption and errors in usage, so the removal of Annex K is proposed for the next revision of the C standard. Usage of Шаблон:Code has also been suggested as a way to avoid unwanted compiler optimizations.

See also

• Шаблон:Section linkШаблон:Snd source code syntax, including backslash escape sequences
• String functions
• Perl Compatible Regular Expressions (PCRE)

External links

• Fast memcpy in C, multiple C coding examples to target different types of CPU instruction architectures