landinstellingenklasse

De klasse die een landinstellingsobject beschrijft dat cultuurspecifieke informatie inkapselt als een set facetten die gezamenlijk een specifieke gelokaliseerde omgeving definiëren.

Syntaxis

class locale;

Opmerkingen

Een facet is een aanwijzer naar een object van een klasse die is afgeleid van klasse-facet die een openbaar object van het formulier heeft:

static locale::id id;

U kunt een open-ended set van deze facetten definiëren. U kunt ook een landinstellingsobject maken dat een willekeurig aantal facetten aanwijst.

Vooraf gedefinieerde groepen van deze facetten vertegenwoordigen de landinstellingencategorieën die traditioneel worden beheerd in de Standard C-bibliotheek door de functie setlocale.

Categorie collate (LC_COLLATE) bevat de facetten:

collate<char>
collate<wchar_t>

Categorie ctype (LC_CTYPE) bevat de facetten:

ctype<char>
ctype<wchar_t>
codecvt<char, char, mbstate_t>
codecvt<wchar_t, char, mbstate_t>
codecvt<char16_t, char, mbstate_t>
codecvt<char32_t, char, mbstate_t>

Categorie monetary (LC_MONETARY) bevat de facetten:

moneypunct<char, false>
moneypunct<wchar_t, false>
moneypunct<char, true>
moneypunct<wchar_t, true>
money_get<char, istreambuf_iterator<char>>
money_get<wchar_t, istreambuf_iterator<wchar_t>>
money_put<char, ostreambuf_iterator<char>>
money_put<wchar_t, ostreambuf_iterator<wchar_t>>

Categorie numeric (LC_NUMERIC) bevat de facetten:

num_get<char, istreambuf_iterator<char>>
num_get<wchar_t, istreambuf_iterator<wchar_t>>
num_put<char, ostreambuf_iterator<char>>
num_put<wchar_t, ostreambuf_iterator<wchar_t>>
numpunct<char>
numpunct<wchar_t>

Categorie time (LC_TIME) bevat de facetten:

time_get<char, istreambuf_iterator<char>>
time_get<wchar_t, istreambuf_iterator<wchar_t>>
time_put<char, ostreambuf_iterator<char>>
time_put<wchar_t, ostreambuf_iterator<wchar_t>>

Categorie messages (LC_MESSAGES) bevat de facetten:

messages<char>
messages<wchar_t>

(De laatste categorie is vereist voor POSIX, maar niet de C-standaard.)

Sommige van deze vooraf gedefinieerde facetten worden door de iostream klassen gebruikt om de conversie van numerieke waarden naar en van tekstreeksen te beheren.

Een object van klasse locale slaat ook een landinstellingsnaam op als een object van klassetekenreeks. Als u een ongeldige landinstellingsnaam gebruikt om een facet voor landinstellingen of een landinstellingsobject te maken, wordt een object van klasse runtime_error gegenereerd. De naam van de opgeslagen landinstelling is "*" als het landinstellingsobject niet zeker weet dat een landinstelling in C-stijl exact overeenkomt met de landinstelling die wordt vertegenwoordigd door het object. Anders kunt u een overeenkomende landinstelling instellen in de Standard C-bibliotheek, voor een bepaald landinstellingsobjectlocale_object, door de naam().c_str()) aan te roepensetlocale(LC_ALL , locale_object..

static locale empty();

In deze implementatie kunt u ook de functie empty() statisch lid aanroepen om een landinstellingsobject te maken dat geen facetten heeft. Het is ook een transparante landinstelling. Als de sjabloon has_facet en use_facet de aangevraagde facet niet kan vinden in een transparante landinstelling, raadplegen ze eerst de algemene landinstelling en als dat transparant is, de klassieke landinstelling. U kunt dus schrijven:

cout.imbue(locale::empty());

Volgende invoegingen worden cout gemediateerd door de huidige status van de globale landinstelling. U kunt zelfs schrijven:

locale loc(locale::empty(),
    locale::classic(),
    locale::numeric);

cout.imbue(loc);

Regels voor numerieke opmaak voor volgende invoegingen blijven cout hetzelfde als in de landinstelling C, zelfs als de globale landinstelling veranderende regels levert voor het invoegen van datums en monetaire bedragen.

Constructeurs

Typedefs

Functies voor leden

Statische functies

Bedieners

Klassen

Requirements

Rubriek:<oord>

naamruimte: std

landinstelling::categorie

Een geheel getal dat bitmaskerwaarden biedt om standaard facetfamilies aan te duiden.

typedef int category;
static const int collate = LC_COLLATE;
static const int ctype = LC_CTYPE;
static const int monetary = LC_MONETARY;
static const int numeric = LC_NUMERIC;
static const int time = LC_TIME;
static const int messages = LC_MESSAGES;
static const int all = LC_ALL;
static const int none = 0;

Opmerkingen

Het type is een synoniem voor een int type dat een groep afzonderlijke elementen van een bitmaskertype lokaal kan vertegenwoordigen voor de landinstelling van de klasse of kan worden gebruikt om een van de bijbehorende C-landinstellingen te vertegenwoordigen. De elementen zijn:

• collate, die overeenkomt met de categorie C LC_COLLATE

• ctype, die overeenkomt met de categorie C LC_CTYPE

• monetary, die overeenkomt met de categorie C LC_MONETARY

• numeric, die overeenkomt met de categorie C LC_NUMERIC

• time, die overeenkomt met de categorie C LC_TIME

• messages, die overeenkomt met de POSIX-categorie LC_MESSAGES

Twee nuttigere waarden zijn:

• none, die overeenkomt met geen van de C-categorieën

• all, die overeenkomt met de C-samenvoeging van alle categorieën LC_ALL

U kunt een willekeurige groep categorieën vertegenwoordigen met behulp van een bitwise-OR met deze constanten, zoals in monetary | time.

landinstelling::klassiek

De functie statisch lid retourneert een landinstellingsobject dat de klassieke C-landinstelling vertegenwoordigt.

static const locale& classic();

Retourwaarde

Een verwijzing naar de C-landinstelling.

Opmerkingen

De klassieke C-landinstelling is de Amerikaanse ASCII-landinstelling in de Standard C-bibliotheek. Dit is de landinstelling die impliciet wordt gebruikt in programma's die niet zijn geinternationaliseerd.

Example

// locale_classic.cpp
// compile with: /EHsc
#include <iostream>
#include <string>
#include <locale>

using namespace std;

int main( )
{
   locale loc1( "german" );
   locale loc2 = locale::global( loc1 );
   cout << "The name of the previous locale is: " << loc2.name( )
        << "." << endl;
   cout << "The name of the current locale is: " << loc1.name( )
        << "." << endl;

   if (loc2 == locale::classic( ) )
      cout << "The previous locale was classic." << endl;
   else
      cout << "The previous locale was not classic." << endl;

   if (loc1 == locale::classic( ) )
      cout << "The current locale is classic." << endl;
   else
      cout << "The current locale is not classic." << endl;
}

The name of the previous locale is: C.
The name of the current locale is: German_Germany.1252.
The previous locale was classic.
The current locale is not classic.

landinstelling::combineren

Hiermee voegt u een facet uit een opgegeven landinstelling in een doellandinstelling in.

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

Parameterwaarden

source_locale
De landinstelling die het facet bevat dat moet worden ingevoegd in de landinstelling van het doel.

Retourwaarde

De lidfunctie retourneert een landinstellingsobject dat vervangt in of toevoegt aan *this het facet Facet dat wordt vermeld in source_locale.

Example

// locale_combine.cpp
// compile with: /EHsc
#include <locale>
#include <iostream>
#include <tchar.h>
using namespace std;

int main() {
   locale loc ( "German_germany" );
   _TCHAR * s1 = _T("Das ist wei\x00dfzz."); // \x00df is the German sharp-s; it comes before z in the German alphabet
   _TCHAR * s2 = _T("Das ist weizzz.");
   int result1 = use_facet<collate<_TCHAR> > ( loc ).
      compare (s1, &s1[_tcslen( s1 )-1 ],  s2, &s2[_tcslen( s2 )-1 ] );
   cout << isalpha (_T ( '\x00df' ), loc ) << result1 << endl;

   locale loc2 ( "C" );
   int result2 = use_facet<collate<_TCHAR> > ( loc2 ).
      compare (s1, &s1[_tcslen( s1 )-1 ],  s2, &s2[_tcslen( s2 )-1 ] );
   cout << isalpha (_T ( '\x00df' ), loc2 )  << result2 << endl;

   locale loc3 = loc2.combine<collate<_TCHAR> > (loc);
   int result3 = use_facet<collate<_TCHAR> > ( loc3 ).
      compare (s1, &s1[_tcslen( s1 )-1 ],  s2, &s2[_tcslen( s2 )-1 ] );
   cout << isalpha (_T ( '\x00df' ), loc3 ) << result3 << endl;
}

facetklasse

Een klasse die fungeert als basisklasse voor alle facetten van landinstellingen.

class facet {
protected:
    explicit facet(size_t references = 0);
    virtual ~facet();
private:
    facet(const facet&) // not defined
    void operator=(const facet&) // not defined
};

Opmerkingen

U kunt een object van klasse facetniet kopiëren of toewijzen. U kunt objecten maken en vernietigen die zijn afgeleid van klasse locale::facet , maar niet objecten van de basisklasse. Normaal gesproken maakt u een object _Myfac dat is afgeleid van facet wanneer u een locale, zoals in locale loc(locale::classic(), new _Myfac);

In dergelijke gevallen moet de constructor voor de basisklasse facet een argument nulverwijzingen hebben. Wanneer het object niet meer nodig is, wordt het verwijderd. Geef een niet-nulverwijzingenargument alleen op in zeldzame gevallen waarin u verantwoordelijk bent voor de levensduur van het object.

landinstelling::globaal

Hiermee stelt u de standaardinstelling voor het programma opnieuw in. Deze aanroep is van invloed op de globale landinstelling voor zowel C als C++.

static locale global(const locale& new_default_locale);

Parameterwaarden

new_default_locale
De landinstelling die moet worden gebruikt als de standaardlandinstelling voor het programma.

Retourwaarde

De vorige landinstelling voordat de standaardinstelling opnieuw is ingesteld.

Opmerkingen

Bij het opstarten van het programma is de algemene landinstelling hetzelfde als de klassieke landinstelling. De global() functieaanroepen setlocale( LC_ALL, loc.name. c_str()) om een overeenkomende landinstelling in de Standard C-bibliotheek tot stand te brengen.

Example

// locale_global.cpp
// compile by using: /EHsc
#include <locale>
#include <iostream>
#include <tchar.h>
using namespace std;

int main( )
{
   locale loc ( "German_germany" );
   locale loc1;
   cout << "The initial locale is: " << loc1.name( ) << endl;
   locale loc2 = locale::global ( loc );
   locale loc3;
   cout << "The current locale is: " << loc3.name( ) << endl;
   cout << "The previous locale was: " << loc2.name( ) << endl;
}

The initial locale is: C
The current locale is: German_Germany.1252
The previous locale was: C

id-klasse

De lidklasse biedt een unieke facetidentificatie die wordt gebruikt als index voor het opzoeken van facetten in een landinstelling.

class id
{
   protected:    id();
   private:      id(const id&)
   void operator=(const id&)  // not defined
};

Opmerkingen

De lidklasse beschrijft het statische lidobject dat is vereist voor elke unieke landinstelling facet. U kunt een object van klasse idniet kopiëren of toewijzen.

landinstelling::landinstelling

Hiermee maakt u een landinstelling of een kopie van een landinstelling of een kopie van de landinstelling waarbij een facet of categorie is vervangen door een facet of categorie van een andere landinstelling. Bevat ook een destructor.

locale();

explicit locale(const char* locale_name, category new_category = all);
explicit locale(const string& locale_name);
locale(const locale& from_locale);
locale(const locale& from_locale, const locale& Other, category new_category);
locale(const locale& from_locale, const char* locale_name, category new_category);

template <class Facet>
locale(const locale& from_locale, const Facet* new_facet);

~locale();

Parameterwaarden

locale_name
Naam van een landinstelling.

from_locale
Een landinstelling die moet worden gekopieerd bij het maken van de nieuwe landinstelling.

Overige
Een landinstelling waaruit u een categorie wilt selecteren.

new_category
De categorie die moet worden vervangen door de samengestelde landinstelling.

new_facet
Het facet dat moet worden vervangen door de geconstrueerde landinstelling.

Opmerkingen

De eerste constructor initialiseert het object zodat het overeenkomt met de globale landinstelling. De tweede en derde constructors initialiseren alle landinstellingencategorieën om gedrag consistent te hebben met de landinstellingsnaam locale_name. De resterende constructors kopiëren from_locale, met de uitzonderingen vermeld:

locale(const locale& from_locale, const locale& Other, category new_category);

vervangt van Andere facetten die overeenkomen met een categorie C waarvoor C & new_category niet-nul is.

locale(const locale& from_locale, const char* locale_name, category new_category);

locale(const locale& from_locale, const string& locale_name, category new_category);

vervangt deze locale(locale_name, all) facetten die overeenkomen met een categorie replace_category waarvoor replace_category & new_category niet-nul is.

template<class Facet> locale(const locale& from_locale, Facet* new_facet);

vervangt in (of toevoegt aan) from_locale de facet-new_facet, als new_facet geen null-aanwijzer is.

Als de landinstellingsnaam locale_name een null-aanwijzer is of anderszins ongeldig is, genereert de functie runtime_error.

Example

// locale_locale.cpp
// compile with: /EHsc
#include <locale>
#include <iostream>
#include <tchar.h>
using namespace std;

int main( ) {

   // Second constructor
   locale loc ( "German_germany" );
   _TCHAR * s1 = _T("Das ist wei\x00dfzz."); // \x00df is the German sharp-s, it comes before z in the German alphabet
   _TCHAR * s2 = _T("Das ist weizzz.");
   int result1 = use_facet<collate<_TCHAR> > ( loc ).
      compare (s1, &s1[_tcslen( s1 )-1 ],  s2, &s2[_tcslen( s2 )-1 ] );
   cout << isalpha (_T ( '\x00df' ), loc ) << result1 << endl;

   // The first (default) constructor
   locale loc2;
   int result2 = use_facet<collate<_TCHAR> > ( loc2 ).
      compare (s1, &s1[_tcslen( s1 )-1 ],  s2, &s2[_tcslen( s2 )-1 ] );
   cout << isalpha (_T ( '\x00df' ), loc2 )  << result2 << endl;

   // Third constructor
   locale loc3 (loc2,loc, _M_COLLATE );
   int result3 = use_facet<collate<_TCHAR> > ( loc3 ).
      compare (s1, &s1[_tcslen( s1 )-1 ],  s2, &s2[_tcslen( s2 )-1 ] );
   cout << isalpha (_T ( '\x00df' ), loc3 ) << result3 << endl;

   // Fourth constructor
   locale loc4 (loc2, "German_Germany", _M_COLLATE );
   int result4 = use_facet<collate<_TCHAR> > ( loc4 ).
      compare (s1, &s1[_tcslen( s1 )-1 ],  s2, &s2[_tcslen( s2 )-1 ] );
   cout << isalpha (_T ( '\x00df' ), loc4 ) << result4 << endl;
}

landinstelling::naam

Retourneert de naam van de opgeslagen landinstelling.

string name() const;

Retourwaarde

Een tekenreeks die de naam van de landinstelling aangeeft.

Example

// locale_name.cpp
// compile with: /EHsc
#include <iostream>
#include <string>
#include <locale>

using namespace std;

int main( )
{
   locale loc1( "german" );
   locale loc2 = locale::global( loc1 );
   cout << "The name of the previous locale is: "
        << loc2.name( ) << "." << endl;
   cout << "The name of the current locale is: "
        << loc1.name( ) << "." << endl;
}

The name of the previous locale is: C.
The name of the current locale is: German_Germany.1252.

landinstelling::operator=

Hiermee wordt een landinstelling toegewezen.

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

landinstelling::operator!=

Test twee landinstellingen voor ongelijkheid.

bool operator!=(const locale& right) const;

Parameterwaarden

Een van de landinstellingen die moeten worden getest op ongelijkheid.

Retourwaarde

Een Booleaanse waarde die is true als de landinstellingen geen kopieën van dezelfde landinstelling zijn. Dit is false als de landinstellingen kopieën van dezelfde landinstelling zijn.

Opmerkingen

Twee landinstellingen zijn gelijk als ze dezelfde landinstelling zijn, als de ene een kopie van de andere is of als ze identieke namen hebben.

Example

// locale_op_ne.cpp
// compile with: /EHsc
#include <iostream>
#include <string>
#include <locale>

using namespace std;

int main( )
{
   locale loc1( "German_Germany" );
   locale loc2( "German_Germany" );
   locale loc3( "English" );

   if ( loc1 != loc2 )
      cout << "locales loc1 (" << loc1.name( )
      << ") and\n loc2 (" << loc2.name( ) << ") are not equal." << endl;
   else
      cout << "locales loc1 (" << loc1.name( )
      << ") and\n loc2 (" << loc2.name( ) << ") are equal." << endl;

   if ( loc1 != loc3 )
      cout << "locales loc1 (" << loc1.name( )
      << ") and\n loc3 (" << loc3.name( ) << ") are not equal." << endl;
   else
      cout << "locales loc1 (" << loc1.name( )
      << ") and\n loc3 (" << loc3.name( ) << ") are equal." << endl;
}

locales loc1 (German_Germany.1252) and
loc2 (German_Germany.1252) are equal.
locales loc1 (German_Germany.1252) and
loc3 (English_United States.1252) are not equal.

landinstelling::operator()

Vergelijkt twee basic_string objecten volgens de lexicografische vergelijkingsregels die zijn gedefinieerd door de facet van std::collate<charT> deze landinstelling.

template <class CharType, class Traits, class Allocator>
bool operator()(
    const basic_string<CharType, Traits, Allocator>& left,
    const basic_string<CharType, Traits, Allocator>& right) const;

Parameterwaarden

De eerste tekenreeks die moet worden vergeleken.

De tweede tekenreeks die moet worden vergeleken.

Retourwaarde

• true indien links lexicografisch kleiner is dan rechts, anders false.

Opmerkingen

De lidfunctie voert het volgende effectief uit:

const collate<CharType>& fac = use_fac<collate<CharType>>(*this);

return (fac.compare(left.begin(), left.end(), right.begin(), right.end()) < 0);

Dit betekent dat u een landinstellingsobject kunt gebruiken als een functieobject.

Example

// locale_op_compare.cpp
// compile with: /EHsc
#include <iostream>
#include <string>
#include <locale>

int main( )
{
   using namespace std;
   const wchar_t *sa = L"ztesting";
   const wchar_t *sb = L"\0x00DFtesting";
   basic_string<wchar_t> a( sa );
   basic_string<wchar_t> b( sb );

   locale loc( "German_Germany" );
   cout << loc( a,b ) << endl;

   const collate<wchar_t>& fac = use_facet<collate<wchar_t> >( loc );
   cout << ( fac.compare( sa, sa + a.length( ),
       sb, sb + b.length( ) ) < 0) << endl;
}

0
0

landinstelling::operator==

Test twee landinstellingen voor gelijkheid.

bool operator==(const locale& right) const;

Parameterwaarden

Een van de landinstellingen die moeten worden getest op gelijkheid.

Retourwaarde

Een Booleaanse waarde die is true als de landinstellingen kopieën van dezelfde landinstelling zijn. Dit is false als de landinstellingen geen kopieën van dezelfde landinstelling zijn.

Opmerkingen

Twee landinstellingen zijn gelijk als ze dezelfde landinstelling zijn, als de ene een kopie van de andere is of als ze identieke namen hebben.

Example

// locale_op_eq.cpp
// compile with: /EHsc
#include <iostream>
#include <string>
#include <locale>

using namespace std;

int main( )
{
   locale loc1( "German_Germany" );
   locale loc2( "German_Germany" );
   locale loc3( "English" );

   if ( loc1 == loc2 )
      cout << "locales loc1 (" << loc1.name( )
      << ")\n and loc2 (" << loc2.name( ) << ") are equal."
      << endl;
   else
      cout << "locales loc1 (" << loc1.name( )
      << ")\n and loc2 (" << loc2.name( ) << ") are not equal."
      << endl;

   if ( loc1 == loc3 )
      cout << "locales loc1 (" << loc1.name( )
      << ")\n and loc3 (" << loc3.name( ) << ") are equal."
      << endl;
   else
      cout << "locales loc1 (" << loc1.name( )
      << ")\n and loc3 (" << loc3.name( ) << ") are not equal."
      << endl;
}

locales loc1 (German_Germany.1252)
and loc2 (German_Germany.1252) are equal.
locales loc1 (German_Germany.1252)
and loc3 (English_United States.1252) are not equal.

Zie ook

<oord>
Codepagina's
Landinstellingen, talen en tekenreeksen voor land/regio
Thread Safety in de C++-standaardbibliotheek