# Strings library

> C++ Atlas: `cppatlas.com/w/cpp/string` | Source: https://en.cppreference.com/w/cpp/string | Domain: Strings | Standards: C++11, C++17, C++20, C++26

In the C++ standard library, a character is an object which, when treated sequentially, can represent text.

## Official Specification Summary (cppreference)

### Characters

In the C++ standard library, a *character* is an object which, when treated sequentially, can represent text.

The term means not only objects of character types, but also any value that can be represented by a type that provides the definitions specified in the strings library and following libraries:

- localization library
- input/output library

(since C++11):

- regular expressions library

In the strings library and regular expressions library (since C++11), a character can be of only *char-like types*, i.e. those non-array types that satisfy the requirements of *PODType* (until C++20) *TrivialType* and *StandardLayoutType* (since C++20) (until C++26) *TriviallyCopyable* and *StandardLayoutType* (since C++26).

For any char-like type `T`, `std::is_trivially_default_constructible_v<T>` is `true`. (since C++26)

Therefore, characters are also referred as *char-like objects* in the strings library and regular expressions library (since C++11).

Some standard library components accept *character container types*. They, too, are types used to represent individual characters. Such types are used for one of the template arguments of `std::char_traits` and the class templates which use `std::char_traits`.

### Library components

The C++ strings library includes the following components:

#### Character traits

Many character-related class templates (such as `std::basic_string`) need a set of related types and functions to complete the definition of their semantics. These types and functions are provided as a set of member `typedef` names and functions in the template parameter `Traits` used by each such template. The classes which are able to complete those semantics are *CharTraits*.

The string library provides the class template `std::char_traits` that defines types and functions for `std::basic_string` and `std::basic_string_view` (since C++17).

The following specializations are defined, all of them satisfy the *CharTraits* requirements:

```cpp
// Defined in header <string>
template<> class char_traits<char>;
template<> class char_traits<wchar_t>;
template<> class char_traits<char8_t>; // (since C++20)
template<> class char_traits<char16_t>; // (since C++11)
template<> class char_traits<char32_t>; // (since C++11)
```

When a user-defined character container type for `std::basic_string` and `std::basic_string_view` (since C++17) is used, it is also necessary to provide a corresponding character trait class (which can be a specialization of `std::char_traits`).

#### String classes (`std::string` etc.)

The class template `std::basic_string` generalizes how sequences of characters are manipulated and stored. String creation, manipulation, and destruction are all handled by a convenient set of class methods and related functions.

Several specializations of `std::basic_string` are provided for commonly-used types:

Defined in header `<string>`

**Type — Definition**

- `std::string`: `std::basic_string<char>`
- `std::wstring`: `std::basic_string<wchar_t>`
- `std::u8string` (since C++20): `std::basic_string<char8_t>`
- `std::u16string` (since C++11): `std::basic_string<char16_t>`
- `std::u32string` (since C++11): `std::basic_string<char32_t>`

#### String view classes (`std::string_view` etc.) (since C++17)

The class template `std::basic_string_view` provides a lightweight object that offers read-only access to a string or a part of a string using an interface similar to the interface of `std::basic_string`.

Several specializations of `std::basic_string_view` are provided for commonly-used types:

Defined in header `<string_view>`

**Type — Definition**

- `std::string_view`: `std::basic_string_view<char>`
- `std::wstring_view`: `std::basic_string_view<wchar_t>`
- `std::u8string_view` (since C++20): `std::basic_string_view<char8_t>`
- `std::u16string_view`: `std::basic_string_view<char16_t>`
- `std::u32string_view`: `std::basic_string_view<char32_t>`

### Relevant libraries

The text processing library provides support for localizations, string conversions (e.g. `std::toupper`), character classification functions (e.g. `std::isspace`), and text encoding recognition (`std::text_encoding`).

### Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

| DR | Applied to | Behavior as published | Correct behavior |
| --- | --- | --- | --- |
| LWG 1170 | C++98 | char-like types could be array types | prohibited |

### See also

- [C documentation for Strings library](https://en.cppreference.com/w/c/string)

---
Attribution: content from https://en.cppreference.com/w/cpp/string (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.