locale — Klasa

Klasa opisująca obiekt ustawień regionalnych, który hermetyzuje informacje specyficzne dla kultury jako zbiór zestawu reguł, które wspólnie definiują specyficzne środowisko zlokalizowane.

Składnia

class locale;

Uwagi

Aspekt jest wskaźnikiem do obiektu klasy pochodzącej z aspektu klasy, który ma publiczny obiekt formularza:

static locale::id id;

Można zdefiniować nieograniczony zbiór tych zestawów reguł. Można także skonstruować obiekt ustawień regionalnych, który wyznacza dowolną liczbę zestawów reguł.

Wstępnie zdefiniowane grupy tych aspektów reprezentują kategorie ustawień regionalnych tradycyjnie zarządzane w standardowej bibliotece C przez funkcję setlocale.

Kategoria collate (LC_COLLATE) obejmuje aspekty:

collate<char>
collate<wchar_t>

Kategoria ctype (LC_CTYPE) zawiera aspekty:

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>

Kategoria monetary (LC_MONETARY) zawiera aspekty:

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>>

Kategoria numeric (LC_NUMERIC) obejmuje aspekty:

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>

Kategoria time (LC_TIME) obejmuje aspekty:

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>>

Kategoria messages (LC_MESSAGES) zawiera aspekty:

messages<char>
messages<wchar_t>

(Ostatnia kategoria jest wymagana przez system POSIX, ale nie standard C).

Niektóre z tych wstępnie zdefiniowanych aspektów są używane przez iostream klasy do kontrolowania konwersji wartości liczbowych na i z sekwencji tekstowych.

Obiekt ustawień regionalnych klasy przechowuje również nazwę ustawień regionalnych jako obiekt ciągu klasy. Użycie nieprawidłowej nazwy ustawień regionalnych do konstruowania aspektu ustawień regionalnych lub obiektu ustawień regionalnych zgłasza obiekt runtime_error klasy. Przechowywana nazwa ustawień regionalnych jest taka "*" , czy obiekt ustawień regionalnych nie może być pewien, że ustawienia regionalne w stylu C odpowiadają dokładnie tym, który jest reprezentowany przez obiekt. W przeciwnym razie można ustanowić zgodne ustawienia regionalne w standardowej bibliotece C dla niektórych obiektów locale_objectustawień regionalnych , wywołując setlocale(LC_ALL , locale_object.nazwę().c_str()).

W tej implementacji można również wywołać funkcję statycznego elementu członkowskiego:

static locale empty();

do konstruowania obiektu ustawień regionalnych, który ma nie zestawu reguł. Jest to również przezroczyste ustawienia regionalne. Jeśli funkcje szablonu has_facet i use_facet nie mogą znaleźć żądanego aspektu w przezroczystych ustawieniach regionalnych, należy najpierw skonsultować się z globalnymi ustawieniami regionalnymi, a następnie, jeśli jest to przezroczyste, klasyczne ustawienia regionalne. Dlatego możesz napisać:

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

Kolejne wstawiania są cout pośredniczone przez bieżący stan globalnych ustawień regionalnych. Można nawet napisać:

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

cout.imbue(loc);

Reguły formatowania liczbowego dla kolejnych wstawiania cout pozostają takie same jak w ustawieniach regionalnych języka C, nawet gdy globalne ustawienia regionalne udostępniają zmieniające się reguły wstawiania dat i kwot pieniężnych.

Konstruktory

Konstruktor	opis
ustawienia regionalne	Tworzy ustawienia regionalne lub kopię ustawień regionalnych, lub kopię ustawień regionalnych, w której zestaw reguł lub kategoria zostały zastąpione przez zestaw reguł lub kategorię z innych ustawień regionalnych.

Typedefs

Nazwa typu	opis
Kategorii	Typ całkowitoliczbowy, który zawiera wartości masek bitowych dla oznaczenia standardowych rodzin zestawów reguł.

Funkcje składowe

Funkcja składowa	opis
Połączyć	Wstawia zestaw reguł z określonych ustawień regionalnych do docelowych ustawień regionalnych.
name	Zwraca przechowywaną nazwę ustawień regionalnych.

Funkcje statyczne

Nazwa/nazwisko	opis
Klasyczny	Funkcja statycznej składowej zwraca obiekt ustawień regionalnych, który reprezentuje klasyczne ustawienia regionalne C.
globalne	Resetuje domyślne ustawienia lokalne dla programu.

Operatory

Operator	opis
operator =	Przypisuje ustawienia regionalne.
operator!=	Testuje dwa ustawienia lokalne pod kątem nierówności.
operator( )	Porównuje dwa basic_string obiekty.
operator==	Testuje dwa ustawienia lokalne pod kątem równości.

Klasy

Klasa	opis
aspekt	Klasa, która służy jako klasa bazowa dla wszystkich zestawów reguł ustawień regionalnych.
id	Klasa składowej zapewnia unikatową identyfikację zestawu reguł używaną jako indeks do wyszukiwania zestawów reguł w ustawieniach regionalnych.

Wymagania

Nagłówek:<ustawienia regionalne>

Przestrzeń nazw: std

locale::category

Typ całkowitoliczbowy, który zawiera wartości masek bitowych dla oznaczenia standardowych rodzin zestawów reguł.

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;

Uwagi

Typ jest synonimem int typu, który może reprezentować grupę odrębnych elementów typu maski bitowej lokalnie na ustawienia regionalne klasy lub może służyć do reprezentowania dowolnej z odpowiednich kategorii ustawień regionalnych języka C. Elementy to:

• collate, odpowiadający LC_COLLATE kategorii C

• ctype, odpowiadający LC_CTYPE kategorii C

• monetary, odpowiadający LC_MONETARY kategorii C

• numeric, odpowiadający LC_NUMERIC kategorii C

• time, odpowiadający LC_TIME kategorii C

• messages, odpowiadający kategorii POSIX LC_MESSAGES

Dwie bardziej przydatne wartości to:

• none, odpowiadający żadnej z kategorii języka C

• all, odpowiadający unii C wszystkich kategorii LC_ALL

Możesz reprezentować dowolną grupę kategorii przy użyciu bitowych or z tymi stałymi, jak w pliku monetary | time.

locale::classic

Funkcja statycznej składowej zwraca obiekt ustawień regionalnych, który reprezentuje klasyczne ustawienia regionalne C.

static const locale& classic();

Wartość zwracana

Odwołanie do ustawień regionalnych języka C.

Uwagi

Klasyczne ustawienia regionalne języka C to angielskie ustawienia regionalne ASCII w stanach Zjednoczonych w bibliotece Standard C. To ustawienia regionalne, które są używane niejawnie w programach, które nie są międzynarodowych.

Przykład

// 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.

ustawienia regionalne::połącz

Wstawia zestaw reguł z określonych ustawień regionalnych do docelowych ustawień regionalnych.

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

Parametry

source_locale
Ustawienia regionalne zawierające aspekt, który ma zostać wstawiony do ustawień regionalnych docelowych.

Wartość zwracana

Funkcja składowa zwraca obiekt ustawień regionalnych, który zastępuje element w elemencie lub dodaje go do *this aspektu Facet wymienionego w source_locale.

Przykład

// 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;
}

facet, klasa

Klasa, która służy jako klasa bazowa dla wszystkich zestawów reguł ustawień regionalnych.

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

Uwagi

Nie można skopiować ani przypisać obiektu klasy facet. Można konstruować i niszczyć obiekty pochodzące z klasy locale::facet , ale nie obiekty właściwe dla klasy bazowej. Zazwyczaj konstruujesz obiekt _Myfac pochodzący z facet obiektu podczas konstruowania localeobiektu , jak w locale loc(locale::classic(), new _Myfac);

W takich przypadkach konstruktor klasy facet bazowej powinien mieć argument zero odwołań . Gdy obiekt nie jest już potrzebny, zostanie usunięty. Podaj argument niezerowy tylko w tych rzadkich przypadkach, gdy ponosisz odpowiedzialność za okres istnienia obiektu.

locale::global

Resetuje domyślne ustawienia regionalne programu. To wywołanie wpływa na globalne ustawienia regionalne dla języków C i C++.

static locale global(const locale& new_default_locale);

Parametry

new_default_locale
Ustawienia regionalne, które mają być używane jako domyślne ustawienia regionalne przez program.

Wartość zwracana

Poprzednie ustawienia regionalne przed zresetowaniem domyślnych ustawień regionalnych.

Uwagi

Podczas uruchamiania programu ustawienia regionalne globalne są takie same jak klasyczne ustawienia regionalne. Funkcja global() wywołuje setlocale( LC_ALL, loc.name. c_str()) metodę ustanawiania pasujących ustawień regionalnych w bibliotece języka C w warstwie Standardowa.

Przykład

// 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, klasa

Klasa składowej zapewnia unikatową identyfikację zestawu reguł używaną jako indeks do wyszukiwania zestawów reguł w ustawieniach regionalnych.

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

Uwagi

Klasa składowa opisuje statyczny obiekt składowy wymagany przez każdy unikatowy zestaw ustawień regionalnych. Nie można skopiować ani przypisać obiektu klasy id.

locale::locale

Tworzy ustawienia regionalne lub kopię ustawień regionalnych, lub kopię ustawień regionalnych, w której zestaw reguł lub kategoria zostały zastąpione przez zestaw reguł lub kategorię z innych ustawień regionalnych. Zawiera również destruktor.

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();

Parametry

locale_name
Nazwa ustawień regionalnych.

from_locale
Ustawienia regionalne, które mają być kopiowane w konstruowaniu nowych ustawień regionalnych.

Inne
Ustawienia regionalne, z których chcesz wybrać kategorię.

new_category
Kategoria, która ma zostać zamieniona na skonstruowane ustawienia regionalne.

new_facet
Aspekt, który ma zostać zastąpiony skonstruowanym ustawieniami regionalnymi.

Uwagi

Pierwszy konstruktor inicjuje obiekt tak, aby był zgodny z ustawieniami regionalnymi globalnymi. Drugie i trzecie konstruktory inicjują wszystkie kategorie ustawień regionalnych w celu zachowania zgodnego z nazwą ustawień regionalnych locale_name. Pozostałe konstruktory kopiują from_locale z wyjątkami:

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

Zastępuje wartość z Inne te aspekty odpowiadające kategorii C, dla której C & new_category jest niezerowy.

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

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

zastępuje te locale(locale_name, all) aspekty odpowiadające kategorii replace_category , dla której replace_category & new_category nie jestzero.

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

zastępuje element (lub dodaje do) from_locale new_facet aspektu, jeśli new_facet nie jest wskaźnikiem o wartości null.

Jeśli nazwa ustawień regionalnych locale_name jest wskaźnikiem o wartości null lub w inny sposób nieprawidłowa, funkcja zgłasza runtime_error.

Przykład

// 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;
}

locale::name

Zwraca przechowywaną nazwę ustawień regionalnych.

string name() const;

Wartość zwracana

Ciąg nadający nazwę ustawień regionalnych.

Przykład

// 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.

locale::operator=

Przypisuje ustawienia regionalne.

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

locale::operator!=

Testuje dwa ustawienia lokalne pod kątem nierówności.

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

Parametry

Prawo
Jeden z ustawień regionalnych do przetestowania pod kątem nierówności.

Wartość zwracana

Wartość logiczna, która jest true taka, jeśli ustawienia regionalne nie są kopiami tych samych ustawień regionalnych. Jeśli false ustawienia regionalne są kopiami tych samych ustawień regionalnych.

Uwagi

Dwa ustawienia regionalne są równe, jeśli są tymi samymi ustawieniami regionalnymi, jeśli jedna z nich jest kopią drugiego lub mają identyczne nazwy.

Przykład

// 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.

locale::operator()

Porównuje dwa basic_string obiekty zgodnie z regułami porównania leksykograficznego zdefiniowanymi przez aspekt ustawień std::collate<charT> regionalnych.

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

Parametry

Lewej
Pierwszy ciąg do porównania.

Prawo
Drugi ciąg do porównania.

Wartość zwracana

• true jeśli po lewej stronie jest leksykograficznie mniejsze niż prawo, w przeciwnym razie false.

Uwagi

Funkcja składowa skutecznie wykonuje:

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

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

Oznacza to, że można użyć obiektu ustawień regionalnych jako obiektu funkcji.

Przykład

// 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

locale::operator==

Testuje dwa ustawienia lokalne pod kątem równości.

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

Parametry

Prawo
Jeden z ustawień regionalnych do przetestowania pod kątem równości.

Wartość zwracana

Wartość logiczna, która jest true taka, że jeśli ustawienia regionalne są kopiami tych samych ustawień regionalnych. Jeśli false ustawienia regionalne nie są kopiami tych samych ustawień regionalnych.

Uwagi

Dwa ustawienia regionalne są równe, jeśli są tymi samymi ustawieniami regionalnymi, jeśli jedna z nich jest kopią drugiego lub mają identyczne nazwy.

Przykład

// 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.

Zobacz też

<ustawienia regionalne>
Strony kodowe
Nazwy ustawień regionalnych, języki i ciągi kraju/regionu
Bezpieczeństwo wątku w standardowej bibliotece C++