b'\n_START_ARTICLE_\nBiblioteca padr\xc3\xa3o do C++\n_START_PARAGRAPH_\nEm C++, a biblioteca padr\xc3\xa3o \xc3\xa9 uma cole\xc3\xa7\xc3\xa3o de classes, fun\xc3\xa7\xc3\xb5es e vari\xc3\xa1veis escritas na pr\xc3\xb3pria linguagem para facilitar o desenvolvimento de aplica\xc3\xa7\xc3\xb5es. Tamb\xc3\xa9m incorpora a biblioteca padr\xc3\xa3o do C, e todas suas funcionalidades est\xc3\xa3o declaradas no espa\xc3\xa7o de nomes std.\n_START_SECTION_\nVis\xc3\xa3o geral\n_START_PARAGRAPH_\nA biblioteca padr\xc3\xa3o do C++ fornece v\xc3\xa1rios containers gen\xc3\xa9ricos, fun\xc3\xa7\xc3\xb5es que utilizam e manipulam tais containers, fun\xc3\xa7\xc3\xb5es-objeto, cadeias de caracteres e streams gen\xc3\xa9ricos, suporte para algumas facilidades da linguagem e fun\xc3\xa7\xc3\xb5es de uso geral, como fun\xc3\xa7\xc3\xb5es matem\xc3\xa1ticas._NEWLINE_Os containers gen\xc3\xa9ricos s\xc3\xa3o uma implementa\xc3\xa7\xc3\xa3o de elementos conhecidos em estrutura de dados. Diferentes containers compartilham uma mesma interface, o acesso \xc3\xa9 o mesmo. A escolha do uso geralmente depende da efici\xc3\xaancia em determinadas tarefas que o container dever\xc3\xa1 desempenhar, o que est\xc3\xa1 relacionado com a implementa\xc3\xa7\xc3\xa3o interna da classe. Por exemplo, alguns containers s\xc3\xa3o mais eficientes em busca e menos eficientes em inser\xc3\xa7\xc3\xb5es._NEWLINE_Ela tamb\xc3\xa9m incorpora a biblioteca padr\xc3\xa3o do C90. Desta forma, as biblioteca-padr\xc3\xa3o do C sofreram uma adequa\xc3\xa7\xc3\xa3o para pertencerem tamb\xc3\xa9m ao espa\xc3\xa7o de nomes std: retirou-se o sufixo .h dos nomes dos arquivos de cabe\xc3\xa7alho, e adicionou-se o prefixo c para indicar que pertence \xc3\xa0 linguagem C._NEWLINE_Os algoritmos, containers e iteradores dessa biblioteca s\xc3\xa3o baseados na STL, e por esse motivo esses dois termos s\xc3\xa3o muitas vezes confundidos. O iterador \xc3\xa9 um conceito importante da STL, e, portanto, da biblioteca padr\xc3\xa3o. Ele permite que os algoritmos usem os containers de forma gen\xc3\xa9rica.\n_START_SECTION_\n<algorithm>\n_START_PARAGRAPH_\nEste cabe\xc3\xa7alho fornece diversos algoritmos gen\xc3\xa9ricos \xc3\xbateis para busca, ordena\xc3\xa7\xc3\xa3o e transforma\xc3\xa7\xc3\xa3o de containers (estruturas de dados), entre outros. Ele podem ser invocados para diferentes containers atrav\xc3\xa9s da interface comum dos iteradores, e de operadores espec\xc3\xadficos que cada algoritmo requisita da estrutura de dado usada. Os algoritmos geralmente s\xc3\xa3o especificados atrav\xc3\xa9s da posi\xc3\xa7\xc3\xa3o de come\xc3\xa7o e de fim da estrutura de dados, e o iterador no final da estrutura deve ser acess\xc3\xadvel a partir do iterador no come\xc3\xa7o da mesma estrutura atrav\xc3\xa9s de seguidos incrementos no iterador. Alguns algoritmos requerem uma condi\xc3\xa7\xc3\xa3o especial de entrada; por exemplo os algoritmos de busca bin\xc3\xa1ria, que requerem uma estrutura de dados j\xc3\xa1 ordenada previamente. Notar entretanto que esse requerimento \xc3\xa9 impl\xc3\xadcito e n\xc3\xa3o detect\xc3\xa1vel em tempo de compila\xc3\xa7\xc3\xa3o, cabendo a responsalibilidade de atender aos requisitos ao desenvolvedor._NEWLINE_Pode-se classificar os algoritmos dessa biblioteca em dois grandes grupos, os que realizam muta\xc3\xa7\xc3\xa3o no containers e os que n\xc3\xa3o realizam muta\xc3\xa7\xc3\xa3o. Algoritmos de busca, compara\xc3\xa7\xc3\xa3o e contagem de elementos n\xc3\xa3o realizam muta\xc3\xa7\xc3\xa3o, apenas l\xc3\xaaem o container e retornam como sa\xc3\xadda refer\xc3\xaancias para elementos da estrutura. Em contrapartida, algoritmos de ordena\xc3\xa7\xc3\xa3o, de c\xc3\xb3pia, de transforma\xc3\xa7\xc3\xa3o e de adi\xc3\xa7\xc3\xa3o ou remo\xc3\xa7\xc3\xa3o de elementos realizam muta\xc3\xa7\xc3\xa3o._NEWLINE_Para algoritmos que realizam muta\xc3\xa7\xc3\xa3o, existe o sufixo especial _copy, que indica que o algoritmo mant\xc3\xa9m intacto o container passado como par\xc3\xa2metro, retornando na sa\xc3\xadda um novo container que corresponde ao container original mais o processamento realizado. Para todos os algoritmos, mut\xc3\xa1veis ou n\xc3\xa3o, existe o sufixo especial _if, usado em algoritmos que envolvem compara\xc3\xa7\xc3\xa3o de elementos. Ele indica que uma fun\xc3\xa7\xc3\xa3o de compara\xc3\xa7\xc3\xa3o est\xc3\xa1 sendo passada por par\xc3\xa2metro para o algoritmo, em favor da utiliza\xc3\xa7\xc3\xa3o dos operadores padr\xc3\xa3o de compara\xc3\xa7\xc3\xa3o fornecidos pelo tipo de dado do container.\n_START_SECTION_\n<fstream>\n_START_PARAGRAPH_\nstd::fstream \xc3\xa9 um manipulador de fluxos de dados de arquivos de computador especializado para o tipo de dado nativo char. Ele permite ler e escrever em modo de texto (utiliza-se os operadores de deslocamento de bits, << e >>) ou bin\xc3\xa1rio (utiliza-se os m\xc3\xa9todos read e write para buffers de dado)._NEWLINE_A biblioteca padr\xc3\xa3o tamb\xc3\xa9m fornece classes para casos de uso de std::fstream somente para leitura (std::ifstream) ou somente para escrita (std::ofstream)._NEWLINE_A implementa\xc3\xa7\xc3\xa3o de std::fstream segue o padr\xc3\xa3o RAII. O gerenciamento do arquivo aberto (um recurso do sistema) \xc3\xa9 de responsabilidade da classe. Isso implica que ao inicializar std::fstream (atrav\xc3\xa9s de informa\xc3\xa7\xc3\xb5es como o nome do arquivo e o modo de abertura) o recurso \xc3\xa9 adquirido, e na destrui\xc3\xa7\xc3\xa3o de std::fstream o recurso \xc3\xa9 liberado ao sistema automaticamente. Apesar da biblioteca padr\xc3\xa3o fornecer o m\xc3\xa9todo close para a libera\xc3\xa7\xc3\xa3o manual do arquivo ao sistema, o RAII permite que isso seja feito automaticamente quando a inst\xc3\xa2ncia de std::fstream sai de escopo no programa.\n_START_SECTION_\n<functional>\n_START_PARAGRAPH_\nEste cabe\xc3\xa7alho fornece suporte para fun\xc3\xa7\xc3\xb5es-objeto, classes que encapsulam fun\xc3\xa7\xc3\xb5es de forma que a inst\xc3\xa2ncia da classe possa ser invocada tal qual uma fun\xc3\xa7\xc3\xa3o qualquer. Por exemplo, as fun\xc3\xa7\xc3\xb5es-objeto s\xc3\xa3o usadas na STL para a passagem de predicados aos algoritmos gen\xc3\xa9ricos de <algorithm>. S\xc3\xa3o disponibilizadas fun\xc3\xa7\xc3\xb5es-objeto un\xc3\xa1rias (que demandam um argumento) e bin\xc3\xa1rias (que demandam dois argumentos), adaptadores que permitem converter ponteiros de fun\xc3\xa7\xc3\xb5es em fun\xc3\xa7\xc3\xb5es-objeto e adaptadores que permitem converter fun\xc3\xa7\xc3\xb5es-objeto bin\xc3\xa1rias em un\xc3\xa1rias ao associar um valor a um dos argumentos._NEWLINE_O cabe\xc3\xa7alho ainda define algumas fun\xc3\xa7\xc3\xb5es-objeto de uso geral tais como opera\xc3\xa7\xc3\xb5es aritm\xc3\xa9ticas e l\xc3\xb3gicas. Um exemplo \xc3\xa9 equal_to, uma fun\xc3\xa7\xc3\xa3o-objeto bin\xc3\xa1ria que testa se dois valores s\xc3\xa3o iguais. Nada mais \xc3\xa9 que uma fun\xc3\xa7\xc3\xa3o de compara\xc3\xa7\xc3\xa3o gen\xc3\xa9rica encapsulada em uma classe.\n_START_SECTION_\n<iostream>\n_START_PARAGRAPH_\nEste cabe\xc3\xa7alho \xc3\xa9 respons\xc3\xa1vel pela manipula\xc3\xa7\xc3\xa3o de fluxo de dados padr\xc3\xa3o do sistema (entrada padr\xc3\xa3o, sa\xc3\xadda padr\xc3\xa3o e sa\xc3\xadda de erros padr\xc3\xa3o) e representa uma evolu\xc3\xa7\xc3\xa3o do cabe\xc3\xa7alho <stdio.h> da linguagem C. S\xc3\xa3o apresentados os objetos cin, cout, cerr e clog para o envio e recebimento de dados dos fluxos de entrada, sa\xc3\xadda, erro sem buffer e erro com buffer, respectivamente; para isso usa-se os operadores de deslocamento de bits (<< e >>)._NEWLINE_Tamb\xc3\xa9m s\xc3\xa3o fornecidos m\xc3\xa9todos para a formata\xc3\xa7\xc3\xa3o do fluxo de dados, como width, que define uma largura para a sa\xc3\xadda, fill, que define um caractere espec\xc3\xadfico para ser impresso caso o fluxo \xc3\xa9 menor que o m\xc3\xadnimo esperado, e precision, que define a quantidade de d\xc3\xadgitos significativos de n\xc3\xbameros de ponto flutuante._NEWLINE_Alguns compiladores s\xc3\xa3o incapazes de remover c\xc3\xb3digo desnecess\xc3\xa1rio ao produzir execut\xc3\xa1veis que incluem esta biblioteca atrav\xc3\xa9s de liga\xc3\xa7\xc3\xa3o est\xc3\xa1tica. Por exemplo, um programa Ol\xc3\xa1 Mundo usando-se a implementa\xc3\xa7\xc3\xa3o GNU da biblioteca padr\xc3\xa3o produz um execut\xc3\xa1vel maior que o equivalente utilizando-se <cstdio>, devido parcialmente a defici\xc3\xaancias do ligador.\n_START_SECTION_\n<locale>\n_START_PARAGRAPH_\nEste cabe\xc3\xa7alho manipula diversas conven\xc3\xa7\xc3\xb5es culturais do utilizador, como a representa\xc3\xa7\xc3\xa3o de n\xc3\xbameros, moeda e datas, para efeitos de internacionaliza\xc3\xa7\xc3\xa3o. A biblioteca faz uso da faceta, uma interface para um servi\xc3\xa7o dum locale espec\xc3\xadfico. Cada locale possui um conjunto de facetas. O construtor padr\xc3\xa3o da classe std::locale define uma c\xc3\xb3pia do locale da m\xc3\xa1quina executando o programa, com as conven\xc3\xa7\xc3\xb5es atuais do utilizador.\n_START_SECTION_\n<map>\n_START_PARAGRAPH_\nO container std::map<Key, Data, Compare, Alloc> \xc3\xa9 um conjunto associativo ordenado que mapeia um objetos do tipo Key (a chave) em objetos do tipo Data (o valor). As chaves s\xc3\xa3o \xc3\xbanicas: se um objeto \xc3\xa9 inserido com uma chave j\xc3\xa1 existente, o valor presente \xc3\xa9 substitu\xc3\xaddo pelo valor inserido._NEWLINE_O tempo requerido para acesso aleat\xc3\xb3rio a cada elemento \xc3\xa9 , e os iteradores atribu\xc3\xaddos n\xc3\xa3o s\xc3\xa3o invalidados ap\xc3\xb3s as opera\xc3\xa7\xc3\xb5es de inser\xc3\xa7\xc3\xa3o e remo\xc3\xa7\xc3\xa3o. Portanto, a implementa\xc3\xa7\xc3\xa3o mais usada para o container \xc3\xa9 a \xc3\xa1rvore de busca bin\xc3\xa1ria auto-balanceada (ainda que qualquer outra estrutura de dados que respeite as restri\xc3\xa7\xc3\xb5es de complexidade computacional pode ser usada, como uma skiplist)._NEWLINE_Internamente, os elementos do mapa s\xc3\xa3o ordenados atrav\xc3\xa9s das chaves._NEWLINE_Uma varia\xc3\xa7\xc3\xa3o do container \xc3\xa9 o std::multimap, que permite chaves repetidas.\n_START_SECTION_\n<set>\n_START_PARAGRAPH_\nO container std::set<Key, Compare, Alloc> \xc3\xa9 um conjunto associativo que permite acesso aleat\xc3\xb3rio r\xc3\xa1pido aos dados. Difere do container std::map pois os valores dos elementos tamb\xc3\xa9m s\xc3\xa3o suas chaves. Por esse motivo, cada valor (e, portanto, sua chave) \xc3\xa9 \xc3\xbanico, n\xc3\xa3o pode repetir. O container pode ser acessado de forma bidirecional, a partir do come\xc3\xa7o ou do fim._NEWLINE_A implementa\xc3\xa7\xc3\xa3o interna do container geralmente \xc3\xa9 uma \xc3\xa1rvore de busca bin\xc3\xa1ria._NEWLINE_Uma varia\xc3\xa7\xc3\xa3o do container \xc3\xa9 o std::multiset, um multiconjunto associativo, que permite valores repetidos.\n_START_SECTION_\n<sstream>\n_START_PARAGRAPH_\nstd::stringstream \xc3\xa9 um manipulador de fluxos de dados de cadeias de caracteres especializado para o tipo de dado nativo char. Ele permite ler e escrever em modo de texto (utiliza-se os operadores de deslocamento de bits, << e >>) ou bin\xc3\xa1rio (utiliza-se os m\xc3\xa9todos read e write para buffers de dado)._NEWLINE_A biblioteca padr\xc3\xa3o tamb\xc3\xa9m fornece classes para casos de uso de std::stringstream somente para leitura (std::istringstream) ou somente para escrita (std::ostringstream).\n_START_SECTION_\n<string>\n_START_PARAGRAPH_\nO container std::string \xc3\xa9 uma cadeia de caracteres especializada para o tipo de dado nativo char. Ele remove v\xc3\xa1rios dos problemas introduzidos pela linguagem C ao confiar no programador no gerenciamento de cadeias de caractere, encapsulando internamente rotinas e considera\xc3\xa7\xc3\xb5es que o programador n\xc3\xa3o precisa tomar conhecimento. Ele tamb\xc3\xa9m permite convers\xc3\xa3o de e para cadeias de texto do C (const char*)._NEWLINE_Diferente de uma cadeia de caracteres em C, que \xc3\xa9 um ponteiro para uma regi\xc3\xa3o de mem\xc3\xb3ria contendo a cadeia, o conte\xc3\xbado de std::string \xc3\xa9 armazenada por valor. Por esse motivo, a opera\xc3\xa7\xc3\xa3o de c\xc3\xb3pia possui tempo . Para evitar c\xc3\xb3pias desnecess\xc3\xa1rias, a passagem de cadeias de texto como par\xc3\xa2metro de fun\xc3\xa7\xc3\xb5es \xc3\xa9 geralmente feita por refer\xc3\xaancia constante. Isso possui uma segunda vantagem pois permite que a mesma fun\xc3\xa7\xc3\xa3o possa receber implicitamente uma cadeia de caracteres do C, sem a necessidade de sobrecarga para o tipo de dado const char*._NEWLINE_A especializa\xc3\xa7\xc3\xa3o para cadeias de char nem sempre \xc3\xa9 desejada. Por exemplo, uma aplica\xc3\xa7\xc3\xa3o que implemente UTF-32 (o mapeamento do padr\xc3\xa3o Unicode para 32 bits, suficiente para representar todo o padr\xc3\xa3o) deve reservar quatro bytes para cada caractere, enquanto um char armazena somente um byte. Por isso, o conceito gen\xc3\xa9rico de cadeia de texto \xc3\xa9 implementado no container std::basic_string, que pode ser especializado para qualquer tipo de dado. No caso de UTF-32, pode-se usar uma especializa\xc3\xa7\xc3\xa3o do container gen\xc3\xa9rico para um tipo de dado que armazene pelo menos quatro bytes. Como na maioria das vezes um char \xc3\xa9 suficiente, a especializa\xc3\xa7\xc3\xa3o \xc3\xa9 tamb\xc3\xa9m definida no padr\xc3\xa3o por conveni\xc3\xaancia.\n_START_SECTION_\n<vector>\n_START_PARAGRAPH_\nO container std::vector \xc3\xa9 um arranjo e generaliza o conceito dum vector em C. Pode ser acessado atrav\xc3\xa9s de \xc3\xadndices para o elementos assim como em C (atrav\xc3\xa9s de uma sobrecarga do operador adequado) e sua mem\xc3\xb3ria \xc3\xa9 alocada de forma cont\xc3\xadgua. Entretanto, diferente dum vetor em C, o tamanho do container \xc3\xa9 din\xc3\xa2mico com gerenciamento autom\xc3\xa1tico e h\xc3\xa1 uma flexibilidade maior para adicionar elementos. Al\xc3\xa9m de conhecer seu tamanho atual, uma inst\xc3\xa2ncia de std::vector tamb\xc3\xa9m conhece quantos elementos ainda pode alocar antes de precisar de redimensionamento: a aloca\xc3\xa7\xc3\xa3o \xc3\xa9 feita em blocos e n\xc3\xa3o para cada elemento, e \xc3\xa9 poss\xc3\xadvel definir manualmente qual o tamanho do bloco. Diferente dum vetor em C, std::vector fornece o m\xc3\xa9todo at para acessar elementos pelo \xc3\xadndice, mas com tratamento de exce\xc3\xa7\xc3\xb5es para o caso de \xc3\xadndices inv\xc3\xa1lidos (valores negativos ou acima do tamanho atual do container)._NEWLINE_Para inser\xc3\xa7\xc3\xb5es no meio do container std::list \xc3\xa9 mais eficiente. Enquanto std::vector fornece inser\xc3\xa7\xc3\xa3o eficiente no final do container, std::deque fornece inser\xc3\xa7\xc3\xa3o eficiente tanto no come\xc3\xa7o quanto no final do container. Al\xc3\xa9m de inser\xc3\xa7\xc3\xa3o eficiente no final, pontos positivos do std::vector incluem acesso em tempo constante a qualquer elemento atrav\xc3\xa9s do \xc3\xadndice e itera\xc3\xa7\xc3\xa3o em tempo linear._NEWLINE_Sendo um container gen\xc3\xa9rico, pode ser especializado para diferentes tipos de dado. Entretanto, desaconselha-se especializ\xc3\xa1-lo para o tipo booleano nativo, bool, cuja especializa\xc3\xa7\xc3\xa3o j\xc3\xa1 consta na biblioteca padr\xc3\xa3o.'