¿Cómo decide C++ utilizar vector, cola o pila?

}

Tipos de vectores de biblioteca estándar

Utilice los archivos de encabezado necesarios:

# include & ltvector & gt

Vector: Un vector es una plantilla de clase. No es un tipo de datos. Vector <int> es un tipo de datos.

1. Definición e inicialización

Vector & ltT & gtv 1; //El constructor predeterminado v1 está vacío.

Vector & ltT & gtv2(v 1); // v2 es una copia de v1.

Vector <T>v3(n,I); //v3 contiene n elementos con valor I.

Vector <T>v4(n) //v4 contiene n elementos con valor 0.

Segundo, inicialización de valor

1》Si no se especifica ningún inicializador de elemento, la biblioteca estándar proporcionará un valor de inicialización para la inicialización del valor.

2>Si la fórmula guardada contiene un elemento de un tipo de clase con un constructor, la biblioteca estándar se inicializa con el constructor de ese tipo.

3>Si la fórmula guardada no tiene un elemento de tipo clase con un constructor, la biblioteca estándar generará un objeto con un valor inicial y usará ese objeto para inicializar el valor.

En tercer lugar, la operación más importante de los objetos vectoriales

1. Agrega un dato con valor t al final de la matriz.

2. El tamaño de los datos utilizados actualmente.

3. Determina si el vector está vacío.

4.v[n] devuelve el elemento en la posición n en v.

5.v1=v2 reemplaza los elementos de v1 con una copia del elemento v2.

6.v1==v2 determina si v1 y v2 son iguales.

7.! =, < y <=,>,gt;= conservan el significado habitual de estos operadores.

Tipo de contenedor vectorial

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 tipo cadena 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(); //Extrae 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 detrá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! =

¡Sí! (lhs == rhs), operador & lt = (lhs, rhs) ¡Así es! (rhs <.

lhs), operador & gt (izquierda, derecha) es (derecha

! (izquierda y derecha).

Iterador de clase vectorial

El iterador de clase vectorial no solo admite el operador de incremento de prefijo general, sino que también admite operaciones aritméticas: it+n, it-n, it2-it1. Tenga en cuenta que it2-it1. tipo).

Tenga en cuenta que cualquier operación que cambie el tamaño del contenedor puede provocar que falle el iterador anterior.

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 size() en el juicio condicional.

Funció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.