¿Cuál es el uso de los vectores de C++?

El contenedor vectorial es una clase de plantilla que puede almacenar cualquier tipo de objeto (pero debe ser el mismo tipo de objeto). Los objetos vectoriales pueden agregar elementos de manera eficiente en tiempo de ejecución y los elementos en el vector se almacenan continuamente.

Construcción de vectores

Prototipo funcional:

Plantilla & ltNombre del tipo T>

Vector explícito() // Constructor predeterminado, vector; El objeto está vacío.

Vector explícito(size_type n, const T & ampv = T()); //Crea un objeto vectorial con n elementos.

Vector (suma de vectores constante. Todos los objetos se inicializan. Si no se especifica ningún valor inicial para el objeto almacenado, el tipo incorporado se inicializará a 0 y el tipo de clase se inicializará a su constructor predeterminado (si hay otros constructores pero no hay un constructor predeterminado, el valor inicial del elemento debe debe proporcionarse antes de que pueda colocarse en el contenedor).

Por ejemplo:

Vector & lt string & gtv 1; //Crea un contenedor vacío de clase de cadena de tipo objeto.

Vector <String>v2(10); //Crea un contenedor que contiene 10 objetos similares a cadenas con valores iniciales (es decir, cadenas vacías).

Vector <String>v3(5,"Hello"); //Crea un contenedor que contenga cinco objetos similares a cadenas con el valor "hello"

Vector <String& gtv4(v3. begin() , v3. end()); // v4 y v3 son el mismo contenedor (copia completa).

Operaciones vectoriales (las siguientes funciones son todas funciones miembro)

bool vacío() const; // Devuelve verdadero si el contenedor está vacío; de lo contrario, devuelve falso;

size_type max_size() const; //Devuelve el número máximo de elementos que puede contener el contenedor.

size_type size() const; //Devuelve el número de elementos en el contenedor.

size_type capacidad () constante; //El número de elementos que el contenedor puede almacenar, incluyendo: capacidad ()》= tamaño ()

Reserva no válida (size_type n); / Asegúrese de que capacidad()》= n

void resize(size_type n, T x = T() // Asegúrese de que haya después de return: size() == n; p>Referencia front(); //Devuelve una referencia al primer elemento en el contenedor (el contenedor no debe estar vacío)

const_reference front() const;

Referencia atrás (); //Devuelve una referencia al último elemento del contenedor (el contenedor no debe estar vacío)

const _ reference back (const);

Operador de referencia [] (size_type pos); // Devuelve una referencia al elemento con el subíndice pos (el subíndice comienza desde 0; si el subíndice es incorrecto, es un comportamiento indefinido.

operador const_reference []( size_type pos) const ;

Referenciado en (size_type pos); //Devuelve una referencia al elemento con subíndice pos; si el subíndice es incorrecto, se generará una excepción out_of_range.

const _reference at (size_type pos);

void push back (const T & ampx); //Agrega elemento al final del contenedor

void; pop_back();//Extraiga el último elemento en el contenedor (el contenedor no debe estar vacío)

//Nota: Las siguientes operaciones de inserción y eliminación moverán elementos (para mantener la naturaleza de almacenamiento continuo), por lo que el iterador anterior puede no ser válido.

Iterator insert(iterator.x = T()); //Inserta un elemento antes del elemento del punto de inserción (o inserta un elemento en el punto de inserción)

void insert(iterator). it, size_type n, const T & ampx); //Tenga en cuenta que es posible que el iterador ya no sea válido (se puede reasignar espacio).

void insert (iterator it, const_iterator first, const _ iterator last);

Iterator erase (iterator it); //Elimina el elemento especificado y vuelve al siguiente después de eliminarlo; elemento La posición de un elemento (si no hay ningún elemento, devuelve end()).

Borrado de iterador (iterador primero, iterador último); // Nota: después de eliminar un elemento, el iterador correspondiente al elemento después del punto de eliminación ya no es válido.

void clear() const; // Limpiar el contenedor, lo que equivale a llamar a erase(begin(), end())

void asignar(size_type n, const T & ampx = T()); // Asignación, reemplaza todos los elementos en el contenedor con la secuencia de elementos especificada.

void asignar (const_iterator al frente, const _ iterator atrás);

const _ iterator begin() const //Secuencia de iteración

Iterador comienza; ();

const_iterator end()const;

Iterador end();

const_reverse_iterator r comenzar()const;

revertir _ iterador r comenzar();

const _ reverso _ iterador render() const;

reverso _ iterador render()

Comparación de objetos vectoriales ( función no miembro)

Hay seis operadores de comparación que se utilizan para comparar objetos vectoriales: operador==, operador! =, operador & lt, operador & lt=, operador & gt, operador & gt=.

Entre ellos, para operador == y operador! =, dos objetos vectoriales son iguales si los objetos vectoriales tienen el mismo número de elementos y todos los elementos en las posiciones correspondientes son iguales, de lo contrario, espere;

Para operadores

Nota: De hecho, ¡solo necesitas implementar operator== y operator! = es suficiente, se pueden implementar otros en base a estos dos elementos. ¡Porque operador! = (izq, dcha) ¡Así es! (lhs == rhs), operador & lt= (lhs, rhs) ¡Así es! (rhs <.lhs), operador & gt (izquierda, derecha) es (derecha

Iterador de clase vectorial

El iterador de clase vectorial no solo admite prefijos generales El operador de incremento automático también admite operaciones aritméticas: it+n, it-n, it2-it1 Tenga en cuenta que el valor de retorno de it2-it1 es Difference_type (tipo con signo)

Tenga en cuenta que cualquier cambio en el tamaño del contenedor puede causar. el iterador anterior falla.

Ejemplos de aplicación

# include & ltiostream & gt

# include & ltcassert & gt

# include & ltvector & gt

Usar espacio de nombres std

int main()

{

vector & lt string & gtv(5, "hola") ;

Vector<String>v2(v.begin(),v.end());

assert(v==v2);

cout <<">antes de la operación"<endl

for(vector<string>* const_iterator it = v.begin();it<v.end(); ++it)

cout & lt& lt* it & lt& ltendl

v . insert(v . comenzar() + 3, 4, "Hola mundo");

cout<<">insert"<<endl

for(vector<string>* size_type i = 0;i<v.size( ); ++i)

cout & lt& ltv【I】& lt;& ltendl

Vector & ltString& gt*Iterador it = v borrar (v . comenzar()+3, v. comenzar()+6);

assert(* it == "hola, mundo");

cout<<">wipe. dividir después de "& lt& ltendl

for (vector & lt; string & gt* size_type i = 0; i ! = v . size (); ++i)

cout & lt& ltv【I】& lt;& ltendl

assert(v . comenzar() + v . tamaño() = = v . end()

asertar (v. end()-v.size()==v.begin());

assert(v.begin()-v.end()==-vector< string & gt* diferencia_tipo(v .size()));

Retorno 0;

}

Descripción del programa: el programa anterior utiliza tres bucles para generar los elementos en el contenedor, y el método transversal de cada bucle es diferente. En particular, el segundo bucle usa la función size() en la condición en lugar de guardarla en una variable antes de usarla. Esto se debe a dos razones: en primer lugar, si el número de elementos del contenedor se modifica en el bucle cuando el programa se modifique en el futuro, el bucle seguirá funcionando bien, pero guardar el valor de la función size() en primer lugar es incorrecto; en segundo lugar, porque estas funciones pequeñas (cuya implementación solo requiere una declaración de retorno) se declaran básicamente en línea, por lo que no es necesario considerar problemas de eficiencia.

Aún hay muchas sugerencias en Internet. Será mejor que compres un stl y veas si tiene contenido más detallado y contenido más básico.