View source for C string handling

{{other uses|C string (disambiguation)}}
{{Short description|Handling of strings in the C programming language}}
{{Use dmy dates|date=July 2020}}
{{C Standard Library}}

The [[C (programming language)|C programming language]] has a set of functions implementing operations on [[String (computer science)|strings]] (character strings and byte strings) in its [[C standard library|standard library]]. Various operations, such as copying, [[concatenation]], [[Tokenization (lexical analysis)|tokenization]] and searching are supported. For character strings, the standard library uses the convention that strings are [[null-terminated string|null-terminated]]: a string of {{mvar|n}} characters is represented as an [[array (data structure)|array]] of {{math|''n'' + 1}} elements, the last of which is a "{{tt|NUL}} character" with numeric value 0.

The only support for strings in the programming language proper is that the compiler translates quoted [[string literal|string constant]]s into null-terminated strings.

==Definitions==
A string is defined as a contiguous sequence of [[code unit]]s terminated by the first zero code unit (often called the ''NUL'' code unit).<ref name="open-std1" /> 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.<ref name="open-std1" /> 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 <code>char</code>, which is exactly 8 bits on all modern machines. [[C90 (C version)|C90]] defines ''wide strings''<ref name="open-std1">{{cite web |title=The C99 standard draft + TC3 |url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf |access-date=7 January 2011 |location=§7.1.1p1 }}</ref> which use a code unit of type <code>wchar_t</code>, 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 <code>char *</code> and <code>wchar_t *</code> are different types, the functions that process wide strings are different than the ones processing normal strings and have different names.

[[String literal]]s (<code>"text"</code> in the C source code) are converted to arrays during compilation.<ref>{{cite web |title=The C99 standard draft + TC3 |url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf |access-date=7 January 2011 |location=§6.4.5p7 }}</ref> The result is an array of code units containing all the characters plus a trailing zero code unit. In C90 <code>L"text"</code> produces a wide string. A string literal can contain the zero code unit (one way is to put <code>\0</code> 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.<ref>{{cite web |title=The C99 standard draft + TC3 |url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf |access-date=7 January 2011 |location=Section 6.4.5 footnote 66}}</ref>

==Character encodings==
Each string ends at the first occurrence of the zero code unit of the appropriate kind (<code>char</code> or <code>wchar_t</code>). Consequently, a byte string ({{code|char*}}) can contain non-[[Null character|NUL]] characters in [[ASCII]] or any [[Extended ASCII|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 <code>wchar_t</code>. In most implementations, <code>wchar_t</code> is at least 16 bits, and so all 16-bit encodings, such as [[UCS-2]], can be stored. If <code>wchar_t</code> 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++.)<ref>{{cite web|url=https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2460r2.pdf|title=Relax requirements on wchar_t to match existing practices}}</ref> C++11 and [[C11 (C standard revision)|C11]] add two types with explicit widths {{code|char16_t}} and {{code|char32_t}}.<ref>{{cite web |title=Fundamental types |url=https://en.cppreference.com/w/cpp/language/types |website=en.cppreference.com}}</ref>

[[Variable-width encoding]]s can be used in both byte strings and wide strings. String length and offsets are measured in bytes or <code>wchar_t</code>, 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 <code>wchar_t</code> is 16 bits. Truncating strings with variable-width characters using functions like <code>strncpy</code> 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|lang=c|1=char foo[512] = "φωωβαρ";}} (UTF-8) or {{Code|lang=c|1=wchar_t foo[512] = L"φωωβαρ";}} (UTF-16 or UTF-32, depends on {{code|wchar_t}}) is implementation defined,<ref name="open-std">{{cite web |title=The C99 standard draft + TC3 |url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf |access-date=23 December 2011 |location=§5.1.1.2 ''Translation phases'', p1 }}</ref> and may require that the source code be in the same encoding, especially for {{code|char}} where compilers might just copy whatever is between the quotes. Some compilers or editors will require entering all non-ASCII characters as <code>\xNN</code> sequences for each byte of UTF-8, and/or <code>\uNNNN</code> for each word of UTF-16. Since C11 (and C++11), a new literal prefix {{Code|lang=c|1=u8}} is available that guarantees UTF-8 for a bytestring literal, as in {{Code|lang=c|1=char foo[512] = u8"φωωβαρ";}}.<ref>{{cite web |title=string literals |url=https://en.cppreference.com/w/c/language/string_literal |website=en.cppreference.com |access-date=23 December 2019}}</ref> Since [[C++20]] and [[C23 (C standard revision)|C23]], a <code>char8_t</code> type was added that is meant to store UTF-8 characters and the types of u8 prefixed character and string literals were changed to <code>char8_t</code> and <code>char8_t[]</code> respectively.

==Features==

===Terminology===
In historical documentation the term "character" was often used instead of "byte" for C strings, which leads many{{who|date=January 2017}} 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 <code>mem</code>, as opposite to the <code>str</code> prefix.

===Headers===
Most of the functions that operate on C strings are declared in the <code>string.h</code> header (<code>cstring</code> in C++), while functions that operate on C wide strings are declared in the <code>wchar.h</code> header (<code>cwchar</code> 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 <code>string.h</code> 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 overflow]]s 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 <code>const</code> string pointer and returning a non-<code>const</code> pointer within the string. To correct this, some have been separated into two [[Function overloading|overloaded functions]] in the C++ version of the standard library.

===Constants and types===
{| class="wikitable"
|-
! Name !! Notes
|-
|{{mono|NULL}} || 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|wchar_t}}{{mono|wchar_t}} || Type used for a [[code unit]] in "wide" strings. On [[Windows]], the only platform to use {{mono|wchar_t}} extensively, it's defined as 16-bit<ref>{{Cite web |title=c++ - What is the use of wchar_t in general programming? |url=https://stackoverflow.com/questions/13509733/what-is-the-use-of-wchar-t-in-general-programming |access-date=2022-08-01 |website=Stack Overflow |language=en}}</ref> 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|wchar_t}} be wide enough to hold the widest character set among the supported system [[C localization functions|locales]]<ref>{{cite web |url=https://pubs.opengroup.org/onlinepubs/007908775/xsh/stddef.h.html |title=stddef.h - standard type definitions |publisher=The Open Group |access-date=2017-01-28 }}</ref> and be greater or equal in size to {{mono|char}},<ref>{{cite book |title=Unicode Demystified: A Practical Programmer's Guide to the Encoding Standard |first=Richard |last=Gillam |url=https://books.google.com/books?id=wn5sXG8bEAcC&pg=PA714 |page=714 |publisher=Addison-Wesley Professional |year=2003|isbn=9780201700527 }}</ref>
|-
|{{anchor|wint_t}}{{mono|wint_t}} || 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|char8_t}}{{mono|char8_t}}<ref>{{Cite web |title=char, wchar_t, char8_t, char16_t, char32_t |url=https://docs.microsoft.com/en-us/cpp/cpp/char-wchar-t-char16-t-char32-t |access-date=2022-08-01 |website=docs.microsoft.com |language=en-us}}</ref>
|| Part of the C standard since C23, in {{mono|<uchar.h>}}, a type that is suitable for storing UTF-8 characters.<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/char8_t|title=char8_t}}</ref>
|-
| {{anchor|char16_t}}{{mono|char16_t}}<ref name="uchar">{{Cite web|title =&lt;cuchar&gt; (uchar.h)|url=https://cplusplus.com/reference/cuchar/|language=en-us}}</ref>
|| Part of the C standard since [[C11 (C standard revision)|C11]],<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/char16_t|title=char16_t}}</ref> in {{mono|<uchar.h>}}, a type capable of holding 16 bits even if {{mono|wchar_t}} is another size. If the macro <code>__STDC_UTF_16__</code> is defined as ''1'', the type is used for UTF-16 on that system. This is always the case in C23.<ref name="utfchar">{{cite web|url=https://en.cppreference.com/w/c/preprocessor/replace#Predefined_macros|title=Replacing text macros}}</ref> C++ does not define such a macro, but the type is always used for UTF-16 in that language.<ref name="cppchar16/32t">{{cite web|url=https://en.cppreference.com/w/cpp/language/types#Character_types|title=Fundamental types}}</ref>
|-
| {{anchor|char32_t}}{{mono|char32_t}}<ref name="uchar" />
|| Part of the C standard since C11,<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/char32_t|title=char32_t}}</ref> in {{mono|<uchar.h>}}, a type capable of holding 32 bits even if {{mono|wchar_t}} is another size. If the macro <code>__STDC_UTF_32__</code> is defined as ''1'', the type is used for UTF-32 on that system. This is always the case in C23.<ref name="utfchar" /> C++ does not define such a macro, but the type is always used for UTF-32 in that language.<ref name="cppchar16/32t" />
|-
|{{anchor|mbstate_t}}{{mono|mbstate_t}} || Contains all the information about the conversion state required from one call to a function to the other.
|}

===Functions===
{| class="wikitable"
|-
!
! Byte<br />string
! Wide<br />string
! Description<ref group="note">For wide string functions substitute {{mono|wchar_t}} for "byte" in the description</ref>
|-
! rowspan=5 | String<br />manipulation
| {{anchor|strcpy}}{{mono|strcpy}}<ref name=strcpy-cppreference>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strcpy |title=strcpy - cppreference.com |publisher=En.cppreference.com |date=2014-01-02 |access-date=2014-03-06}}</ref>
| {{anchor|wcscpy}}{{mono|wcscpy}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcscpy |title=wcscpy - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Copies one string to another
|-
| {{anchor|strncpy}}{{mono|strncpy}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strncpy |title=strncpy - cppreference.com |publisher=En.cppreference.com |date=2013-10-04 |access-date=2014-03-06}}</ref>
| {{anchor|wcsncpy}}{{mono|wcsncpy}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcsncpy |title=wcsncpy - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Writes exactly {{mvar|n}} bytes, copying from source or adding nulls
|-
| {{anchor|strcat}}{{mono|strcat}}<ref name=strcat-cppreference>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strcat |title=strcat - cppreference.com |publisher=En.cppreference.com |date=2013-10-08 |access-date=2014-03-06}}</ref>
| {{anchor|wcscat}}{{mono|wcscat}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcscat |title=wcscat - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Appends one string to another
|-
| {{anchor|strncat}}{{mono|strncat}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strncat |title=strncat - cppreference.com |publisher=En.cppreference.com |date=2013-07-01 |access-date=2014-03-06}}</ref>
| {{anchor|wcsncat}}{{mono|wcsncat}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcsncat |title=wcsncat - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Appends no more than {{mvar|n}} bytes from one string to another
|-
| {{anchor|strxfrm}}{{mono|strxfrm}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strxfrm |title=strxfrm - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| {{anchor|wcsxfrm}}{{mono|wcsxfrm}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcsxfrm |title=wcsxfrm - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Transforms a string according to the current locale
|-
! rowspan=11 | String<br /> examination
| {{anchor|strlen}}{{mono|strlen}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strlen |title=strlen - cppreference.com |publisher=En.cppreference.com |date=2013-12-27 |access-date=2014-03-06}}</ref>
| {{anchor|wcslen}}{{mono|wcslen}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcslen |title=wcslen - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Returns the length of the string
|-
| {{anchor|strcmp}}{{mono|strcmp}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strcmp |title=strcmp - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| {{anchor|wcscmp}}{{mono|wcscmp}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcscmp |title=wcscmp - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Compares two strings ([[three-way comparison]])
|-
| {{anchor|strncmp}}{{mono|strncmp}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strncmp |title=strncmp - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| {{anchor|wcsncmp}}{{mono|wcsncmp}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcsncmp |title=wcsncmp - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Compares a specific number of bytes in two strings
|-
| {{anchor|strcoll}}{{mono|strcoll}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strcoll |title=strcoll - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| {{anchor|wcscoll}}{{mono|wcscoll}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcscoll |title=wcscoll - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Compares two strings according to the current locale
|-
| {{anchor|strchr}}{{mono|strchr}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strchr |title=strchr - cppreference.com |publisher=En.cppreference.com |date=2014-02-23 |access-date=2014-03-06}}</ref>
| {{anchor|wcschr}}{{mono|wcschr}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcschr |title=wcschr - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Finds the first occurrence of a byte in a string
|-
| {{anchor|strrchr}}{{mono|strrchr}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strrchr |title=strrchr - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| {{anchor|wcsrchr}}{{mono|wcsrchr}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcsrchr |title=wcsrchr - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Finds the last occurrence of a byte in a string
|-
| {{anchor|strspn}}{{mono|strspn}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strspn |title=strspn - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| {{anchor|wcsspn}}{{mono|wcsspn}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcsspn |title=wcsspn - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Returns the number of initial bytes in a string that are in a second string
|-
| {{anchor|strcspn}}{{mono|strcspn}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strcspn |title=strcspn - cppreference.com |publisher=En.cppreference.com |date=2013-05-31 |access-date=2014-03-06}}</ref>
| {{anchor|wcscspn}}{{mono|wcscspn}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcscspn |title=wcscspn - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Returns the number of initial bytes in a string that are not in a second string
|-
| {{anchor|strpbrk}}{{mono|strpbrk}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strpbrk |title=strpbrk - cppreference.com |publisher=En.cppreference.com |date=2013-05-31 |access-date=2014-03-06}}</ref>
| {{anchor|wcspbrk}}{{mono|wcspbrk}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcspbrk |title=wcspbrk - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Finds in a string the first occurrence of a byte in a set
|-
| {{anchor|strstr}}{{mono|strstr}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strstr |title=strstr - cppreference.com |publisher=En.cppreference.com |date=2013-10-16 |access-date=2014-03-06}}</ref>
| {{anchor|wcsstr}}{{mono|wcsstr}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcsstr |title=wcsstr - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Finds the first occurrence of a substring in a string
|-
| {{anchor|strtok}}{{mono|strtok}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strtok |title=strtok - cppreference.com |publisher=En.cppreference.com |date=2013-09-03 |access-date=2014-03-06}}</ref>
| {{anchor|wcstok}}{{mono|wcstok}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcstok |title=wcstok - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Splits a string into tokens
|-
! Miscellaneous
| {{anchor|strerror}}{{mono|strerror}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strerror |title=strerror - cppreference.com |publisher=En.cppreference.com |date=2013-05-31 |access-date=2014-03-06}}</ref>
| {{n/a}}
| Returns a string containing a message derived from an [[errno.h|error code]]
|-
! rowspan=5 | Memory<br />manipulation
|{{anchor|memset}}{{mono|memset}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/memset |title=memset - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
|{{anchor|wmemset}}{{mono|wmemset}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wmemset |title=wmemset - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Fills a buffer with a repeated byte.  Since [[C23 (C standard revision)|C23]], {{mono|memset_explicit()}} was added to erase sensitive data.
|-
|{{anchor|memcpy}}{{mono|memcpy}}<ref name=memcpy-cppreference>{{cite web|url=https://en.cppreference.com/w/c/string/byte/memcpy |title=memcpy - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
|{{anchor|wmemcpy}}{{mono|wmemcpy}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wmemcpy |title=wmemcpy - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Copies one buffer to another.  Since [[C23 (C standard revision)|C23]], {{mono|memccpy()}} was added to efficiently concatenate strings.
|-
|{{anchor|memmove}}{{mono|memmove}}<ref name=memmove-cppreference>{{cite web|url=https://en.cppreference.com/w/c/string/byte/memmove |title=memmove - cppreference.com |publisher=En.cppreference.com |date=2014-01-25 |access-date=2014-03-06}}</ref>
|{{anchor|wmemmove}}{{mono|wmemmove}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wmemmove |title=wmemmove - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Copies one buffer to another, possibly overlapping, buffer
|-
|{{anchor|memcmp}}{{mono|memcmp}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/memcmp |title=memcmp - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
|{{anchor|wmemcmp}}{{mono|wmemcmp}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wmemcmp |title=wmemcmp - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Compares two buffers (three-way comparison)
|-
|{{anchor|memchr}}{{mono|memchr}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/memchr |title=memchr - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
|{{anchor|wmemchr}}{{mono|wmemchr}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wmemchr |title=wmemchr - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Finds the first occurrence of a byte in a buffer
|-
| colspan=4 |<references group="note"/>
|}

====Multibyte functions====
{| class="wikitable" style="margin-right: 1.5em;"
|-
! Name
! Description
|-
| {{anchor|mblen}}{{mono|mblen}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mblen |title=mblen - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Returns the number of bytes in the next multibyte character
|-
| {{anchor|mbtowc}}{{mono|mbtowc}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mbtowc |title=mbtowc - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Converts the next multibyte character to a wide character
|-
| {{anchor|wctomb}}{{mono|wctomb}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/wctomb |title=wctomb - cppreference.com |publisher=En.cppreference.com |date=2014-02-04 |access-date=2014-03-06}}</ref>
| Converts a wide character to its multibyte representation
|-
| {{anchor|mbstowcs}}{{mono|mbstowcs}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mbstowcs |title=mbstowcs - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Converts a multibyte string to a wide string
|-
| {{anchor|wcstombs}}{{mono|wcstombs}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/wcstombs |title=wcstombs - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Converts a wide string to a multibyte string
|-
| {{anchor|btowc}}{{mono|btowc}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/btowc |title=btowc - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Converts a single-byte character to wide character, if possible
|-
| {{anchor|wctob}}{{mono|wctob}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/wctob |title=wctob - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Converts a wide character to a single-byte character, if possible
|-
| {{anchor|mbsinit}}{{mono|mbsinit}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mbsinit |title=mbsinit - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Checks if a state object represents initial state
|-
| {{anchor|mbrlen}}{{mono|mbrlen}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mbrlen |title=mbrlen - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Returns the number of bytes in the next multibyte character, given state
|-
| {{anchor|mbrtowc}}{{mono|mbrtowc}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mbrtowc |title=mbrtowc - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Converts the next multibyte character to a wide character, given state
|-
| {{anchor|wcrtomb}}{{mono|wcrtomb}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/wcrtomb |title=wcrtomb - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Converts a wide character to its multibyte representation, given state
|-
| {{anchor|mbsrtowcs}}{{mono|mbsrtowcs}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mbsrtowcs |title=mbsrtowcs - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Converts a multibyte string to a wide string, given state
|-
| {{anchor|wcsrtombs}}{{mono|wcsrtombs}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/wcsrtombs |title=wcsrtombs - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| Converts a wide string to a multibyte string, given state
|-
| {{anchor|mbrtoc8}}{{mono|mbrtoc8}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mbrtoc8 |title=mbrtoc8 - cppreference.com |publisher=En.cppreference.com}}</ref>
| Converts the next multibyte character to a UTF-8 character, given state
|-
| {{anchor|c8rtomb}}{{mono|c8rtomb}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/c8rtomb|title=c8rtomb - cppreference.com |publisher=En.cppreference.com}}</ref>
| Converts a single code point from UTF-8 to a narrow multibyte character representation, given state
|-
| {{anchor|mbrtoc16}}{{mono|mbrtoc16}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mbrtoc16 |title=mbrtoc16 - cppreference.com |publisher=En.cppreference.com}}</ref>
| Converts the next multibyte character to a UTF-16 character, given state
|-
| {{anchor|c16rtomb}}{{mono|c16rtomb}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/c16rtomb|title=c16rtomb - cppreference.com |publisher=En.cppreference.com}}</ref>
| Converts a single code point from UTF-16 to a narrow multibyte character representation, given state
|-
| {{anchor|mbrtoc32}}{{mono|mbrtoc32}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/mbrtoc32 |title=mbrtoc32 - cppreference.com |publisher=En.cppreference.com}}</ref>
| Converts the next multibyte character to a UTF-32 character, given state
|-
| {{anchor|c32rtomb}}{{mono|c32rtomb}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/multibyte/c32rtomb|title=c23rtomb - cppreference.com |publisher=En.cppreference.com}}</ref>
| Converts a single code point from UTF-32 to a narrow multibyte character representation, given state
|}

These functions all need a {{samp|mbstate_t}} 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|mb}} encodings, but modern ones such as UTF-8 do not need this. However these functions were designed on the assumption that the {{samp|wc}} encoding is not a [[variable-width encoding]] and thus are designed to deal with exactly one {{samp|wchar_t}} at a time, passing it by value rather than using a string pointer. As UTF-16 is a variable-width encoding, the {{samp|mbstate_t}} has been reused to keep track of surrogate pairs in the wide encoding, though the caller must still detect and call {{samp|mbtowc}} twice for a single character.<ref>{{cite web |url=https://www.gnu.org/software/libc/manual/html_node/Keeping-the-state.html |title=6.3.2 Representing the state of the conversion |access-date=2017-01-31 | website=The GNU C Library}}</ref><ref>{{cite web |url=https://git.musl-libc.org/cgit/musl/tree/src/multibyte/c16rtomb.c |title=root/src/multibyte/c16rtomb.c |access-date=2017-01-31 }}</ref><ref>{{cite web |url=https://svnweb.freebsd.org/base/stable/11/lib/libc/locale/c16rtomb.c?view=markup |title=Contents of /stable/11/lib/libc/locale/c16rtomb.c |access-date=2017-01-31 }}</ref> 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.

{{Clear}}

==={{anchor|stdlib.h}}Numeric conversions===
{| class="wikitable" style="margin-right: 1.5em;"
|-
! Byte<br />string
! Wide<br />string
! Description<ref group="note">Here ''string'' refers either to byte string or wide string</ref>
|-
| {{anchor|atof}}{{mono|atof}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/atof |title=atof - cppreference.com |publisher=En.cppreference.com |date=2013-05-31 |access-date=2014-03-06}}</ref>
| {{n/a}}
| converts a string to a floating-point value ('atof' means 'ASCII to float')
|-
| {{anchor|atoi|atol|atoll}}{{mono|atoi}}<br />{{mono|atol}}<br />{{mono|atoll}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/atoi |title=atoi, atol, atoll - cppreference.com |publisher=En.cppreference.com |date=2014-01-18 |access-date=2014-03-06}}</ref>
| {{n/a}}
| converts a string to an integer ([[C99]]) ('atoi' means 'ASCII to integer')
|-
| {{anchor|strtof|strtod|strtold}}{{mono|strtof}} ([[C99]])<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strtof |title=strtof, strtod, strtold - cppreference.com |publisher=En.cppreference.com |date=2014-02-04 |access-date=2014-03-06}}</ref><br />{{mono|strtod}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strtod |title=strtof, strtod, strtold - cppreference.com |publisher=En.cppreference.com |date=2014-02-04 |access-date=2014-03-06}}</ref><br />{{mono|strtold}} ([[C99]])<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strtold |title=strtof, strtod, strtold - cppreference.com |publisher=En.cppreference.com |date=2014-02-04 |access-date=2014-03-06}}</ref>
| {{anchor|wcstof|wcstod|wcstold}}{{mono|wcstof}} ([[C99]])<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcstof |title=wcstof, wcstod, wcstold - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref><br />{{mono|wcstod}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcstod |title=wcstof, wcstod, wcstold - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref><br />{{mono|wcstold}} ([[C99]])<ref>{{cite web|url=http://en.cppreference.com/w/c/string/wide/wcstold |title=wcstof, wcstod, wcstold - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| converts a string to a floating-point value
|-
| {{anchor|strtol|strtoll}}{{mono|strtol}}<br />{{mono|strtoll}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strtol |title=strtol, strtoll - cppreference.com |publisher=En.cppreference.com |date=2014-02-04 |access-date=2014-03-06}}</ref>
| {{anchor|wcstol|wcstoll}}{{mono|wcstol}}<br />{{mono|wcstoll}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcstol |title=wcstol, wcstoll - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| converts a string to a signed integer
|-
| {{anchor|strtoul|strtoull}}{{mono|strtoul}}<br />{{mono|strtoull}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/byte/strtoul |title=strtoul, strtoull - cppreference.com |publisher=En.cppreference.com |date=2014-02-04 |access-date=2014-03-06}}</ref>
| {{anchor|wcstoul|wcstoull}}{{mono|wcstoul}}<br />{{mono|wcstoull}}<ref>{{cite web|url=https://en.cppreference.com/w/c/string/wide/wcstoul |title=wcstoul, wcstoull - cppreference.com |publisher=En.cppreference.com |access-date=2014-03-06}}</ref>
| converts a string to an unsigned integer
|-
| colspan=3 |<references group="note"/>
|}

The C standard library contains several functions for numeric conversions. The functions that deal with byte strings are defined in the {{code|stdlib.h}} header ({{code|cstdlib}} header in C++). The functions that deal with wide strings are defined in the {{code|wchar.h}} header ({{code|cwchar}} header in C++).

The functions {{code|strchr}}, {{code|bsearch}}, {{code|strpbrk}}, {{code|strrchr}}, {{code|strstr}}, {{code|memchr}} and their wide counterparts are not [[const-correctness|const-correct]], since they accept a {{code|const}} string pointer and return a non-{{code|const}} pointer within the string. This has been fixed in [[C23 (C standard revision)|C23]].<ref name=N3020>{{cite web |title=WG14-N3020 : Qualifier-preserving standard library functions, v4 |url=https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3020.pdf |website=open-std.org |date=2022-06-13}}</ref>

Also, since the Normative Amendment 1 (C95), {{code|atoxx}} functions are considered subsumed by {{code|strtoxxx}} functions, for which reason neither C95 nor any later standard provides wide-character versions of these functions. The argument against {{code|atoxx}} is that they do not differentiate between an error and a {{code|0}}.<ref>[http://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf C99 Rationale, 7.20.1.1]</ref>{{clear}}

==Popular extensions==
{| class="wikitable"
|-
! Name !! Source !! Description
|-
| {{anchor|bzero}}{{mono|bzero}}<ref>{{cite web|url=http://pubs.opengroup.org/onlinepubs/009695399/functions/bzero.html |title=bzero |publisher=[[The Open Group]] |access-date=2017-11-27}}</ref><ref name="explicit_bzero">{{cite web|url=https://man.openbsd.org/explicit_bzero.3 |title=bzero(3) |publisher=[[OpenBSD]] |access-date=2017-11-27}}</ref>
|| [[BSD]] 
|| Fills a buffer with zero bytes, deprecated by {{mono|memset}}
|-
| {{anchor|memccpy}}{{mono|memccpy}}<ref>{{cite web|url=http://pubs.opengroup.org/onlinepubs/009695399/functions/memccpy.html |title=memccpy |publisher=Pubs.opengroup.org |access-date=2014-03-06}}</ref> 
|| [[System V Interface Definition|SVID]]
|| Part of the C standard since [[C23 (C standard revision)|C23]], copies between two non-overlapping memory areas, stopping when a given byte is found.
|-
| {{anchor|mempcpy}}{{mono|mempcpy}}<ref>{{cite web|url=https://www.kernel.org/doc/man-pages/online/pages/man3/mempcpy.3.html |title=mempcpy(3) - Linux manual page |publisher=Kernel.org |access-date=2014-03-06}}</ref> 
|| GNU 
|| a variant of [[#memcpy|{{mono|memcpy}}]] returning a pointer to the byte following the last written byte
|-
| {{anchor|strcasecmp}}{{mono|strcasecmp}}<ref>{{cite web|url=https://www.kernel.org/doc/man-pages/online/pages/man3/strcasecmp.3.html |title=strcasecmp(3) - Linux manual page |publisher=Kernel.org |access-date=2014-03-06}}</ref> 
|| BSD
|| case-insensitive version of {{mono|strcmp}}
|-
| {{anchor|strcat_s}}{{mono|strcat_s}}<ref name=strcat_s>{{cite web|url=https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/strcat-s-wcscat-s-mbscat-s?view=msvc-170 |title=strcat_s, wcscat_s, _mbscat_s |publisher=docs.microsoft.com |access-date=2022-04-22}}</ref> 
|| Windows 
|| a variant of [[#strcat|{{mono|strcat}}]] that checks the destination buffer size before copying
|-
| {{anchor|strcpy_s}}{{mono|strcpy_s}}<ref name=strcpy_s>{{cite web|url=https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/strcpy-s-wcscpy-s-mbscpy-s?view=msvc-170 |title=strcpy_s, wcscpy_s, _mbscpy_s, _mbscpy_s_l |publisher=docs.microsoft.com |access-date=2022-04-22}}</ref> 
|| Windows 
|| a variant of [[#strcpy|{{mono|strcpy}}]] that checks the destination buffer size before copying
|-
| {{anchor|strdup}}{{mono|strdup}} & {{mono|strndup}}<ref>{{cite web|url=http://pubs.opengroup.org/onlinepubs/009695399/functions/strdup.html |title=strdup |publisher=Pubs.opengroup.org |access-date=2014-03-06}}</ref> 
|| [[POSIX]]
|| Part of the C standard since C23, allocates and duplicates a string
|-
| {{anchor|strerror_r}}{{mono|strerror_r}}<ref>{{cite web|url=http://man7.org/linux/man-pages/man3/strerror.3.html |title=strerror(3) - Linux manual page |publisher=man7.org |access-date=2019-11-03}}</ref> 
|| POSIX&nbsp;1,&nbsp;GNU 
|| a variant of [[#strerror|{{mono|strerror}}]] that is thread-safe. The GNU version is incompatible with the POSIX one.
|-
| {{anchor|stricmp}}{{mono|stricmp}}<ref>{{cite web|url=http://www.cprogrammingexpert.com/C/Tutorial/strings/stricmp.aspx |title=String &#124; stricmp() |publisher=C Programming Expert.com |access-date=2014-03-06}}</ref> 
|| Windows
|| case-insensitive version of {{mono|strcmp}}
|-
| {{anchor|strlcpy}}{{mono|strlcpy}}<ref name="strlcat_strlcpy">{{cite web|url=https://man.openbsd.org/OpenBSD-5.9/man3/strlcat.3 |title= strlcpy, strlcat — size-bounded string copying and concatenation |publisher=[[OpenBSD]] |access-date=2016-05-26}}</ref> 
|| BSD
|| a variant of [[#strcpy|{{mono|strcpy}}]] that truncates the result to fit in the destination buffer<ref name="strl">{{cite web | url=https://www.millert.dev/papers/strlcpy | title=strlcpy and strlcat – consistent, safe, string copy and concatenation. | author=Todd C. Miller |author2=Theo de Raadt | year=1999 | publisher=USENIX '99 }}</ref>
|-
| {{anchor|strlcat}}{{mono|strlcat}}<ref name="strlcat_strlcpy" /> 
|| BSD
|| a variant of [[#strcat|{{mono|strcat}}]] that truncates the result to fit in the destination buffer<ref name="strl" />
|-
| {{anchor|strsignal}}{{mono|strsignal}}<ref>{{cite web|url=https://pubs.opengroup.org/onlinepubs/9699919799/functions/strsignal.html |title=strsignal |publisher=Pubs.opengroup.org |access-date=2014-03-06}}</ref> 
|| [[POSIX|POSIX:2008]] 
|| returns string representation of a [[Signal (computing)|signal code]]. Not thread safe.
|-
| {{anchor|strtok_r}}{{mono|strtok_r}}<ref>{{cite web|url=https://pubs.opengroup.org/onlinepubs/009695399/functions/strtok.html |title=strtok |publisher=Pubs.opengroup.org |access-date=2014-03-06}}</ref> 
|| POSIX 
|| a variant of [[#strtok|{{mono|strtok}}]] that is thread-safe
|}

==Replacements==

Despite [[C standard library#Buffer overflow vulnerabilities|the well-established need]] to replace <code>strcat</code><ref name=strcat-cppreference/> and <code>strcpy</code><ref name=strcpy-cppreference/> 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 <code>strncat</code> and <code>strncpy</code> 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.<ref name="strl" />

The most popular{{Efn|On GitHub, there are 7,813,206 uses of <code>strlcpy</code>, versus 38,644 uses of <code>strcpy_s</code> (and 15,286,150 uses of <code>strcpy</code>).{{Citation needed|date=February 2015}}}} replacement are the <code>strlcat</code><ref>{{cite web|url=http://bxr.su/OpenBSD/lib/libc/string/strlcpy.c |title= strlcpy.c |author=Todd C. Miller |website=BSD Cross Reference}}</ref> and <code>strlcpy</code><ref>{{cite web|url=http://bxr.su/OpenBSD/lib/libc/string/strlcat.c |title= strlcat.c |author=Todd C. Miller |website=BSD Cross Reference}}</ref> functions, which appeared in [[OpenBSD]] 2.4 in December, 1998.<ref name="strl" /> 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. For a long time they have not been included in the [[GNU C library]] (used by software on Linux), on the basis of allegedly being inefficient,<ref>{{cite web |url=https://www.openbsd.org/papers/portability.pdf |title=Secure Portability |first1=Damien |last1=Miller |date=October 2005|access-date=26 June 2016 |quote=This [strlcpy and strlcat] API has been adopted by most modern operating systems and many standalone software packages [...]. The notable exception is the GNU standard C library, glibc, whose maintainer steadfastly refuses to include these improved APIs, labelling them "horribly inefficient BSD crap", despite prior evidence that they are faster is most cases than the APIs they replace.}}</ref> encouraging the use of C strings (instead of some superior alternative form of string),<ref name="libc-alpha-discussion-1">[http://sources.redhat.com/ml/libc-alpha/ libc-alpha mailing list] {{Webarchive|url=https://web.archive.org/web/20070609043450/http://sources.redhat.com/ml/libc-alpha/ |date=9 June 2007 }}, selected messages from 8 August 2000 thread: [https://www.sourceware.org/ml/libc-alpha/2000-08/msg00053.html 53], [https://www.sourceware.org/ml/libc-alpha/2000-08/msg00060.html 60], [https://www.sourceware.org/ml/libc-alpha/2000-08/msg00061.html 61]</ref><ref>[https://lwn.net/Articles/507319/ The ups and downs of strlcpy(); LWN.net]</ref> and hiding other potential errors.<ref>{{cite web |title=Adding strlcpy() to glibc |url=https://lwn.net/Articles/612244/ |website=lwn.net |quote=Correct string handling means that you always know how long your strings are and therefore you can you memcpy (instead of strcpy).}}</ref><ref>{{man|3|strlcpy|ManKier}}  "However, one may question the validity of such optimizations, as they defeat the whole purpose of strlcpy() and strlcat(). As a matter of fact, the first version of this manual page got it wrong."</ref> 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 (operating system)|Solaris]], [[OS X]], and [[QNX]], as well as in alternative C libraries for Linux, such as [https://en.wikibooks.org/wiki/C%20Programming/C%20Reference/nonstandard/strlcpy libbsd], introduced in 2008,<ref>{{Cite web |url=https://libbsd.freedesktop.org/ |title=libbsd |access-date=2022-11-21}}</ref> and [[musl]], introduced in 2011,<ref>{{cite web |url=https://git.musl-libc.org/cgit/musl/tree/src/string/strlcpy.c |title=root/src/string/strlcpy.c |access-date=2017-01-28 }}</ref><ref>{{cite web |url=https://git.musl-libc.org/cgit/musl/tree/src/string/strlcat.c |title=root/src/string/strlcat.c |access-date=2017-01-28 }}</ref> and the source code added directly to other projects such as [[Simple_DirectMedia_Layer|SDL]], [[GLib]], [[FFmpeg|ffmpeg]], [[rsync]], and even internally in the [[Linux kernel]]. This did change in 2024, the [https://sourceware.org/glibc/wiki/FAQ#Why_no_strlcpy_.2F_strlcat.3F glibc FAQ] notes that as of glibc 2.38, the code has been committed <ref>[https://sourceware.org/git/?p=glibc.git;a=commit;h=454a20c8756c9c1d55419153255fc7692b3d2199 strlc{py|at} commit]</ref> and thereby added.<ref>https://news.ycombinator.com/item?id=36765747 {{Bare URL inline|date=August 2024}}</ref> These functions were standardized as part of POSIX.1-2024,<ref>{{cite web|url=https://pubs.opengroup.org/onlinepubs/9799919799/functions/strlcat.html |title=strlcat |publisher=Pubs.opengroup.org |access-date=2024-09-05}}</ref> the Austin Group Defect Tracker [https://www.austingroupbugs.net/view.php?id=986 ID 986] tracked some discussion about such plans for POSIX.

Sometimes <code>memcpy</code><ref name=memcpy-cppreference/> or <code>memmove</code><ref name=memmove-cppreference/> are used, as they may be more efficient than <code>strcpy</code> 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 [[Microsoft Security Development Lifecycle|Security Development Lifecycle]], Microsoft introduced a family of "secure" functions including <code>strcpy_s</code> and <code>strcat_s</code> (along with many others).<ref>{{cite web|last1=Lovell|first1=Martyn|title=Repel Attacks on Your Code with the Visual Studio 2005 Safe C and C++ Libraries|url=https://msdn.microsoft.com/en-us/magazine/cc163794.aspx|access-date=13 February 2015}}</ref> These functions were standardized with some minor changes as part of the optional [[C11 (C standard revision)|C11 (Annex K)]] proposed by ISO/IEC WDTR 24731.<ref>{{cite web |url=http://safeclib.sourceforge.net/ |title=The Safe C Library provides bound checking memory and string functions per ISO/IEC TR24731 |author=Safe C Library |publisher=Sourceforge | access-date=6 March 2013 }}</ref> 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,<ref>{{cite web |title=The C11 standard draft |url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1548.pdf |access-date=13 February 2013 |location=§K.3.1.4p2}}</ref> which usually aborts the program.<ref>{{cite web |title=The C11 standard draft |url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1548.pdf |access-date=13 February 2013 |location=§K.3.6.1.1p4}}</ref><ref>{{cite web|title=Parameter Validation|date=21 October 2022 |url=https://msdn.microsoft.com/en-us/library/ksazx244.aspx}}</ref> 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.<ref>{{cite web |url=http://www.informit.com/blogs/blog.aspx?uk=Theyre-at-it-again |title=They're at it again |author=Danny Kalev |publisher=InformIT |access-date=10 November 2011 |archive-url=https://web.archive.org/web/20120115011928/http://www.informit.com/blogs/blog.aspx?uk=Theyre-at-it-again |archive-date=15 January 2012 |url-status=dead }}</ref> 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.<ref>{{cite web |title=Field Experience With Annex K — Bounds Checking Interfaces |url=http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1967.htm |access-date=5 November 2015}}</ref> Usage of {{code|memset_s}} has been suggested as a way to avoid unwanted compiler optimizations.<ref>{{cite web |title=MSC06-C. Beware of compiler optimizations |url=https://wiki.sei.cmu.edu/confluence/display/c/MSC06-C.+Beware+of+compiler+optimizations |website=SEI CERT C Coding Standard}}</ref><ref>{{man|3|memset_s|FreeBSD}}</ref>

==See also==
* {{Section link|C syntax|Strings}}{{snd}} source code syntax, including backslash escape sequences
* [[String functions]]
* [[Perl Compatible Regular Expressions]] (PCRE)

==Notes==
{{Notelist}}

==References==
{{Reflist|30em}}

==External links==
{{wikibooks|C Programming|Strings|C Programming/Strings}}
* [http://www.danielvik.com/2010/02/fast-memcpy-in-c.html Fast memcpy in C], multiple C coding examples to target different types of CPU instruction architectures

{{CProLang|state=expanded}}

[[Category:C (programming language)|String handling]]
[[Category:C standard library|String handling]]
[[Category:String (computer science)]]