C++ STL y biblioteca estándar

STL

STL (Biblioteca de plantillas estándar) es un conjunto de clases de plantillas de C++ que proporcionan clases y funciones de plantillas generales. Estas clases y funciones de plantillas pueden implementar una variedad de algoritmos y estructuras de datos populares y de uso común, como vectores, listas vinculadas, colas y pilas.

El núcleo de C++ STL consta de tres componentes:

Contenedores	Se utiliza para gestionar una colección de objetos de un determinado tipo. C++ proporciona varios tipos de contenedores, como deque, lista, vector, mapa, etc.
Algoritmos	Los algoritmos actúan sobre los contenedores. Proporcionan formas de realizar una variedad de operaciones, incluida la inicialización, clasificación, búsqueda y transformación del contenido del contenedor.
iteradores	Los iteradores se utilizan para recorrer los elementos de una colección de objetos. Estas colecciones pueden ser contenedores o subconjuntos de contenedores.

Los tres componentes vienen con ricas funciones predefinidas para ayudarnos a manejar tareas complejas de una manera sencilla.

Contenedor (vector)

definición

Vector es uno de los contenedores más utilizados: es un contenedor de secuencia (Contenedor de secuencia) que encapsula una matriz de tamaño dinámico. Como cualquier otro tipo de contenedor, puede almacenar varios tipos de objetos. Simplemente puede pensar en un vector como una matriz dinámica que puede almacenar cualquier tipo, porque su tamaño cambia según las actualizaciones en tiempo real.

La definición de vector es la siguiente:

Vector<类型> 标识符
Vector<类型> 标识符(最大容量)
Vector<类型> 标识符(最大容量,初始所有值)
Vector<类型> v(i,i+2);     //得到i索引值为3以后的值
Vector< vector< int> >v;   //二维向量,这里最外的<>要有空格。否则在比较旧的编译器下无法通过

Por ejemplo:

vector<int> v;           // 储存int型的值 
vector<double> v;        // 储存double型的值 
vector<string> v;        // 储存string型的值 
vector<struct> v;        // 储存结构体或者类的值的值 

/* 可以定义vector数组 */
vector<int> a[n];        // 储存int型的值 
vector<double> a[n];     // 储存double型的值

característica

Características del contenedor:

Secuencia secuencial: los elementos de un contenedor secuencial se ordenan en estricto orden lineal. Se puede acceder al elemento correspondiente por su posición en la secuencia.
Matrices dinámicas: admite acceso rápido y directo a cualquier elemento de la secuencia, incluso mediante aritmética de punteros. Proporciona operaciones relativamente rápidas para agregar o eliminar elementos al final de una secuencia.
Consciente del asignador: el contenedor utiliza un objeto asignador de memoria para manejar dinámicamente sus necesidades de almacenamiento.

función miembro

Constructor

vector();                       //创建一个空vector
vector(int nSize);              //创建一个vector,元素个数为nSize
vector(int nSize,const t& t);   //创建一个vector，元素个数为nSize,且值均为t
vector(const vector&);          //复制构造函数
vector(begin,end);              //复制[begin,end)区间内另一个数组的元素到vector中

Agregar función

/* 向量尾部增加一个元素X */
void push_back(const T& x);    
/* 向量中迭代器指向元素前增加一个元素x */              
iterator insert(iterator it,const T& x); 
/* 向量中迭代器指向元素前增加n个相同的元素x */    
iterator insert(iterator it,int n,const T& x); 
/* 向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据 */
iterator insert(iterator it,const_iterator first,const_iterator last);

función de eliminación

iterator erase(iterator it);                   //删除向量中迭代器指向元素
iterator erase(iterator first,iterator last);  //删除向量中[first,last)中元素
void pop_back();                               //删除向量中最后一个元素
void clear();                                  //清空向量中所有元素

función transversal

reference at(int pos);       //返回pos位置元素的引用
reference front();           //返回首元素的引用
reference back();            //返回尾元素的引用
iterator begin();            //返回向量头指针，指向第一个元素
iterator end();              //返回向量尾指针，指向向量最后一个元素的下一个位置
reverse_iterator rbegin();   //反向迭代器，指向最后一个元素
reverse_iterator rend();     //反向迭代器，指向第一个元素之前的位置

función de juicio

bool empty() const;          //判断向量是否为空，若为空，则向量中无元素

función de tamaño

int size() const;             //返回向量中元素的个数
int capacity() const;         //返回当前向量所能容纳的最大元素值
int max_size() const;         //返回最大可允许的vector元素数量值

/* 如果n小于当前容器的大小，则将内容减少到其前n个元素，并删除超出范围的元素（并销毁它们）*/
void resize(size_type n);    

/**
  *如果n大于当前容器的大小，则通过在末尾插入所需数量的元素来扩展内容，以达到n的大小。
  *如果指定了val，则将新元素初始化为val的副本，否则将对它们进行值初始化。
  *如果n也大于当前容器容量，将自动重新分配已分配的存储空间 
  */
void resize(size_type n, const value_type& val);

/**
  *表示预分配n个元素的存储空间，但不是真正的创建对象，
  *需要通过insert()或push_back()等操作创建对象。
  *调用reserve(n)后，若容器的capacity<n，则重新分配内存空间，从而使得capacity等于n。
  *若capacity>=n，capacity无变化。
  */
void reserve(size_type n);

La diferencia entre cambiar tamaño() y revertir()

Después de que el contenedor llama a la función resize(), todos los espacios se han inicializado y se puede acceder a ellos directamente. El espacio preasignado por la función reserve() no se ha inicializado, por lo que es inaccesible. la diferencia:

reserve() solo modifica el tamaño de la capacidad, no el tamaño.
resize() modifica tanto el tamaño de la capacidad como el tamaño.

A continuación se utilizan ejemplos para ilustrar:

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> v;
    cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << endl;
	
    v.reserve(10);
	cout<<v[5]<< endl;
    cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << endl;
	
    v.resize(10);
    v.push_back(0);
    cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << endl;

    return 0;
}

Los resultados de la ejecución son los siguientes:

v.tamaño() == 0 v.capacidad() = 0
1735357008
v.tamaño() == 0 v.capacidad() = 10
v.tamaño() == 11 v.capacidad() = 20

Nota: Para: después de v.reserve (10), use directamente [] para acceder al error fuera de límites (la memoria es salvaje), aquí use directamente [] para acceder, el vector degenera en una matriz y no hay salidas. Se emitirá un juicio fuera de los límites. En este momento, se recomienda utilizar at (), que primero realizará una verificación de límites, como se muestra a continuación:

cout<<v.at(5)<< endl;

v.size() == 0 v.capacity() = 0
termina la llamada después de lanzar una instancia de 'std::out_of_range'
what(): vector::_M_range_check: __n (que es 5) >= this->size( ) (que es 0)

Citas relacionadas:

Con respecto al atributo de capacidad, otros contenedores en STL, como list, map, set y deque, debido a que la memoria de estos contenedores está distribuida mediante hash, no se producirán llamadas como realloc (), por lo que se puede considerar que el atributo de capacidad es dirigido a estos contenedores. Los contenedores no tienen sentido, por lo que estos contenedores están diseñados sin esta propiedad. En STL, los únicos contenedores con atributos de capacidad son vector y cadena.

La diferencia entre capacidad() y tamaño()

size() : el tamaño real ocupado por el contenedor de vectores actual, es decir, la cantidad de elementos almacenados actualmente en el contenedor.
capacidad() : La cantidad total máxima que el contenedor puede almacenar, es decir, el espacio de memoria preasignado.

Estas dos propiedades corresponden a dos métodos: resize() y reserve().

otro

/* 交换两个同类型向量的数据 */
void swap(vector&);
/* 设置向量中前n个元素的值为x */
void assign(int n,const T& x);//
/* 向量中[first,last)中元素设置成当前向量元素 */
void assign(const_iterator first,const_iterator last);

Ejemplo

pop_back() y push_back()

Eliminar e insertar datos al final del contenedor:

#include<iostream>
#include<vector>
#include<string.h>

using namespace std;

int main()
{
	vector<int> obj;               // 创建一个向量存储容器 int
	for(int i=0;i<10;i++)          // 依次在数组最后添加数据
	{
		obj.push_back(i);
		cout<<obj[i]<<"\t";
	}
	
	for(int j=0;j<5;j++)           // 依次去掉数组最后一个数据 
	{
		obj.pop_back();
	}
	
	cout<<"\n"<<endl;
	
	for(int k=0;k<obj.size();k++)  // size()返回容器中实际数据个数 
	{
		cout<<obj[k]<<"\t";
	}
	
	return 0;
}

Los resultados de la ejecución son los siguientes:

0 1 2 3 4 5 6 7 8 9

0 1 2 3 4

claro()

Borre todos los datos del contenedor:

#include<string.h>
#include<vector>
#include<iostream>

using namespace std;

int main()
{
	vector<int> obj;
	for(int i=0;i<10;i++)
	{
		obj.push_back(i);
		cout<<obj[i]<<"\t";
	}
	
	obj.clear();
	cout<<endl;
	for(int i=0;i<obj.size();i++)
	{
		cout<<obj[i]<<"\t";
	}
	cout<<endl<<"size = "<<obj.size()<<", capacity = "<<obj.capacity();
	
	return 0;
}

Los resultados de la ejecución son los siguientes:

0 1 2 3 4 5 6 7 8 9

tamaño = 0, capacidad = 16

clasificar

La función sort() debe incluir el archivo de encabezado: #include <algoritmo>

#include<string.h>
#include<vector>
#include<iostream>
#include<algorithm>    // 'sort()' and 'reverse()' was declared in this Header file

using namespace std;

int main()
{
	vector<int> obj;
	
	obj.push_back(1);
	obj.push_back(2);
	obj.push_back(3);
	
	cout<<"由小到大："<<endl;
	sort(obj.begin(),obj.end());
	for(int i=0;i<obj.size();i++)
	{
		cout<<obj[i]<<"\t";
	}
	
	cout<< endl <<"由大到小："<<endl;
	reverse(obj.begin(),obj.end());
	for(int i=0;i<obj.size();i++)
	{
		cout<<obj[i]<<"\t";
	}
	
    return 0;	
}

Los resultados de la ejecución son los siguientes:

De menor a mayor:
1 2 3

De mayor a menor:
3 2 1

Si desea ordenar en orden descendente, puede reescribir ordenar

/* 升序排列，如果改为return a>b，则为降序  */
bool compare(int a,int b) 
{ 
    return a< b; 
} 

/* 示例 */
int a[20]={2,4,1,23,5,76,0,43,24,65},i; 
for(i=0;i<20;i++) 
{
    cout<< a[i]<< endl; 
}
sort(a,a+20,compare);

Como sigue:

#include<string.h>
#include<vector>
#include<iostream>
#include<algorithm>    // 'sort' and 'reverse' was declared in this Header file

using namespace std;

bool compare(int a,int b) 
{ 
    return a > b; 
} 

int main()
{
	vector<int> obj;
	
	obj.push_back(1);
	obj.push_back(2);
	obj.push_back(3);
	
	cout<<"由小到大："<<endl;
	sort(obj.begin(),obj.end());
	for(int i=0;i<obj.size();i++)
	{
		cout<<obj[i]<<"\t";
	}
	
	cout<< endl <<"由大到小："<<endl;
	sort(obj.begin(),obj.end(),compare);  //sort 来降序
	for(int i=0;i<obj.size();i++)
	{
		cout<<obj[i]<<"\t";
	}
	
    return 0;	
}

Acceso directo a la matriz y acceso al iterador

#include<iostream>
#include<string.h>
#include<vector>
#include<algorithm>

using namespace std;

int main()
{
	vector<int> obj;
	for(int i=0;i<10;i++)
	{
		obj.push_back(i);
	}

	// 方法一:直接数组访问
	cout<<"直接利用数组："<<"\t";
	for(int i=0;i<10;i++)
	{
		cout<<obj[i]<<"\t";
	}
	
	// 方法二:迭代器访问
	cout<<endl;
	cout<<"利用迭代器："<<"\t";
	vector<int>::iterator it;
	for(it=obj.begin();it!=obj.end();it++)
	{
		cout<<*it<<"\t";
	}
	
	return 0;
}

Los resultados de la ejecución son los siguientes:

Usando funciones directamente: 0 1 2 3 4 5 6 7 8 9
Usando iteradores: 0 1 2 3 4 5 6 7 8 9

Dos formas de definir matrices bidimensionales

Supongamos que se define una matriz bidimensional obj [5] [6], los resultados de los dos métodos de definición son los mismos:

método uno

#include<iostream>
#include<vector>
#include<string.h>
#include<algorithm>

using namespace std;

int main()
{
	int N=5,M=6;                   // 定义二维动态数组大小5行为5行6列,值默认全为0
	vector< vector<int> > obj(N);  // 开辟行
	for(int i=0;i<obj.size();i++)
	{
		obj[i].resize(M);          // 开辟行
	}
	
	for(int i=0;i<obj.size();i++)  // 赋值，并输出二维动态数组 
	{
		for(int j=0;j<obj[i].size();j++)
		{
			obj[i][j]=i+j;
			cout<<obj[i][j]<<"\t"; 
		}
		cout<<endl;
	}
	
	return 0;
}

Método dos

#include<iostream>
#include<vector>
#include<string.h>
#include<algorithm>

using namespace std;

int main()
{
	int N=5,M=6;                   // 定义二维动态数组大小5行为5行6列,值默认全为0
	
	/* 创建一个vector，元素个数为N,且值均为一个元素个数为M的vector<int>(M) */ 
	vector< vector<int> > obj(N,vector<int>(M)); 
	
	for(int i=0;i<obj.size();i++)  // 赋值，并输出二维动态数组 
	{
		for(int j=0;j<obj[i].size();j++)
		{
			obj[i][j]=i+j;
			cout<<obj[i][j]<<"\t"; 			
		}
		cout<<endl;
	}

	return 0;
}

La salida es:

0 1 2 3 4 5
1 2 3 4 5 6
2 3 4 5
6 7 3 4 5 6 7 8
4 5 6 7 8 9

biblioteca estándar

La biblioteca estándar de C++ se puede dividir en dos partes:

Biblioteca de funciones estándar: consta de funciones generales independientes que no pertenecen a ninguna clase. Se hereda del lenguaje C.
Biblioteca de clases orientada a objetos: esta biblioteca es una colección de clases y sus funciones asociadas.

La biblioteca estándar de C++ contiene todas las bibliotecas estándar de C, con ciertas adiciones y modificaciones realizadas para admitir la seguridad de tipos.

Biblioteca de funciones estándar

La biblioteca de funciones estándar se divide en las siguientes categorías:

E/S de entrada/salida
Manejo de cadenas y caracteres.
matemáticas
Hora, fecha y localización.
asignación dinámica
otro
funciones de caracteres amplios

biblioteca de clases orientada a objetos

La biblioteca de clases orientada a objetos define una gran cantidad de clases que admiten algunas operaciones comunes, como E/S de entrada/salida, procesamiento de cadenas y procesamiento numérico. La biblioteca de clases orientada a objetos contiene el siguiente contenido:

Clases de E/S estándar de C++
clase de cadena
clase numérica
Clase de contenedor STL
Algoritmo STL
Objeto de función STL
iterador STL
Asignador STL
biblioteca de localización
Clase de manejo de excepciones
Bibliotecas de soporte diversas