I. ¿Qué es vector?

Un vector es un contenedor secuencial (Sequence Container) que encapsula un arreglo de tamaño dinámico. Al igual que cualquier otro tipo de contenedor, puede almacenar objetos de varios tipos. Puede considerarse simplemente como un arreglo dinámico que puede almacenar cualquier tipo de datos.

II. Características del contenedor

1. Secuencia ordenada

Los elementos del contenedor secuencial se ordenan en un orden estrictamente lineal. Se puede acceder a los elementos correspondientes mediante su posición en la secuencia.

2. Arreglo dinámico

Admite acceso directo y rápido a cualquier elemento de la secuencia, incluso mediante aritmética de punteros. Proporciona operaciones relativamente rápidas para añadir/eliminar elementos al final de la secuencia.

3. Consciente del asignador de memoria (Allocator-aware)

El contenedor utiliza un objeto asignador de memoria para gestionar dinámicamente sus necesidades de almacenamiento.

III. Implementación de funciones básicas

1. Constructores
  • vector(): crea un vector vacío
  • vector(int nSize): crea un vector con nSize elementos
  • vector(int nSize, const t& t): crea un vector con nSize elementos, todos con valor t
  • vector(const vector&): constructor de copia
  • vector(begin,end): copia en el vector los elementos de otro arreglo en el intervalo [begin,end)

2. Funciones de añadir

  • void push_back(const T& x): añade un elemento x al final del vector
  • iterator insert(iterator it, const T& x): inserta un elemento x antes del elemento señalado por el iterador en el vector
  • iterator insert(iterator it, int n, const T& x): inserta n elementos iguales a x antes del elemento señalado por el iterador en el vector
  • iterator insert(iterator it, const_iterator first, const_iterator last): inserta los datos en el intervalo [first,last) de otro vector del mismo tipo antes del elemento señalado por el iterador en el vector

3. Funciones de borrado

  • iterator erase(iterator it): elimina el elemento señalado por el iterador en el vector
  • iterator erase(iterator first, iterator last): elimina los elementos en [first,last) del vector
  • void pop_back(): elimina el último elemento del vector
  • void clear(): borra todos los elementos del vector

4. Funciones de recorrido

  • reference at(int pos): devuelve una referencia al elemento en la posición pos
  • reference front(): devuelve una referencia al primer elemento
  • reference back(): devuelve una referencia al último elemento
  • iterator begin(): devuelve el puntero de inicio del vector, que apunta al primer elemento
  • iterator end(): devuelve el puntero final del vector, que apunta a la posición siguiente al último elemento
  • reverse_iterator rbegin(): iterador inverso, apunta al último elemento
  • reverse_iterator rend(): iterador inverso, apunta a la posición anterior al primer elemento

5. Funciones de comprobación

  • bool empty() const: comprueba si el vector está vacío; si está vacío, no contiene elementos

6. Funciones de tamaño

  • int size() const: devuelve el número de elementos del vector
  • int capacity() const: devuelve el número máximo de elementos que el vector puede contener actualmente
  • int max_size() const: devuelve el número máximo permitido de elementos del vector

7. Otras funciones

  • void swap(vector&): intercambia los datos de dos vectores del mismo tipo
  • void assign(int n, const T& x): asigna el valor x a los primeros n elementos del vector
  • void assign(const_iterator first, const_iterator last): asigna al vector actual los elementos en [first,last)

8. Para que quede claro

1. push_back añade un dato al final del arreglo

2. pop_back elimina el último dato del arreglo

3. at obtiene el dato de la posición indicada

4. begin obtiene el puntero al inicio del arreglo

5. end obtiene el puntero a la última celda +1 del arreglo

6. front obtiene una referencia al inicio del arreglo

7. back obtiene una referencia a la última celda del arreglo

8. max_size obtiene el tamaño máximo que puede tener el vector

9. capacity tamaño actualmente asignado al vector

10. size tamaño de los datos actualmente en uso

11. resize cambia el tamaño de los datos actualmente en uso; si es mayor que el actual, rellena con valores predeterminados

12. reserve cambia el tamaño del espacio asignado actualmente al vector

13. erase elimina el dato al que apunta el puntero

14. clear vacía el vector actual

15. rbegin devuelve el puntero de inicio del vector invertido (en realidad es end-1 original)

16. rend devuelve el puntero final del vector invertido (en realidad es begin-1 original)

17. empty comprueba si el vector está vacío

18. swap intercambia datos con otro vector

IV. Uso básico

#include < vector> 
using namespace std;

V. Breve introducción

  1. Vector<tipo> identificador
  2. Vector<tipo> identificador(capacidad máxima)
  3. Vector<tipo> identificador(capacidad máxima, valor inicial para todos)
  4. Int i[5]={1,2,3,4,5}
    Vector<tipo> vi(I, i+2); // obtiene los valores posteriores al índice i cuando su valor es 3
  5. Vector< vector< int> >v; vector bidimensional // aquí los <> más externos deben tener un espacio; de lo contrario, no compila en compiladores antiguos

Ejemplo

1. Ejemplo de pop_back() y push_back(elem): eliminar e insertar datos al final del contenedor

Ejemplo

#include <string.h> #include <vector> #include <iostream> using namespace std; int main() { vector<int>obj;// crear un contenedor de tipo vector para almacenar int for(int i=0;i<10;i++) // push_back(elem) añade datos al final del arreglo { obj.push_back(i); cout<<obj[i]<<","; } for(int i=0;i<5;i++)// elimina el último dato del arreglo { obj.pop_back(); } cout<<"\n"<<endl; for(int i=0;i<obj.size();i++)// size() número real de datos en el contenedor { cout<<obj[i]<<","; } return 0; }

El resultado de la salida es:

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

0,1,2,3,4,

2. clear() borra todos los datos del contenedor

Ejemplo

#include <string.h> #include <vector> #include <iostream> using namespace std; int main() { vector<int>obj; for(int i=0;i<10;i++)// push_back(elem) añade datos al final del arreglo { obj.push_back(i); cout<<obj[i]<<","; } obj.clear();// borra todos los datos del contenedor for(int i=0;i<obj.size();i++) { cout<<obj[i]<<endl; } return 0; }

El resultado de la salida es:

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

3. Ordenación

Ejemplo

#include <string.h> #include <vector> #include <iostream> #include <algorithm> using namespace std; int main() { vector<int>obj; obj.push_back(1); obj.push_back(3); obj.push_back(0); sort(obj.begin(),obj.end());//De menor a mayor cout<<"De menor a mayor:"<<endl; for(int i=0;i<obj.size();i++) { cout<<obj[i]<<","; } cout<<"\n"<<endl; cout<<"De mayor a menor:"<<endl; reverse(obj.begin(),obj.end());//De mayor a menor for(int i=0;i<obj.size();i++) { cout<<obj[i]<<","; } return 0; }

El resultado de salida es:

从小到大:
0,1,3,

从大到小:
3,1,0,

1. Nota: sort necesita un archivo de cabecera#include <algorithm>

2. Si se quiere que sort ordene en orden descendente, se puede reescribir sort

bool compare(int a,int b) 
{ 
    return a< 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);

4. Acceso (acceso directo por índice y acceso mediante iteradores)

Ejemplo

#include <string.h> #include <vector> #include <iostream> #include <algorithm> using namespace std; int main() { //Acceso secuencial vector<int>obj; for(int i=0;i<10;i++) { obj.push_back(i); } cout<<"Usando directamente el arreglo:"; for(int i=0;i<10;i++)//Método uno { cout<<obj[i]<<" "; } cout<<endl; cout<<"Usando el iterador:" ; //Método dos, usar un iterador para generar los datos del contenedor vector<int>::iterator it;//Declarar un iterador para acceder al contenedor vector; función: recorrer o apuntar a los elementos del contenedor vector for(it=obj.begin();it!=obj.end();it++) { cout<<*it<<" "; } return 0; }

El resultado de salida es:

直接利用数组：0 1 2 3 4 5 6 7 8 9 
利用迭代器：0 1 2 3 4 5 6 7 8 9

5. Dos formas de definir una matriz bidimensional (el resultado es el mismo)

Método 1

#include <string.h> #include <vector> #include <iostream> #include <algorithm> using namespace std; int main() { int N=5, M=6; vector<vector<int> > obj(N); //Definir un arreglo dinámico bidimensional con tamaño de 5 filas for(int i =0; i< obj.size(); i++)//El arreglo dinámico bidimensional es de 5 filas y 6 columnas, todos los valores son 0 { obj[i].resize(M); } for(int i=0; i< obj.size(); i++)//Generar el arreglo dinámico bidimensional { for(int j=0;j<obj[i].size();j++) { cout<<obj[i][j]<<" "; } cout<<"\n"; } return 0; }

Método 2

#include <string.h> #include <vector> #include <iostream> #include <algorithm> using namespace std; int main() { int N=5, M=6; vector<vector<int> > obj(N, vector<int>(M)); //Definir un arreglo dinámico bidimensional de 5 filas y 6 columnas for(int i=0; i< obj.size(); i++)//Generar el arreglo dinámico bidimensional { for(int j=0;j<obj[i].size();j++) { cout<<obj[i][j]<<" "; } cout<<"\n"; } return 0; }

El resultado de salida es:

0 0 0 0 0 0 
0 0 0 0 0 0 
0 0 0 0 0 0 
0 0 0 0 0 0 
0 0 0 0 0 0

Dirección original: http://blog.csdn.net/w_linux/article/details/71600574