Tema 1 : Standrad Template Library
Upcoming SlideShare
Loading in...5
×
 

Tema 1 : Standrad Template Library

on

  • 1,665 views

 

Statistics

Views

Total Views
1,665
Views on SlideShare
1,290
Embed Views
375

Actions

Likes
1
Downloads
16
Comments
1

18 Embeds 375

http://notebookbymarioyc.blogspot.com 275
http://notebookbymarioyc.blogspot.ru 36
http://notebookbymarioyc.blogspot.in 16
http://notebookbymarioyc.blogspot.com.br 16
http://notebookbymarioyc.blogspot.com.au 5
http://www.slideshare.net 4
http://notebookbymarioyc.blogspot.co.uk 4
http://notebookbymarioyc.blogspot.fr 3
http://notebookbymarioyc.blogspot.tw 3
http://notebookbymarioyc.blogspot.fi 2
http://notebookbymarioyc.blogspot.com.es 2
http://notebookbymarioyc.blogspot.cz 2
http://webcache.googleusercontent.com 2
http://notebookbymarioyc.blogspot.mx 1
http://notebookbymarioyc.blogspot.it 1
http://notebookbymarioyc.blogspot.com.ar 1
http://www.blogger.com 1
http://notebookbymarioyc.blogspot.pt 1
More...

Accessibility

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • Buenos slides, gracias por compartir (Y)
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Tema 1 : Standrad Template Library Tema 1 : Standrad Template Library Presentation Transcript

  • STL : Standard Template Library Mario Ynocente Castro UNI-FIIS
  • Referencia
    • http://www.sgi.com/tech/stl/
    • http://www.cppreference.com/wiki/stl/start
    • http://www.cplusplus.com/reference/stl/
  • Ventajas
    • Estandarizada
    • Eficiente
    • Pequeña, fácil de aprender
    • Flexible
    • Código abierto
  • ¿Qué logramos?
    • Menos código
    • Escribir más rápido
    • Menos bugs
  • Notas
    • Los #include no llevan .h
    #include <cstdio> // new include method #include <vector> // vector container #include <algorithm> // STL algorithms using namespace std; // assume std::
  • Contenedores
    • Contienen elementos
    • Proveen iteradores que apuntan a sus elementos
    • Proveen un conjunto mínimo de operaciones mínimas para manipular sus elementos
  • Contenedores
  • Vector (#include <vector>) vector<int> v(10); for(int i = 0; i < 10; i++) { v[i] = (i+1)*(i+1); } int numero_elementos = v.size(); bool esta_vacio = (v.size() == 0); // Evite usar esto bool esta_vacio = v.empty();
  • Vector vector<int> v; // ... vector<int> v2(v); vector<int> v3(v.begin(), v.end()); //v3 igual a v2 int data[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31 }; vector<int> primes(data, data+(sizeof(data) / sizeof(data[0]))); vector<int> v; // ... vector<int> v2(v.begin(), v.begin() + (v.size()/2));
  • Vector vector<int> v; // ... vector<int> v2(v.rbegin()+(v.size()/2), v.rend()); vector<int> v; // ... // Traverse all container, from begin() to end() for(vector<int>::iterator it = v.begin(); it != v.end(); it++) { *it++; // Increment the value iterator is pointing to }
  • Vector vector<int> v(20); for(int i = 0; i < v.size(); i++) { v[i] = i+1; } v.resize(25); for(int i = 20; i < 25; i++) { v[i] = i*2; }
  • Vector vector< vector<int> > Matrix; int N, M; // ... vector< vector<int> > Matrix(N, vector<int>(M, -1)); vector<int> v1; // ... vector<int> v2 = v1; vector<int> v3(v1);
  • Búsqueda en Vector vector<int> v; for(int i = 1; i < 100; i++) { v.push_back(i*i); } if(find(v.begin(), v.end(), 49) != v.end()) { // ... }
  • Inserción en Vector vector<int> v; // ... v.insert(v.begin()+1, 42); // Inserta 42 luego del primer elemento //los demás se desplazan vector<int> v; vector<int> v2; // ... v.insert(1,v2.begin(),v2.end());
  • Eliminación en Vector erase(iterator); erase(iterador inicial, iterador final);
  • String (#include <string>)
    • Las cadenas estilo C no son la única forma de manejar data con caracteres.
    • C++ también te permite trabajar con una clase string , la cual soluciona problemas que se tiene al trabajar con las cadenas estilo C.
    • En particular, no tenemos que preocuparnos en manejar la memoria para la cadena.
  • String string s1 = &quot;hello&quot;; string s2 = string(s1); string s2 = s1; bool iguales = (s1==s2);
  • Constructores para String string() // vacía string(string s) // copia de s string(string s, int inicio) // sub-string string(string s, int inicio int long) // sub-string string(char* a) // string estilo C string(int cnt, char c) // uno o más caracteres string(char* inicio, char* final) // [inicio, final)
  • Operadores para String
    • = : usado para asignar un valor a una cadena
    • += : usado para concatenar un string, caracter, o cadena estilo C a un string
    • + : usado para concatenación de cadenas
    • Los operadores booleanos realizan comparaciones en el mismo orden de diccionario
  • String string s = “Harry”; s.c_str() // retorna s como una cadena C con ‘’ int num = atoi(s.c_str()); // conversión printf(”%s”,s.c_str());
  • Métodos para String string s; // ... cout<<s.size()<<endl; cout<<s.length()<<endl; if(s.empty()) cout<<”Cadena vacia”<<endl; s.clear(); if(s.empty()) cout<<”Cadena vacia”<<endl;
  • Búsqueda e Inserción en String s.find(s2); // halla la primera ocurrencia s.find(s2, inicio); // empezando en inicio s.insert(s2, pos); //inserción a partir de pos
  • Sub-String string s = &quot;hello&quot;; string s1 = s.substr(0, 3), // &quot;hel&quot; s2 = s.substr(1, 3), // &quot;ell&quot; s3 = s.substr(0, s.length()-1), &quot;hell&quot; s4 = s.substr(1); // &quot;ello&quot;
  • Set (#include <set>)
    • Agregar elementos
    • No permite duplicados
    • Remover elementos
    • Número de elementos distintos
    • Verificar si un elemento está en el Set
  • ¿Qué necesita Set?
    • Necesita un criterio de orden para determinar si hay duplicados o no
    • Se usa el operador <
    • a y b son iguales si a<b y b<a son ambos falsos
  • Set set<int> s; for(int i = 1; i <= 100; i++) { s.insert(i); } s.insert(42); // no hace nada for(int i = 2; i <= 100; i += 2) { s.erase(i); // Borrar todos los valores pares } int n = int(s.size()); // n será 50
  • Set if(s.find(42) != s.end()) { // 42 presents in set } else { // 42 not presents in set }
  • Set int data[5] = { 5, 1, 4, 2, 3 }; set<int> S(data, data+5); vector<int> v; // … set<int> s(v.begin(), v.end()); vector<int> v2(s.begin(), s.end());
  • Buscar y Borrar en Set set<int> s; // ... set<int>::iterator it1, it2; it1 = s.find(10); it2 = s.find(100); // Funcionará si it1 e it2 son iteradores válidos s.erase(it1, it2); // 10 será borrado, pero 100 permanecerá s.remove(it1);
  • Map (#include <map>) map<string, int> M; M[&quot;Top&quot;] = 1; M[&quot;Coder&quot;] = 2; M[&quot;SRM&quot;] = 10; int x = M[&quot;Top&quot;] + M[&quot;Coder&quot;]; if(M.find(&quot;SRM&quot;) != M.end()) { M.erase(M.find(&quot;SRM&quot;)); // or even M.erase(&quot;SRM&quot;) }
  • Pair template<typename T1, typename T2> struct pair { T1 first; T2 second; }; pair<string, pair<int,int> > P; string s = P.first; // extraer string int x = P.second.first; // extraer primer entero int y = P.second.second; // extract segundo entero
  • Algorithm (#include <algorithm>)
    • Aproximadamente 60 algoritmos standard
      • Búsqueda
      • Ordenamiento
      • Transformaciones
      • Numéricos
    • La mayoría de las funciones toman la forma:
    • fn(e.begin(), e.end(), ...)
  • Algorithm i nt data[5] = { 1, 5, 2, 4, 3 }; vector<int> X(data, data+5); int v1 = *max_element(X.begin(), X.end()); int i1 = min_element(X.begin(), X.end()) – X.begin(); int v2 = *max_element(data, data+5); int i3 = min_element(data, data+5) – data;
  • Algorithm vector<int> X; // ... sort(X.begin(), X.end()); // orden ascendente sort(X.rbegin(), X.rend()); // orden descendente vector<int> v; for(int i = 0; i < 10; i++) { v.push_back(i); } do { Solve(..., v); } while(next_permutation(all(v));
  • String Streams (#include <sstream>) void f(const string& s) { istringstream is(s); vector<int> v; int tmp; while(is >> tmp) { v.push_back(tmp); } }
  • String Streams string f(const vector<int>& v) { ostringstream os; for(vector<int>::iterator it=v.begin();it!=v.end();it++){ os << ' ' << *it; } s = os.str(); if(!s.empty()) s = s.substr(1); return s; }