[locale]

# 28 Text processing library [[text]](./#text)

## 28.3 Localization library [[localization]](localization#locale)

### 28.3.3 Locales [[locales]](locales#locale)

#### 28.3.3.1 Class locale [locale]

#### [28.3.3.1.1](#general) General [[locale.general]](locale.general)

namespace std {class locale {public:// [[locale.types]](#types "28.3.3.1.2 Types"), types// [[locale.facet]](#facet "28.3.3.1.2.2 Class locale​::​facet"), class locale​::​facetclass facet; // [[locale.id]](#id "28.3.3.1.2.3 Class locale​::​id"), class locale​::​idclass id; // [[locale.category]](#category "28.3.3.1.2.1 Type locale​::​category"), type locale​::​categoryusing category = int; static const category // values assigned here are for exposition only none = 0,
 collate = 0x010, ctype = 0x020,
 monetary = 0x040, numeric = 0x080,
 time = 0x100, messages = 0x200,
 all = collate | ctype | monetary | numeric | time | messages; // [[locale.cons]](#cons "28.3.3.1.3 Constructors and destructor"), construct/copy/destroy locale() noexcept;
 locale(const locale& other) noexcept; explicit locale(const char* std_name); explicit locale(const string& std_name);
 locale(const locale& other, const char* std_name, category);
 locale(const locale& other, const string& std_name, category); template<class Facet> locale(const locale& other, Facet* f);
 locale(const locale& other, const locale& one, category); ~locale(); // not virtualconst locale& operator=(const locale& other) noexcept; // [[locale.members]](#members "28.3.3.1.4 Members"), locale operationstemplate<class Facet> locale combine(const locale& other) const;
 string name() const;
 text_encoding encoding() const; bool operator==(const locale& other) const; template<class charT, class traits, class Allocator>bool operator()(const basic_string<charT, traits, Allocator>& s1, const basic_string<charT, traits, Allocator>& s2) const; // [[locale.statics]](#statics "28.3.3.1.6 Static members"), global locale objectsstatic locale global(const locale&); static const locale& classic(); };}

[1](#general-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L520)

Class locale implements a type-safe polymorphic set of facets,
indexed by facet *type*[.](#general-1.sentence-1)

In other words, a facet has a dual role:
in one sense, it's just a class interface;
at the same time, it's an index into a locale's set of facets[.](#general-1.sentence-2)

[2](#general-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L527)

Access to the facets of a locale is via two function templates,use_facet<> and has_facet<>[.](#general-2.sentence-1)

[3](#general-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L531)

[*Example [1](#general-example-1)*:

An iostream operator<< can be implemented as:[214](#footnote-214 "Note that in the call to put, the stream is implicitly converted to an ostreambuf_­iterator<charT, traits>.")

template<class charT, class traits> basic_ostream<charT, traits>&operator<< (basic_ostream<charT, traits>& s, Date d) {typename basic_ostream<charT, traits>::sentry cerberos(s); if (cerberos) { tm tmbuf; d.extract(tmbuf); bool failed = use_facet<time_put<charT, ostreambuf_iterator<charT, traits>>>( s.getloc()).put(s, s, s.fill(), &tmbuf, 'x').failed(); if (failed) s.setstate(s.badbit); // can throw}return s;} â *end example*]

[4](#general-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L558)

In the call to use_facet<Facet>(loc),
the type argument chooses a facet,
making available all members of the named type[.](#general-4.sentence-1)

If Facet is not present in a locale,
it throws the standard exception bad_cast[.](#general-4.sentence-2)

A C++ program can check if a locale implements a particular facet
with the function template has_facet<Facet>()[.](#general-4.sentence-3)

User-defined facets may be installed in a locale, and
used identically as may standard facets[.](#general-4.sentence-4)

[5](#general-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L569)

[*Note [1](#general-note-1)*:

All locale semantics are accessed viause_facet<> and has_facet<>,
except that:

- [(5.1)](#general-5.1)

A member operator templateoperator()(const basic_string<C, T, A>&, const basic_string<C, T, A>&) is provided so that a locale can be used as a predicate argument to
the standard collections, to collate strings.

- [(5.2)](#general-5.2)

Convenient global interfaces are provided for
traditional ctype functions such asisdigit() and isspace(),
so that given a locale object loc a C++ program can call isspace(c, loc). (This eases upgrading existing extractors ([[istream.formatted]](istream.formatted "31.7.5.3 Formatted input functions"))[.](#general-5.2.sentence-2))

â *end note*]

[6](#general-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L593)

Once a facet reference is obtained from a locale object
by calling use_facet<>,
that reference remains usable,
and the results from member functions of it may be cached and re-used,
as long as some locale object refers to that facet[.](#general-6.sentence-1)

[7](#general-7)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L600)

In successive calls to a locale facet member function
on a facet object installed in the same locale,
the returned result shall be identical[.](#general-7.sentence-1)

[8](#general-8)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L605)

A locale constructed
from a name string (such as "POSIX"), or
from parts of two named locales, has a name;
all others do not[.](#general-8.sentence-1)

Named locales may be compared for equality;
an unnamed locale is equal only to (copies of) itself[.](#general-8.sentence-2)

For an unnamed locale, locale​::​name() returns the string "*"[.](#general-8.sentence-3)

[9](#general-9)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L614)

Whether there is
one global locale object for the entire program or
one global locale object per thread
is implementation-defined[.](#general-9.sentence-1)

Implementations should provide one global locale object per thread[.](#general-9.sentence-2)

If there is a single global locale object for the entire program,
implementations are not required to
avoid data races on it ([[res.on.data.races]](res.on.data.races "16.4.6.10 Data race avoidance"))[.](#general-9.sentence-3)

[214)](#footnote-214)[214)](#footnoteref-214)

Note that in the call to put,
the stream is implicitly converted
to an ostreambuf_iterator<charT, traits>[.](#footnote-214.sentence-1)

#### [28.3.3.1.2](#types) Types [[locale.types]](locale.types)

#### [28.3.3.1.2.1](#category) Type locale​::​category [[locale.category]](locale.category)

[ð](#lib:locale,category)

`using category = int;
`

[1](#category-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L633)

*Valid* category values
include the locale member bitmask elementscollate,ctype,monetary,numeric,time,
andmessages,
each of which represents a single locale category[.](#category-1.sentence-1)

In addition, locale member bitmask constant none is defined as zero and represents no category[.](#category-1.sentence-2)

And locale member bitmask constant all is defined such that the expression(collate | ctype | monetary | numeric | time | messages | all) == all is true,
and represents the union of all categories[.](#category-1.sentence-3)

Further, the expression (X | Y),
where X and Y each represent a single category,
represents the union of the two categories[.](#category-1.sentence-4)

[2](#category-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L657)

locale member functions
expecting a category argument
require one of the category values defined above, or
the union of two or more such values[.](#category-2.sentence-1)

Such a category value identifies a set of locale categories[.](#category-2.sentence-2)

Each locale category, in turn, identifies a set of locale facets,
including at least those shown in Table [91](#tab:locale.category.facets "Table 91: Locale category facets")[.](#category-2.sentence-3)

Table [91](#tab:locale.category.facets) — Locale category facets [[tab:locale.category.facets]](./tab:locale.category.facets)  

| [ð](#tab:locale.category.facets-row-1)<br>**Category** | **Includes facets** |
| --- | --- |
| [ð](#tab:locale.category.facets-row-2)<br>collate | collate<char>, collate<wchar_t> |
| [ð](#tab:locale.category.facets-row-3)<br>ctype | ctype<char>, ctype<wchar_t> |
| [ð](#tab:locale.category.facets-row-4) | codecvt<char, char, mbstate_t> |
| [ð](#tab:locale.category.facets-row-5) | codecvt<wchar_t, char, mbstate_t> |
| [ð](#tab:locale.category.facets-row-6)<br>monetary | moneypunct<char>, moneypunct<wchar_t> |
| [ð](#tab:locale.category.facets-row-7) | moneypunct<char, true>, moneypunct<wchar_t, true> |
| [ð](#tab:locale.category.facets-row-8) | money_get<char>, money_get<wchar_t> |
| [ð](#tab:locale.category.facets-row-9) | money_put<char>, money_put<wchar_t> |
| [ð](#tab:locale.category.facets-row-10)<br>numeric | numpunct<char>, numpunct<wchar_t> |
| [ð](#tab:locale.category.facets-row-11) | num_get<char>, num_get<wchar_t> |
| [ð](#tab:locale.category.facets-row-12) | num_put<char>, num_put<wchar_t> |
| [ð](#tab:locale.category.facets-row-13)<br>time | time_get<char>, time_get<wchar_t> |
| [ð](#tab:locale.category.facets-row-14) | time_put<char>, time_put<wchar_t> |
| [ð](#tab:locale.category.facets-row-15)<br>messages | messages<char>, messages<wchar_t> |

[3](#category-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L686)

For any locale loc either constructed, or returned by locale​::​classic(),
and any facet Facet shown in Table [91](#tab:locale.category.facets "Table 91: Locale category facets"),has_facet<Facet>(loc) is true[.](#category-3.sentence-1)

Each locale member function
which takes a locale​::​category argument
operates on the corresponding set of facets[.](#category-3.sentence-2)

[4](#category-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L695)

An implementation is required to provide those specializations
for facet templates identified as members of a category, and
for those shown in Table [92](#tab:locale.spec "Table 92: Required specializations")[.](#category-4.sentence-1)

Table [92](#tab:locale.spec) — Required specializations [[tab:locale.spec]](./tab:locale.spec)  

| [ð](#tab:locale.spec-row-1)<br>**Category** | **Includes facets** |
| --- | --- |
| [ð](#tab:locale.spec-row-2)<br>collate | collate_byname<char>, collate_byname<wchar_t> |
| [ð](#tab:locale.spec-row-3)<br>ctype | ctype_byname<char>, ctype_byname<wchar_t> |
| [ð](#tab:locale.spec-row-4) | codecvt_byname<char, char, mbstate_t> |
| [ð](#tab:locale.spec-row-5) | codecvt_byname<wchar_t, char, mbstate_t> |
| [ð](#tab:locale.spec-row-6)<br>monetary | moneypunct_byname<char, International> |
| [ð](#tab:locale.spec-row-7) | moneypunct_byname<wchar_t, International> |
| [ð](#tab:locale.spec-row-8) | money_get<C, InputIterator> |
| [ð](#tab:locale.spec-row-9) | money_put<C, OutputIterator> |
| [ð](#tab:locale.spec-row-10)<br>numeric | numpunct_byname<char>, numpunct_byname<wchar_t> |
| [ð](#tab:locale.spec-row-11) | num_get<C, InputIterator>, num_put<C, OutputIterator> |
| [ð](#tab:locale.spec-row-12)<br>time | time_get<char, InputIterator> |
| [ð](#tab:locale.spec-row-13) | time_get_byname<char, InputIterator> |
| [ð](#tab:locale.spec-row-14) | time_get<wchar_t, InputIterator> |
| [ð](#tab:locale.spec-row-15) | time_get_byname<wchar_t, InputIterator> |
| [ð](#tab:locale.spec-row-16) | time_put<char, OutputIterator> |
| [ð](#tab:locale.spec-row-17) | time_put_byname<char, OutputIterator> |
| [ð](#tab:locale.spec-row-18) | time_put<wchar_t, OutputIterator> |
| [ð](#tab:locale.spec-row-19) | time_put_byname<wchar_t, OutputIterator> |
| [ð](#tab:locale.spec-row-20)<br>messages | messages_byname<char>, messages_byname<wchar_t> |

[5](#category-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L726)

The provided implementation of members of
facets num_get<charT> and num_put<charT> calls use_facet<F>(l) only for facet F of
types numpunct<charT> and ctype<charT>,
and for locale l the value obtained by calling member getloc() on the ios_base& argument to these functions[.](#category-5.sentence-1)

[6](#category-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L734)

In declarations of facets,
a template parameter with name InputIterator or OutputIterator indicates the set of all possible specializations on parameters that meet the*Cpp17InputIterator* requirements or*Cpp17OutputIterator* requirements,
respectively ([[iterator.requirements]](iterator.requirements "24.3 Iterator requirements"))[.](#category-6.sentence-1)

A template parameter with name C represents
the set of types containing char, wchar_t, and any otherimplementation-defined
character container types ([[defns.character.container]](defns.character.container "3.10 character container type"))
that meet the requirements for a character
on which any of the iostream components can be instantiated[.](#category-6.sentence-2)

A template parameter with name International represents the set of all possible specializations on a bool parameter[.](#category-6.sentence-3)

#### [28.3.3.1.2.2](#facet) Class locale​::​facet [[locale.facet]](locale.facet)

[ð](#lib:locale,facet)

namespace std {class locale::facet {protected:explicit facet(size_t refs = 0); virtual ~facet();
 facet(const facet&) = delete; void operator=(const facet&) = delete; };}

[1](#facet-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L766)

Class facet is the base class for locale feature sets[.](#facet-1.sentence-1)

A class is a [*facet*](#def:facet "28.3.3.1.2.2 Class locale​::​facet [locale.facet]") if it is publicly derived from another facet, or
if it is a class derived from locale​::​facet and
contains a publicly accessible declaration as follows:[215](#footnote-215 "This is a complete list of requirements; there are no other requirements. Thus, a facet class need not have a public copy constructor, assignment, default constructor, destructor, etc.")static ::std::locale::id id;

[2](#facet-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L781)

Template parameters in this Clause
which are required to be facets
are those named Facet in declarations[.](#facet-2.sentence-1)

A program that passes
a type that is *not* a facet, or
a type that refers to a volatile-qualified facet,
as an (explicit or deduced) template parameter to
a locale function expecting a facet,
is ill-formed[.](#facet-2.sentence-2)

A const-qualified facet is a valid template argument to
any locale function that expects a Facet template parameter[.](#facet-2.sentence-3)

[3](#facet-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L794)

The refs argument to the constructor is used for lifetime management[.](#facet-3.sentence-1)

For refs == 0,
the implementation performs delete static_cast<locale​::​facet*>(f) (where f is a pointer to the facet)
when the last locale object containing the facet is destroyed;
for refs == 1, the implementation never destroys the facet[.](#facet-3.sentence-2)

[4](#facet-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L802)

Constructors of all facets defined in this Clause
take such an argument and pass it along to
their facet base class constructor[.](#facet-4.sentence-1)

All one-argument constructors defined in this Clause are explicit,
preventing their participation in implicit conversions[.](#facet-4.sentence-2)

[5](#facet-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L809)

For some standard facets a standard â…_bynameâ class,
derived from it, implements the virtual function semantics
equivalent to that facet of the locale
constructed by locale(const char*) with the same name[.](#facet-5.sentence-1)

Each such facet provides a constructor that takes
a const char* argument, which names the locale, and
a refs argument, which is passed to the base class constructor[.](#facet-5.sentence-2)

Each such facet also provides a constructor that takes
a string argument str and
a refs argument,
which has the same effect as calling the first constructor
with the two arguments str.c_str() and refs[.](#facet-5.sentence-3)

If there is no â…_bynameâ version of a facet,
the base class implements named locale semantics itself
by reference to other facets[.](#facet-5.sentence-4)

[215)](#footnote-215)[215)](#footnoteref-215)

This is a complete list of requirements; there are no other requirements[.](#footnote-215.sentence-1)

Thus, a facet class need not have a public
copy constructor, assignment, default constructor, destructor, etc[.](#footnote-215.sentence-2)

#### [28.3.3.1.2.3](#id) Class locale​::​id [[locale.id]](locale.id)

[ð](#lib:locale,id)

namespace std {class locale::id {public: id(); void operator=(const id&) = delete;
 id(const id&) = delete; };}

[1](#id-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L840)

The class locale​::​id provides
identification of a locale facet interface,
used as an index for lookup and to encapsulate initialization[.](#id-1.sentence-1)

[2](#id-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L845)

[*Note [1](#id-note-1)*:

Because facets are used by iostreams,
potentially while static constructors are running,
their initialization cannot depend on programmed static initialization[.](#id-2.sentence-1)

One initialization strategy is for locale to initialize each facet's id member
the first time an instance of the facet is installed into a locale[.](#id-2.sentence-2)

This depends only on static storage being zero
before constructors run ([[basic.start.static]](basic.start.static "6.10.3.2 Static initialization"))[.](#id-2.sentence-3)

â *end note*]

#### [28.3.3.1.3](#cons) Constructors and destructor [[locale.cons]](locale.cons)

[ð](#lib:locale,constructor)

`locale() noexcept;
`

[1](#cons-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L865)

*Effects*: Constructs a copy of the argument last passed tolocale​::​global(locale&),
if it has been called;
else, the resulting facets have virtual function semantics identical to
those of locale​::​classic()[.](#cons-1.sentence-1)

[*Note [1](#cons-note-1)*:

This constructor yields a copy of the current global locale[.](#cons-1.sentence-2)

It is commonly used as a default argument for
function parameters of type const locale&[.](#cons-1.sentence-3)

â *end note*]

[ð](#lib:locale,constructor_)

`explicit locale(const char* std_name);
`

[2](#cons-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L885)

*Effects*: Constructs a locale using standard C locale names, e.g., "POSIX"[.](#cons-2.sentence-1)

The resulting locale implements semantics defined to be associated
with that name[.](#cons-2.sentence-2)

[3](#cons-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L891)

*Throws*: runtime_error if the argument is not valid, or is null[.](#cons-3.sentence-1)

[4](#cons-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L895)

*Remarks*: The set of valid string argument values is"C", "", and any implementation-defined values[.](#cons-4.sentence-1)

[ð](#lib:locale,constructor__)

`explicit locale(const string& std_name);
`

[5](#cons-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L907)

*Effects*: Equivalent to locale(std_name.c_str())[.](#cons-5.sentence-1)

[ð](#lib:locale,constructor___)

`locale(const locale& other, const char* std_name, category cats);
`

[6](#cons-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L918)

*Preconditions*: cats is a valid category value ([[locale.category]](#category "28.3.3.1.2.1 Type locale​::​category"))[.](#cons-6.sentence-1)

[7](#cons-7)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L922)

*Effects*: Constructs a locale as a copy of other except for the facets identified by the category argument,
which instead implement the same semantics as locale(std_name)[.](#cons-7.sentence-1)

[8](#cons-8)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L928)

*Throws*: runtime_error if the second argument is not valid, or is null[.](#cons-8.sentence-1)

[9](#cons-9)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L932)

*Remarks*: The locale has a name if and only if other has a name[.](#cons-9.sentence-1)

[ð](#lib:locale,constructor____)

`locale(const locale& other, const string& std_name, category cats);
`

[10](#cons-10)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L943)

*Effects*: Equivalent to locale(other, std_name.c_str(), cats)[.](#cons-10.sentence-1)

[ð](#lib:locale,constructor_____)

`template<class Facet> locale(const locale& other, Facet* f);
`

[11](#cons-11)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L954)

*Effects*: Constructs a locale incorporating all facets from the first argument
except that of type Facet,
and installs the second argument as the remaining facet[.](#cons-11.sentence-1)

If f is null, the resulting object is a copy of other[.](#cons-11.sentence-2)

[12](#cons-12)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L961)

*Remarks*: If f is null,
the resulting locale has the same name as other[.](#cons-12.sentence-1)

Otherwise, the resulting locale has no name[.](#cons-12.sentence-2)

[ð](#lib:locale,constructor______)

`locale(const locale& other, const locale& one, category cats);
`

[13](#cons-13)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L974)

*Preconditions*: cats is a valid category value[.](#cons-13.sentence-1)

[14](#cons-14)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L978)

*Effects*: Constructs a locale incorporating all facets from the first argument
except those that implement cats,
which are instead incorporated from the second argument[.](#cons-14.sentence-1)

[15](#cons-15)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L984)

*Remarks*: If cats is equal to locale​::​none,
the resulting locale has a name if and only if the first argument has a name[.](#cons-15.sentence-1)

Otherwise, the resulting locale has a name if and only if
the first two arguments both have names[.](#cons-15.sentence-2)

[ð](#lib:operator=,locale)

`const locale& operator=(const locale& other) noexcept;
`

[16](#cons-16)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L998)

*Effects*: Creates a copy of other, replacing the current value[.](#cons-16.sentence-1)

[17](#cons-17)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1002)

*Returns*: *this[.](#cons-17.sentence-1)

#### [28.3.3.1.4](#members) Members [[locale.members]](locale.members)

[ð](#lib:locale,combine)

`template<class Facet> locale combine(const locale& other) const;
`

[1](#members-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1015)

*Effects*: Constructs a locale incorporating all facets from *this except for that one facet of other that is identified by Facet[.](#members-1.sentence-1)

[2](#members-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1020)

*Returns*: The newly created locale[.](#members-2.sentence-1)

[3](#members-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1024)

*Throws*: runtime_error if has_facet<Facet>(other) is false[.](#members-3.sentence-1)

[4](#members-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1028)

*Remarks*: The resulting locale has no name[.](#members-4.sentence-1)

[ð](#lib:locale,name)

`string name() const;
`

[5](#members-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1039)

*Returns*: The name of *this, if it has one;
otherwise, the string "*"[.](#members-5.sentence-1)

[ð](#lib:locale,encoding)

`text_encoding encoding() const;
`

[6](#members-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1051)

*Mandates*: CHAR_BIT == 8 is true[.](#members-6.sentence-1)

[7](#members-7)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1055)

*Returns*: A text_encoding object representing
the implementation-defined encoding scheme
associated with the locale *this[.](#members-7.sentence-1)

#### [28.3.3.1.5](#operators) Operators [[locale.operators]](locale.operators)

[ð](#lib:locale,operator==)

`bool operator==(const locale& other) const;
`

[1](#operators-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1070)

*Returns*: true if
both arguments are the same locale, or
one is a copy of the other, or
each has a name and the names are identical;false otherwise[.](#operators-1.sentence-1)

[ð](#lib:locale,operator())

`template<class charT, class traits, class Allocator>
  bool operator()(const basic_string<charT, traits, Allocator>& s1,
                  const basic_string<charT, traits, Allocator>& s2) const;
`

[2](#operators-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1087)

*Effects*: Compares two strings according to the std​::​collate<charT> facet[.](#operators-2.sentence-1)

[3](#operators-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1091)

*Returns*: use_facet<std::collate<charT>>(*this).compare(s1.data(), s1.data() + s1.size(),
 s2.data(), s2.data() + s2.size()) < 0

[4](#operators-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1098)

*Remarks*: This member operator template (and therefore locale itself)
meets the requirements for
a comparator predicate template argument ([[algorithms]](algorithms "26 Algorithms library")) applied to strings[.](#operators-4.sentence-1)

[5](#operators-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1104)

[*Example [1](#operators-example-1)*:

A vector of strings v can be collated according to collation rules in locale loc simply by ([[alg.sort]](alg.sort "26.8.2 Sorting"), [[vector]](vector "23.3.13 Class template vector")):

std::sort(v.begin(), v.end(), loc); â *end example*]

#### [28.3.3.1.6](#statics) Static members [[locale.statics]](locale.statics)

[ð](#lib:locale,global)

`static locale global(const locale& loc);
`

[1](#statics-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1124)

*Effects*: Sets the global locale to its argument[.](#statics-1.sentence-1)

Causes future calls to the constructor locale() to return a copy of the argument[.](#statics-1.sentence-2)

If the argument has a name, doessetlocale(LC_ALL, loc.name().c_str()); otherwise, the effect on the C locale, if any, isimplementation-defined[.](#statics-1.sentence-3)

[2](#statics-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1136)

*Returns*: The previous value of locale()[.](#statics-2.sentence-1)

[3](#statics-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1140)

*Remarks*: No library function other than locale​::​global() affects the value returned by locale()[.](#statics-3.sentence-1)

[*Note [1](#statics-note-1)*:

See [[c.locales]](c.locales "28.3.5 C library locales") for data race considerations
when setlocale is invoked[.](#statics-3.sentence-2)

â *end note*]

[ð](#lib:locale,classic)

`static const locale& classic();
`

[4](#statics-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1156)

The "C" locale[.](#statics-4.sentence-1)

[5](#statics-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1159)

*Returns*: A locale that implements the classic "C" locale semantics,
equivalent to the value locale("C")[.](#statics-5.sentence-1)

[6](#statics-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/text.tex#L1164)

*Remarks*: This locale, its facets, and their member functions, do not change with time[.](#statics-6.sentence-1)
