Una guía para principiantes de la biblioteca de plantillas estándar en C ++

julio 12, 2021 Aranzulla de Los Pobres

C ++ es uno de los lenguajes de programación más poderosos e intimidantes que puede encontrar como principiante. La razón es bastante sencilla. Requiere mucho código para lograr el resultado deseado. La biblioteca de plantillas estándar, o STL, puede ayudarlo a resolver este enigma.

Teniendo en cuenta la cantidad de tiempo y esfuerzo consumidos al escribir código para funciones como ordenar y buscar, STL puede ayudarlo a realizar todas estas operaciones con una sola línea de código. Esta biblioteca puede ser inmensamente útil para la resolución de problemas y la preparación de entrevistas técnicas.

¿Qué es la biblioteca de plantillas estándar?

La biblioteca de plantillas estándar, o STL, es una biblioteca de C ++ que consta de funciones y contenedores prediseñados. Incluye algunas clases de plantilla destacadas para estructuras de datos comunes como vectores, pilas, colas y algunas funciones algorítmicas útiles como la búsqueda binaria para facilitar la programación.

La biblioteca de plantillas estándar en C ++ consta de cuatro componentes:

Algoritmos
Contenedores
Funciones
Iteradores

Echemos un vistazo a los algoritmos y contenedores con mayor profundidad, ya que son los componentes de STL más utilizados.

Algoritmos en STL

El archivo de encabezado <algorithm> es una parte del STL que consta de varias funciones algorítmicas que se pueden usar en lugar de codificarlas manualmente. Algunos de los algoritmos incluidos son búsqueda binaria, clasificación e inversión, que son extremadamente útiles.

Para empezar, necesita importar el encabezado <algorithm> en su archivo C ++. La sintaxis es la siguiente:

 #include <algorithm>

Para los próximos métodos, considere una variable de matriz con los valores de {6, 2, 9, 1, 4} como ejemplo.

 int arr[] = {6, 2, 9, 1, 4};

clasificar()

La función sort () le ayuda a ordenar todos los elementos dentro de la estructura de datos especificada en orden ascendente. Esta función toma dos parámetros: el iterador inicial y el iterador final.

Relacionado: Introducción al algoritmo de clasificación por fusión

Sintaxis:

 sort(start_iterator, end_iterator);

He aquí un ejemplo rápido:

 sort(arr, arr+5);
 for (int i = 0; i < 5; i++) {
 cout << arr[i] << " ";
 }

Producción:

 1 2 4 6 9

contrarrestar()

La función reverse () invierte el orden de los elementos en la estructura de datos especificada. Acepta dos parámetros: el iterador inicial y el iterador final.

Sintaxis:

 reverse(start_iterator, end_iterator);

Aquí hay un breve ejemplo del método anterior:

 reverse(arr, arr+5);
 for(int i = 0; i < 5; i++) {
 cout << arr[i] << " ";
 }

Producción:

 4 1 9 2 6

* min_element () y * max_element ()

Las funciones * max_element () y * min_element () devuelven el valor máximo y mínimo dentro de la estructura de datos especificada, respectivamente. Ambas funciones aceptan dos argumentos: el iterador inicial y el iterador final.

Sintaxis:

 *max_element(start_iterator, end_iterator);
 *min_element(start_iterator, end_iterator);

Averigüemos qué valores devuelven estas funciones al llamarlas en la matriz de ejemplo:

 cout << *max_element(arr, arr+5) << endl;
 cout << *min_element(arr, arr+5) << endl;

Producción:

 9
 1

búsqueda binaria()

El método binary_search () se utiliza para encontrar si el valor especificado está presente dentro de la estructura de datos o no. Acepta tres argumentos: el iterador inicial, el iterador final y el valor que desea encontrar.

La búsqueda binaria solo funciona en estructuras de datos ordenadas. Por lo tanto, primero deberá llamar al método sort () antes que al método binary_search () .

Sintaxis:

 binary_search(start_iterator, end_iterator, value_to_find)

Aquí hay una demostración de este método:

 sort(arr, arr+5);
 binary_search(arr, arr+5, 2) ? cout << "Element found" : cout << "Element not found";
 binary_search(arr, arr+5, 7) ? cout << "Element found" : cout << "Element not found";

Producción:

 Element found
 Element not found

contar()

El método count () devuelve el recuento de ocurrencia del valor especificado dentro de la estructura de datos. Se necesitan tres argumentos: el iterador inicial, el iterador final y el valor para contar.

Sintaxis:

 count(start_iterator, end_iterator, value_to_count);

A continuación, se muestra un ejemplo de este método:

 cout << count(arr, arr+5, 2) << endl;

Producción:

Contenedores en STL

Los contenedores son las estructuras de datos que almacenan objetos y datos. Vectores, listas, pilas, colas, conjuntos y mapas son algunos de los ejemplos que almacenan datos en ellos de acuerdo con el tipo de datos primitivo especificado. Puede utilizar estos contenedores importando sus respectivos encabezados en el archivo C ++.

Al inicializar la variable contenedora, debe mencionar los datos primitivos como int , char , string dentro de los corchetes <> .

Exploremos algunos de estos contenedores con mayor detalle:

Vector

Los vectores son matrices dinámicas que son redimensionables y flexibles para trabajar. Cuando inserta o elimina un elemento del vector, ajusta automáticamente el tamaño del vector. Esto es similar a la estructura de datos ArrayList en Java.

Sintaxis:

 #include <vector>
 vector<data_type> variable_name;

A continuación, se muestran algunos métodos vectoriales importantes:

push_back (valor) : este método agrega los datos al vector.
pop_back () : este método elimina el último elemento del vector.
insertar (índice, valor) : este método inserta nuevos elementos antes del elemento en la posición especificada.
size () : este método devuelve el tamaño del vector.
empty () : este método comprueba si el vector está vacío o no.
front () : este método devuelve el primer valor del vector.
back () : el método back devuelve el último valor del vector.
at (índice) : este método devuelve el valor en la posición especificada.
borrar (índice) : el método borrar elimina elementos del índice dado.
clear () : este método borra todos los elementos del vector.

 vector < int > v = { 23, 12, 56, 10 };
 v.push_back(5);
 v.push_back(25);
 v.pop_back();
 auto i = v.insert(v.begin() + 1, 7);
 cout << "The size of the given vector " << v.size() << endl;
 if (v.empty()) {
 cout << "Vector is empty" << endl;
 } else {
 cout << "Vector is not empty" << endl;
 }
 cout << "Element at the first position is " << v.front() << endl;
 cout << "Element at the last position is " << v.back() << endl;
 cout << "Element at the given position is " << v.at(4) << endl;
 v.erase(v.begin() + 1);
 for (int i = 0; i < v.size(); i++) {
 cout << v[i] << " ";
 }

Producción:

 The size of the given vector 6
 Vector is not empty
 Element at the first position is 23
 Element at the last position is 5
 Element at the given position is 10
 23 12 56 10 5

Cola

En la estructura de datos de la cola, los elementos se insertan desde atrás y se eliminan desde el frente. Por lo tanto, sigue el enfoque FIFO ("primero en entrar, primero en salir").

Sintaxis:

 #include <queue>
 queue<data_type> variable_name;

A continuación, se muestran algunos métodos de cola importantes:

empujar (valor ): este método agrega elementos a la cola.
pop () : este método elimina el primer elemento de la cola.
size () : este método devuelve el tamaño de la cola.
front () : este método devuelve el primer elemento de la cola.
back () : este método devuelve el último elemento de la cola.

 queue < int > q;
 q.push(30);
 q.push(40);
 q.push(50);
 q.push(60);
 q.push(70);
 cout << "The first element is " << q.front() << endl;
 cout << "The last element is " << q.back() << endl;
 cout << "The size of queue is " << q.size() << endl;
 q.pop();
 cout << "Printing all the elements of the Queue" << endl;
 while (!q.empty()) {
 cout << q.front() << " ";
 q.pop();
 }

Producción:

 The first element is 30
 The last element is 70
 The size of the queue is 5
 Printing all the elements of the Queue
 40 50 60 70

Apilar

Los contenedores apilados funcionan con el método LIFO. LIFO significa "último en entrar, primero en salir". Los datos se empujan y se extraen desde el mismo extremo.

Sintaxis:

 #include <stack>
 stack<data_type> variable_name;

A continuación, se muestran algunos métodos de pila importantes:

empujar (valor ): este método empuja el elemento en la pila.
pop () : este método elimina el elemento superior de la pila.
top () : este método devuelve el valor del último elemento ingresado en la pila.
size () : este método devuelve el tamaño de la pila.
empty () : este método comprueba si la pila está vacía o no.

 stack < int > s;
 s.push(30);
 s.push(40);
 s.push(50);
 s.push(60);
 cout << "The top of the stack contains " << s.top() << endl;
 s.pop();
 cout << "The top of the stack after performing pop operation: " << s.top() << endl;
 cout << "Printing all elements of the stack" << endl;
 while (!s.empty()) {
 cout << s.top() << " ";
 s.pop();
 }

Producción:

 The top of the stack contains 60
 The top of the stack after performing pop operation: 50
 Printing all elements of the stack
 50 40 30

Colocar

Los contenedores de conjuntos se utilizan para contener valores únicos y el valor del elemento no se puede cambiar una vez que se inserta en el conjunto. Todos los elementos del conjunto se almacenan de forma ordenada. El contenedor de conjuntos es similar a la estructura de datos de conjuntos en Python .

Sintaxis:

 #include <set>
 set<data_type> variable_name;

A continuación, se muestran algunos métodos de conjuntos importantes:

insertar (valor) : este método inserta elementos en el conjunto.
begin () : este método devuelve el iterador al primer elemento del conjunto.
end () : este método devuelve el iterador al último elemento del conjunto.
size () : este método devuelve el tamaño del conjunto.
vacío () : este método comprueba si el conjunto está vacío o no.
find (value) : este método devuelve el iterador al elemento pasado en el parámetro. Si no se encuentra el elemento, esta función devuelve el iterador al final del conjunto.
borrar (valor) : este método eliminó el elemento especificado del conjunto.

 set < int > s;
 s.insert(20);
 s.insert(30);
 s.insert(40);
 s.insert(50);
 s.insert(60);
 s.insert(60);
 s.insert(60);
 auto i = s.begin();
 cout << "Element at the first position " << * i << endl;
 cout << "The size of the set " << s.size() << endl;
 s.find(20) != s.end() ? cout << "Element found" << endl : cout << "Element not found" << endl;
 s.erase(30);
 cout << "Printing all the elements" << endl;
 for (auto i = s.begin(); i != s.end(); i++) {
 cout << * i << " ";
 }

Producción:

 Element at the first position 20
 The size of the set 5
 Element found
 Printing all the elements
 20 40 50 60

C ++ no tiene por qué ser difícil

Al igual que cualquier otra habilidad, la práctica es esencial para aprovechar al máximo el STL. Estos contenedores y algoritmos pueden ayudarlo a ahorrar mucho tiempo y son fáciles de usar. Comience practicando los ejemplos que se muestran arriba y eventualmente comenzará a usarlo también en sus propios proyectos.

Sin embargo, si es la primera vez que aprende C ++, comience por aprender los conceptos básicos antes de proceder a comprender el STL.