Classe de localidade

A classe que descreve um objeto de localidade que encapsula informações específicas da cultura como um conjunto de facetas que definem coletivamente um ambiente localizado específico.

Sintaxe

class locale;

Observações

Uma faceta é um ponteiro para um objeto de uma classe derivada da faceta de classe que tem um objeto público do formulário:

static locale::id id;

Você pode definir um conjunto aberto dessas facetas. Você também pode construir um objeto de localidade que designa um número arbitrário de facetas.

Grupos predefinidos dessas facetas representam as categorias de localidade tradicionalmente gerenciadas na Biblioteca C padrão pela função setlocale.

A categoria collate (LC_COLLATE) inclui as facetas:

collate<char>
collate<wchar_t>

A categoria ctype (LC_CTYPE) inclui as facetas:

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>

A categoria monetary (LC_MONETARY) inclui as facetas:

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

A categoria numeric (LC_NUMERIC) inclui as facetas:

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>

A categoria time (LC_TIME) inclui as facetas:

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

A categoria messages (LC_MESSAGES) inclui as facetas:

messages<char>
messages<wchar_t>

(A última categoria é exigida pela POSIX, mas não a Norma C.)

Algumas dessas facetas predefinidas são usadas pelas iostream classes, para controlar a conversão de valores numéricos de e para sequências de texto.

Um objeto de classe locale também armazena um nome de localidade como um objeto de cadeia de caracteres de classe. Usar um nome de localidade inválido para construir uma faceta de localidade ou um objeto de localidade lança um objeto de classe runtime_error. O nome da localidade armazenada é "*" se o objeto de localidade não puder ter certeza de que uma localidade de estilo C corresponde exatamente àquela representada pelo objeto. Caso contrário, você pode estabelecer uma localidade correspondente dentro da Biblioteca C padrão, para algum objeto locale_objectde localidade , chamando setlocale(LC_ALL , locale_object.o nome().c_str()).

static locale empty();

Nesta implementação, você também pode chamar a função empty() de membro estático para construir um objeto de localidade que não tenha facetas. É também um local transparente. Se o modelo funcionar has_facet e use_facet não conseguir encontrar a faceta solicitada em uma localidade transparente, eles consultarão primeiro a localidade global e, em seguida, se ela for transparente, a localidade clássica. Então, você pode escrever:

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

Inserções subsequentes são cout mediadas pelo estado atual da localidade global. Você pode até escrever:

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

cout.imbue(loc);

As regras de formatação numérica para inserções subsequentes cout devem permanecer as mesmas que na localidade C, mesmo quando a localidade global fornece regras de alteração para inserir datas e valores monetários.

Construtores

Typedefs (definições de tipos)

Funções de membro

Funções estáticas

Operadores

Aulas

Requerimentos

Cabeçalho:<localidade>

Espaço de nomes: std

localidade::categoria

Um tipo inteiro que fornece valores de máscara de bits para denotar famílias de facetas padrão.

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;

Observações

O tipo é um sinônimo de um int tipo que pode representar um grupo de elementos distintos de um tipo de máscara de bits local para localidade de classe ou pode ser usado para representar qualquer uma das categorias de localidade C correspondentes. Os elementos são:

• collate, correspondente à categoria C LC_COLLATE

• ctype, correspondente à categoria C LC_CTYPE

• monetary, correspondente à categoria C LC_MONETARY

• numeric, correspondente à categoria C LC_NUMERIC

• time, correspondente à categoria C LC_TIME

• messages, correspondente à categoria POSIX LC_MESSAGES

Dois outros valores úteis são:

• none, que não corresponde a nenhuma das categorias C

• all, correspondente à união C de todas as categorias LC_ALL

Você pode representar um grupo arbitrário de categorias usando um bitwise-OR com essas constantes, como em monetary | time.

localidade::classic

A função de membro estático retorna um objeto de localidade que representa a localidade C clássica.

static const locale& classic();

Valor de retorno

Uma referência à localidade C.

Observações

A localidade C clássica é a localidade ASCII em inglês dos EUA dentro da biblioteca C padrão. É a localidade que é usada implicitamente em programas que não são internacionalizados.

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.

localidade::combinar

Insere uma faceta de uma localidade especificada em uma localidade de destino.

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

Parâmetros

source_locale
A localidade que contém a faceta a ser inserida na localidade de destino.

Valor de retorno

A função member retorna um objeto de localidade que substitui ou adiciona à *this faceta Facet listada em 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;
}

faceta Classe

Uma classe que serve como a classe base para todas as facetas da localidade.

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

Observações

Não é possível copiar ou atribuir um objeto de classe facet. Você pode construir e destruir objetos derivados da classe, locale::facet mas não objetos da classe base propriamente dita. Normalmente, você constrói um objeto _Myfac derivado de facet quando você constrói um locale, como em locale loc(locale::classic(), new _Myfac);

Nesses casos, o construtor para a classe facet base deve ter um argumento zero references . Quando o objeto não é mais necessário, ele é excluído. Forneça um argumento de referências diferente de zero apenas nos raros casos em que você assume a responsabilidade pelo tempo de vida do objeto.

localidade::global

Redefine a localidade padrão para o programa. Essa chamada afeta a localidade global para C e C++.

static locale global(const locale& new_default_locale);

Parâmetros

new_default_locale
A localidade a ser usada como a localidade padrão pelo programa.

Valor de retorno

A localidade anterior antes da localidade padrão foi redefinida.

Observações

Na inicialização do programa, a localidade global é a mesma que a localidade clássica. A global() função chama setlocale( LC_ALL, loc.name. c_str()) para estabelecer uma localidade correspondente na biblioteca C padrão.

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 Classe

A classe de membro fornece uma identificação de faceta exclusiva usada como um índice para procurar facetas em uma localidade.

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

Observações

A classe member descreve o objeto de membro estático exigido por cada faceta de localidade exclusiva. Não é possível copiar ou atribuir um objeto de classe id.

localidade::locale

Cria uma localidade, ou uma cópia de uma localidade, ou uma cópia da localidade onde uma faceta ou uma categoria foi substituída por uma faceta ou categoria de outra localidade. Também inclui um destruidor.

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

Parâmetros

locale_name
Nome de uma localidade.

from_locale
Uma localidade que deve ser copiada na construção da nova localidade.

Outros
Uma localidade a partir da qual selecionar uma categoria.

new_category
A categoria a ser substituída na localidade construída.

new_facet
A faceta a ser substituída no local construído.

Observações

O primeiro construtor inicializa o objeto para corresponder à localidade global. O segundo e terceiro construtores inicializam todas as categorias de localidade para ter um comportamento consistente com o nome da localidade locale_name. Os construtores restantes copiam from_locale, com as exceções observadas:

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

substitui de Outras as facetas correspondentes a uma categoria C para a qual C & new_category é diferente de zero.

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

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

substitui as facetas correspondentes a uma categoria replace_category para a qual replace_category & new_category é diferente de locale(locale_name, all) zero.

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

substitui (ou adiciona) from_locale a faceta new_facet, se new_facet não for um ponteiro nulo.

Se o nome da localidade locale_name for um ponteiro nulo ou inválido, a função será lançada 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;
}

localidade::nome

Retorna o nome da localidade armazenada.

string name() const;

Valor de retorno

Uma cadeia de caracteres que dá o nome da localidade.

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.

localidade::operador=

Atribui uma localidade.

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

localidade::operador!=

Testa dois locais para a desigualdade.

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

Parâmetros

direito
Um dos locais a ser testado para a desigualdade.

Valor de retorno

Um valor booleano que é true se as localidades não forem cópias da mesma localidade. É se as localidades false forem cópias da mesma localidade.

Observações

Duas localidades são iguais se forem a mesma localidade, se uma for uma cópia da outra ou se tiverem nomes idênticos.

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.

localidade::operator()

Compara dois basic_string objetos de acordo com as regras de comparação lexicográfica definidas pela faceta desta localidade std::collate<charT> .

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

Parâmetros

deixou
A primeira cadeia de caracteres a ser comparada.

direito
A segunda string para comparar.

Valor de retorno

• true se a esquerda é lexicograficamente menor que a direita, caso contrário false.

Observações

A função de membro executa efetivamente:

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

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

Isso significa que você pode usar um objeto locale como um objeto de função.

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

localidade::operador==

Testa duas localidades para igualdade.

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

Parâmetros

direito
Um dos locais a ser testado para a igualdade.

Valor de retorno

Um valor booleano que é true se as localidades forem cópias da mesma localidade. É se as localidades false não forem cópias da mesma localidade.

Observações

Duas localidades são iguais se forem a mesma localidade, se uma for uma cópia da outra ou se tiverem nomes idênticos.

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.

Consulte também

<localidade>
Páginas de código
Nomes de localidade, idiomas e cadeias de caracteres de país/região
Segurança de threads na biblioteca padrão C++