Universidade Federal de Mato Grosso do Sul. Standard Template Library (STL)

Transcrição

1 Universidade Federal de Mato Grosso do Sul Facom - Faculdade de Computação Linguagem de Programação Orientada a Objetos Prof. Me. Liana Duenha Standard Template Library (STL) 1 Introdução A Standard Template Library ou STL é uma biblioteca disponibilizada pelos ambientes de desenvolvimento C++ que contém um conjunto de classes para representar diversas estruturas de dados e algoritmos baseado em templates. A STL define os poderosos componentes reutilizáveis que implementam muitas estruturas de dados comuns e os algoritmos para processar adequadamente essas estruturas. O uso de STL oferece os seguintes benefícios: Reutilização de código. Como é baseado em templates, as classes de STL podem ser adaptadas a tipos distintos sem mudança de funcionalidade (type safe collections). Portabilidade e facilidade de uso. 1.1 Categorias de classes na STL As classes implementadas pela STL podem ser categorizadas em três grandes grupos: Contêineres (containers): classes utilizadas para armazenamento de dados, implementando uma coleção. Os adaptadores de contêineres fornecem funcionalidades específicas sobre contêiners; Iteradores (iterators): classes que permitem a varredura de uma coleção seguindo uma determinada regra; Algoritmos (algorithms): classes que implementam métodos para realização de algoritmos comuns de estruturas de dados sobre as coleções. 2 Contêineres Correspondem às coleções de elementos de um determinado tipo, na forma de gabaritos de classe. Os contêineres de sequência representam estruturas de dados lineares, 1

2 como vetores e listas. Os contêineres associativos representam estruturas de dados não-lineares que, em geral, podem localizar rapidamente elementos armazenados na estrutura. Esses dois tipos de contêineres são referidos como de contêineres de primeira classe. Há também os adaptadores de contêineres que implementam versões limitadas de contêineres sequenciais, como por exemplo, filas, pilhas ou filas de prioridade. Contêineres de sequência: vector: os elementos são organizados na forma de um array que pode crescer dinamicamente; list: os elementos são organizados na forma de uma lista duplamente encadeada, sem limite máximo de elementos; deque: os elementos são organizados em sequência, permitindo inserção ou remoção no início ou no fim sem necessidade de movimentação de outros elementos. Essa estrutura tenta se aproveitar das vantagens das duas anteriores com relação à eficiência dos métodos. Deque é abreviação de double ended queue ou fila com dupla terminação. Esta classe oferece acesso indexado eficiente para ler e modificar seus elementos, de modo muito semelhante a um vector, e também ofecere métodos eficientes de inserção e remoção nas suas extremidades (front ou back) de maneira eficiente, assim como uma list. Contêineres Associativos: set: coleção ordenada na qual os próprios elementos são utilizados como chaves para ordenação do contêiner. Esse contêiner permite duplicatas; multiset: idem ao set, porém não permite duplicatas; map: mapeamento de um para um, não permite duplicatas e possui pesquisa baseada em chave; multimap: idem ao map, porém permite mapeamento de um para muitos e duplicatas. Adaptadores de Contêineres: Existem três adaptadores de containeres definidos na STL. São eles: stack: fornece funcionalidade de pilha (estrutura LIFO, last in first out). queue: fornece funcionalidade de fila FIFO (first in first out). priority queue: fornece a funcionalidade de uma fila FIFO porém com prioridades de inserção. 2

3 Arquivos de cabeçalho de contêiner Standard Libraty: <vector>,<list>,<deque>, <stack>, <queue>, <map> (para map e multimap), <set> (para set e multiset). 2.1 Métodos comuns Alguns dos principais métodos comuns aos templates de contêiner são: construtor padrão: implementa a inicialização-padrão do contêiner (é comum que existam diferentes construtores para o mesmo contêiner); construtor de cópia: inicializa o contêiner como uma cópia de um contêiner existente do mesmo tipo; destrutor: função destrutora para liberação da memória utilizada pelo contêiner; empty: retorna true se não houver nenhum elemento no contêiner; caso contrário, retorna false size: retorna o número de elementos no contêiner; swap: permuta os elementos de um contêiner; operators =, <, <=, >, >=, ==,! =: para cada operador; implementa a funcionalidade esperada Funções encontradas apenas em contêineres de primeira classe (de sequência ou associativos: max size: retorna o número máximo de elemento de um contêiner; begin: retorna um iterator ou um const iterator que referencia o primeiro elemento do contêiner; end: retorna um iterador ou um const iterator que referencia a próxima posição depois do fim do contêiner; rbegin: retorna um reverse iterator ou const reverse iterator que referencia o último elemento do contêiner; rend: retorna um reverse iterator ou const reverse iterator que referencia a próxima posição depois do último elemento do contêiner invertido; clear: remove todos os elementos do contêiner; erase: remove um elemento do contêiner. Métodos de adição e remoção em deque e vector: 3

4 push back: adiciona elemento ao fim do contêiner push front: adiciona elemento ao início do contêiner back: obter uma referência para elemento no fim do contêiner front: obter uma referência para elemento no início do contêiner pop back: remove um elemento do fim do contêiner pop front: remove um elemento do início do contêiner Para operações de acesso a elementos em vector, map e deque: utiliza-se o operador [ ] como em um array comum. Após a explicação e exemplificação dos iteradores, exibiremos exemplos sobre adaptadores de contêineres. 3 Iteradores Os iteradores são utilizados para apontar para os elementos de contêineres de primeira classe. Os iteradores são implementados apropriadamente para cada tipo de contêiner. O operador de desreferenciação (*) desreferencia um iterador a fim de que o elemento para o qual ele aponta possa ser utilizado. A operação ++ em um iterador move-o para o próximo elemento do contêiner. Há suporte a diversas categorias de iteradores: iterator: é usado para percorrer os elementos do contêiner do início para o fim do contêiner e não pode ser usado para a gravação de dados no contêiner; const iterator: idem ao iterator, porém permite acesso para gravação de dados no contêiner; reverse iterator: permite percurso apenas para leitura dos elementos na ordem inversa (do fim para o início); const reverse iterator: permite percurso para leitura/gravação dos elementos do contêiner na ordem inversa (do fim para o início); random access: iterador bidimensional com capacidade de acesso direto a qualquer elemento do contêiner; 4

5 4 Algoritmos Correspondem de funções que implementam algoritmos de estruturas de dados (definidos na biblioteca algorithm). As funções são divididas em 3 categorias: sequência: implementam operações de busca e alteração da sequência de elementos do container classificação: implementam classificação dos elementos do contêiner numéricos: implementam funções numéricas comuns sobre os elementos do container. 4.1 Alguns algoritmos de sequência: copy: copia os elementos entre dois iteradores para um outro contêiner; fill: atribui um determinado valor a todos os elementos entre dois iteradores; remove: remove todos os elementos de um determinado valor entre dois iteradores; replace: recebe dois valore old value e new value, e substitui os elementos iguais a old value por new value entre dois os iteradores. reverse: inverte a ordem dos elementos entre dois iteradores; rotate: recebe como parâmetros três iteradores (start, end e middle). Rotaciona os elementos entre dois iteradores start e end de tal maneira que o iterador middle fique posicionado onde antes estava o iterador start. equal: Recebe como parâmetros três iteradores (start1, end1, start2). Retorna true se os elementos entre os iteradores start1 e end1 são iguais aos da faixa de mesmo tamanho iniciando em start2. find: Retorna um iterador para a primeira ocorrência do elemento com um determinado valor passado como parâmetro entre dois iteradores. search: Recebe como parâmetros quatro iteradores (start1, end1, start2, end2). Realiza a busca do subconjunto dos elementos entre os iteradores start2 e end2 dentro do conjunto dos elementos entre start1 e end1. Os algoritmos operam sobre os contêineres utilizando somente os iteradores dos containers. Exemplo: 5

6 using namespace std; #include <vector> #include <algorithm> #include <iostream> int main () int elements[] = 3, 8, 4, 7, 2, 1; vector<int> v; for (int i = 0; i < 6; i++) v.push_back(elements[i]); //rotaç~ao vector<int>::iterator inicio = v.begin(); vector<int>::iterator fim = v.end(); vector<int>::iterator meio = inicio + 3; rotate(inicio, meio, fim); cout << "Elementos rotacionados: " << endl; for (vector<int>::const_iterator it = v.begin(); it < v.end(); it++) cout << *it << " "; //reversing inicio = v.begin(); fim = v.end(); reverse(inicio, fim); cout << endl << "Elementos invertidos: " << endl; for (vector<int>::const_iterator it = v.begin(); it < v.end(); it++) cout << *it << " "; // replacing inicio = v.begin(); fim = v.end(); replace(inicio, fim, 4, -1); cout << endl << "Substituindo 4 por -1: " << endl; for (vector<int>::const_iterator it = v.begin(); it < v.end(); it++) 6

7 cout << *it << " "; 4.2 Alguns algoritmos de classificação: sort: Classifica em ordem crescente os elementos entre dois iteradores passados como parâmetros, sem garantia de ordem entre os elementos de mesmo valor; stable sort: semelhante a sort porém mantém a ordem original dos elementos que são iguais; Exemplo: using namespace std; #include <vector> #include <algorithm> #include <iostream> int main(int argc, char* argv[]) int elemento; vector <int> v; //mostrando o tamanho do conteiner cout << "O container tem tamanho " << v.size() << endl; //inserindo no final do conteiner for (int i = 0; i < 10; i++) cout << "Digite o próximo elemento: "; cin >> elemento; v.push_back(elemento); //percorrendo de trás para a frente cout << "Percurso do container na ordem inversa: " << endl; for (vector<int>::reverse_iterator rev = v.rbegin(); rev < v.rend(); rev++) cout << *rev << " "; 7

8 cout << endl; //mostrando a capacidade cout << "A capacidade atual do vector é " << v.capacity() << endl; //criando iteradores na direç~ao original vector<int>::iterator inicio = teste.begin(); vector<int>::iterator fim = teste.end(); //ordenando os elementos sort(inicio, fim); cout << "Elementos ordenados: " << endl; for (vector<int>::const_iterator fwd = v.begin(); fwd < v.end(); fwd++) cout << *fwd << " "; return 0; 4.3 Alguns algoritmos numéricos: accumulate: Recebe como parâmetros dois iteradores e um valor val. Acumula e retorna o valor de val com todos os valores entre os dois iteradores. count: Conta e retorna quantos valores entre os dois iteradores são iguais a determinado valor. Exemplo: using namespace std; #include <vector> #include <algorithm> #include <numeric> #include <iostream> int main () int elementos[] = 3, 8, 4, 7, 2, 1; vector<int> v; for (int i = 0; i < 6; i++) v.push_back(elementos[i]); 8

9 // acumula e retorna o valor do inicio ao fim do vetor vector<int>::iterator inicio = v.begin(); vector<int>::iterator fim = v.end(); int valor = accumulate(inicio, fim, 0); cout << "Valor acumulado dos elementos: " << endl; cout << valor; // conta a quantidade de 7s no vetor inicio = v.begin(); fim = v.end(); int contagem = count(inicio, fim, 7); cout << endl << "Contagem de 7 s: " << endl; cout << contagem; return 0; 5 Exmplos de uso de Contêineres Sequênciais e Associativos 5.1 Classe vector #include <vector> #include <algorithm> #include <iostream> #include <numeric> using namespace std; template <typename T> void printvector(vector<t> v) for (typename std::vector<t>::const_iterator it = v.begin(); it < v.end(); it++) cout << *it << " "; cout << endl; 9

10 int main () int elements[] = 3, 8, 4, 7, 2, 1; vector<int> vint; // validando a insercao no conteiner vector for (int i = 0; i < 6; i++) vint.push_back(elements[i]); // uso de iterators cout << "\nelementos do vetor: " << endl; printvector(vint); // uso de reverse_iterators cout << "\nelementos do vetor utilizando reverse_iterators: " << endl; for (vector<int>::const_reverse_iterator it = vint.rbegin(); it < vint.rend(); it++) cout << *it << " "; // useo de reverse (invers~ao dos elementos) reverse(vint.begin(),vint.end()); cout << endl << "\nelementos do vetor após invers~ao: " << endl; printvector(vint); // uso de rotate (método de rotaç~ao) rotate(vint.begin(),vint.begin()+2,vint.end()); cout << "\nelementos rotacionados usando início+2 elemento de controle da rotaç~ao: " << endl; printvector(vint); // uso de replace (método de substituiç~ao) replace(vint.begin(),vint.end(), 4, -1); cout << "\nsubstituindo 4 por -1 em todo o vetor: " << endl; printvector (vint); 10

11 // lendo 5 elementos da entrada padr~ao e armazenando no final do vetor int elemento; for (int i = 0; i < 5; i++) cout << "Digite o próximo elemento: "; cin >> elemento; vint.push_back(elemento); printvector(vint); //mostrando a capacidade cout << endl << "A capacidade atual do vector é " << vint.capacity() << endl; //ordenando os elementos do vetor sort(vint.begin(), vint.end()); cout << "Elementos ordenados: " << endl; printvector(vint); // acumulador int valorac = accumulate (vint.begin(),vint.end(),0); cout << "\nsoma de todos os elementos do vetor: " << valorac; return 0; 5.2 Classe list #include <list> #include <algorithm> #include <iostream> #include <numeric> using namespace std; template <typename T> void printlist(list<t> v) 11

12 for (typename std::list<t>::const_iterator it = v.begin(); it!= v.end(); it++) cout << *it << " "; cout << endl; // comparison, not case sensitive. bool compare_nocase (std::string first, std::string second) unsigned int i=0; while ( (i<first.length()) && (i<second.length()) ) if (tolower(first[i])<tolower(second[i])) return true; else if (tolower(first[i])>tolower(second[i])) return false; ++i; if (first.length()<second.length()) return true; else return false; return false; int main () int elements[] = 3, 8, 4, 7, 2, 1; list<int> intlist; // validando a insercao no conteiner list for (int i = 0; i < 6; i++) intlist.push_back(elements[i]); intlist.push_front(10); // uso de iterators cout << "\nelementos da lista: " << endl; printlist(intlist); 12

13 // useo de reverse (invers~ao dos elementos) reverse(intlist.begin(),intlist.end()); cout << endl << "\nelementos do vetor após invers~ao: " << endl; printlist(intlist); // uso de replace (método de substituiç~ao) replace(intlist.begin(),intlist.end(), 4, -1); cout << "\nsubstituindo 4 por -1 em todo o vetor: " << endl; printlist (intlist); //ordenando os elementos do vetor intlist.sort(); cout << "Elementos ordenados: " << endl; printlist(intlist); // acumulador int valorac = accumulate (intlist.begin(),intlist.end(),0); cout << "\nsoma de todos os elementos do vetor: " << valorac; // EXEMPLO SOBRE STRINGS list<string> strlist; list<string>::const_iterator it; strlist.push_back ("Meu"); strlist.push_back ("primeiro"); strlist.push_back ("teste"); strlist.push_back ("com"); strlist.push_back ("STD lists."); strlist.push_front ("Este é "); strlist.push_front ("Olá pessoal! "); std::cout << "\nelementos da lista:"; for (it=strlist.begin(); it!=strlist.end(); ++it) 13

14 std::cout << << *it; std::cout << \n ; return 0; 5.3 Classe deque #include <deque> #include <algorithm> #include <iostream> #include <numeric> using namespace std; template <typename T> void printdeque(deque<t> v) for (typename std::deque<t>::const_iterator it = v.begin(); it!= v.end(); it++) cout << *it << " "; cout << endl; int main () int elements[] = 3.0, 8.2, 4.0, 7.1, -0.2, -23; deque<double> doubledeque; // validando a insercao no conteiner deque for (int i = 0; i < 6; i++) doubledeque.push_front(elements[i]); 14

15 doubledeque.push_back(-0.45); // uso de iterators cout << "\nelementos do deque: " << endl; printdeque(doubledeque); // uso de reverse_iterators cout << "\nelementos do deque utilizando reverse_iterators: " << endl; for (deque<double>::const_reverse_iterator it = doubledeque.rbegin(); it < doubledeque.rend(); it++) cout << *it << " "; // useo de reverse (invers~ao dos elementos) reverse(doubledeque.begin(),doubledeque.end()); cout << endl << "\nelementos do deque após invers~ao: " << endl; printdeque(doubledeque); // uso de replace (método de substituiç~ao) replace(doubledeque.begin(),doubledeque.end(), -0.45, -0.5); cout << "\nsubstituindo por -0.5 em todo o deque: " << endl; printdeque (doubledeque); //ordenando os elementos do vetor sort(doubledeque.begin(),doubledeque.end()); cout << "\nelementos ordenados: " << endl; printdeque(doubledeque); // acumulador double valorac = accumulate (doubledeque.begin(),doubledeque.end(),0); cout << "\nsoma de todos os elementos do deque: " << valorac; 15

16 return 0; 5.4 Classe set e multiset #include <set> #include <iostream> using namespace std; using std::cout; typedef std::multiset<int> Ims; template <typename T> void printset(set<t> v) for (typename std::set<t>::const_iterator it = v.begin(); it!= v.end(); it++) cout << *it << " "; cout << endl; template <typename T> void printmultiset(multiset<t> v) for (typename std::multiset<t>::const_iterator it = v.begin(); it!= v.end(); it++) cout << *it << " "; cout << endl; int main () 16

17 const int SIZE = 10; int elements[] = 3, 8, 3, 4, 4, 7, 8, 2, 2, 1; // declaraç~ao de dois multisets de inteiros e um set de inteiros multiset<int> intmultiset1, intmultiset2; set<int> intset; // validando a insercao nos conteineres set e multiset for (int i = 0; i < SIZE; i++) intset.insert(elements[i]); intmultiset1.insert(elements[i]); // outra forma de inserç~ao intmultiset2.insert(elements,elements+size); // Impress~ao dos resultados cout << "\nelementos em intset:"; printset (intset); cout << "\nelementos em intmultiset1:"; printmultiset (intmultiset1); cout << "\nelementos em intmultiset2:"; printmultiset (intmultiset2); // ratificando a diferenca de set e multiset com // relaç~ao às chaves duplicadas cout << "\nhá " << intset.count (3) << " elementos iguais a 3 no set"; cout << "\nhá " << intmultiset1.count (3) << " elementos iguais a 3 no multiset"; // Usando iteradores para realizar busca de um elemento Ims::const_iterator result; // ou Ims::const_iterator result = intmultiset1.find(3); if (result!= intmultiset1.end() ) cout << "\nencontrou valor 3 em Multiset"; result = intmultiset1.find(20); 17

18 if (result!= intmultiset1.end() ) cout << "\nencontrou valor 20 em Multiset"; // Impress~ao cout << "\nelementos em intset:"; printset (intset); cout << "\nelementos em intmultiset1:"; printmultiset (intmultiset1); cout << "\nelementos em intmultiset2:"; printmultiset (intmultiset2); return 0; 5.5 Classe map e multimap #include <map> #include <iostream> using namespace std; using std::cout; typedef std::multimap<int,double> MMapType; typedef std::map<int,double> MapType; int main () // declaraç~ao de UM multimap de pares (int, double) MMapType pairs; pairs.insert(mmaptype::value_type(3,4.5) ); pairs.insert(mmaptype::value_type(10,4.5) ); pairs.insert(mmaptype::value_type(0,2.5) ); 18

19 pairs.insert(mmaptype::value_type(2,7.5) ); pairs.insert(mmaptype::value_type(2,7.5) ); cout << "\nmultimap:\n"; for (MMapType::const_iterator iter = pairs.begin(); iter!= pairs.end(); iter++) cout << iter->first << "\t" << iter->second << "\n"; // MAP n~ao aceita duplicatas MapType map; map.insert(mmaptype::value_type(3,4.5) ); map.insert(mmaptype::value_type(10,4.5) ); map.insert(mmaptype::value_type(0,2.5) ); map.insert(mmaptype::value_type(2,7.5) ); map.insert(mmaptype::value_type(2,7.5) ); cout << "\nmap:\n"; for (MapType::const_iterator iter = map.begin(); iter!= map.end(); iter++) cout << iter->first << "\t" << iter->second << "\n"; return 0; 6 Exemplos de uso de Adaptadores de Containeres 6.1 stack Um adaptador stack utiliza, por padrão, um container deque para sua implementação. Seus métodos são: push: empilha pop: desempilha empty: verifica se está vazia 19

20 top: obtém valor do topo da pilha Exemplo: using namespace std; #include <vector> #include <stack> #include <algorithm> #include <numeric> #include <iostream> int main(int argc, char* argv[]) int elementos[] = 3, 8, 4, 7, 2, 1; stack <int, vector<int> > pilha; //monta pilha sobre vetor cout << "Empilhando: "; for (int i = 0; i < 6; i++) cout << elementos[i] << " "; pilha.push(elementos[i]); cout << endl; //desempilhamento cout << "Desempilhando: "; while (!pilha.empty()) cout << pilha.top() << " "; pilha.pop(); return 0; 6.2 queue Um adaptador queue utiliza, por padrão, um container deque para sua implementação. Pode também ser implementado com list. Seus métodos são: push: enfileira pop: desenfileira 20

21 empty: verifica se está vazia front: obtém primeiro elemento da fila back: obtém último elemento da fila Exemplo: using namespace std; #include <vector> #include <stack> #include <queue> #include <iostream> int main(int argc, char* argv[]) int elementos[] = 3, 8, 4, 7, 2, 1; queue <int> fila; //monta pilha sobre vetor cout << "Enfileirando: "; for (int i = 0; i < 6; i++) cout << elementos[i] << " "; fila.push(elementos[i]); //desenfileiramento cout << "Desenfileirando: "; while (!fila.empty()) cout << fila.front() << " "; fila.pop(); return 0; 6.3 priority queue Um adaptador priority queue utiliza, por padrão, um container vector para sua implementação. Pode também ser implementado com deque. A inserção é feita de acordo com a prioridade dos elementos inseridos; por padrão a prioridade é definida pelo valor do elemento, porém pode-se fornecer um outro comparador que estenda o objeto de função less<t> e redefina o método operator() (x, y) que retorna true se x < y. 21

22 Os métodos de priority queue são os mesmos de deque. Exemplo: using namespace std; #include <vector> #include <stack> #include <queue> #include <iostream> #include <functional>//para permitir a extens~ao de less template <class T> class my_less: public less<t> public: bool operator()(const T& x, const T& y) ; if (strcmpi(x, y) < 0) return true; else return false; //redefiniç~ao do significado da compara int main(int argc, char* argv[]) char* elementos[] = "abacaxi", "uva", "mamao"; priority_queue<char*, vector<char*>, my_less<char*> > filap; cout << "Enfileirando: "; for (int i = 0; i < 3; i++) cout << elementos[i] << " "; filap.push(elementos[i]); //desenfileiramento cout << endl << "Desenfileirando: "; while (!filap.empty()) cout << filap.top() << " "; filap.pop(); return 0; 22