Plantilla estándar C++11 (STL) std::vector (5)

Definido en el archivo de cabecera <vector>

plantilla<     clase T,     asignador de clase = std::allocator<T> > vector de clase;	(1)
espacio de nombres pmr {     template <clase T>     usando vector = std::vector<T, std::pmr::polymorphic_allocator<T>>; }	(2)	(desde C++17)

 1) std::vectores un contenedor secuencial que encapsula una matriz dinámica.

2) std::pmr::vectores un alias de plantilla que utiliza un asignador polimórfico.

Los elementos se almacenan secuencialmente, lo que significa que se puede acceder a los elementos no solo a través de iteradores, sino también con punteros regulares a los elementos. Esto significa que un puntero a un elemento vectorial se puede pasar a cualquier función que espere un puntero a un elemento de matriz.

(desde C++03)

El almacenamiento de vectores se gestiona automáticamente, ampliándose y reduciéndose según demanda. Por lo general, un vector ocupa más espacio que una matriz estática porque se asigna más memoria para administrar el crecimiento futuro. La forma en que se usa el vector no es para reasignar cada vez que se inserta un elemento, sino solo cuando se agota la memoria adicional. La cantidad total de memoria asignada se puede consultar con la función de capacidad(). Se puede devolver memoria adicional al sistema a través de una llamada a shrink_to_fit(). (desde C++11)

La reasignación suele ser una operación de alto rendimiento. La función reserve() se puede utilizar para eliminar la reasignación si se conoce el número de elementos.

La complejidad (eficiencia) de las operaciones comunes en vectores es la siguiente:

• Acceso aleatorio - constante O(1)
• Insertar o quitar elementos al final - constante amortizada O(1)
• Insertar o quitar elementos - O(n) lineal en distancia al final del vector

std::vector(Para boolotros T) Satisfacer los requisitos de Container , AllocatorAwareContainer , SequenceContainer , ContiguousContainer (desde C++17) y ReversibleContainer .

iterador

Devuelve un iterador que apunta al primer elemento del contenedor.

std::vector<T,Allocator>::begin, 
std::vector<T,Allocator>::cbegin

iterador begin();		(hasta C++11)
iterador begin() noexcept;		(desde C++11)
const_iterator comenzar() const;		(hasta C++11)
const_iterator begin() const noexcept;		(desde C++11)
const_iterator cbegin() const noexcept;		(desde C++11)

 Devuelve un iterador que apunta al primer elemento del contenedor.

Si el contenedor está vacío, el iterador devuelto será igual a end().

 

parámetro

(ninguno)

valor devuelto

Iterador apuntando al primer elemento.

la complejidad

constante.

devuelve un iterador que apunta al final del contenedor

std::vector<T,Allocator>::end, 
std::vector<T,Allocator>::cend

final del iterador();		(hasta C++11)
iterador end() noexcept;		(desde C++11)
const_iterator end() const;		(hasta C++11)
const_iterator end() const noexcept;		(desde C++11)
const_iterator cend() const noexcept;		(desde C++11)

Devuelve un iterador que apunta al elemento que sigue al último elemento del contenedor.

Este elemento se comporta como un marcador de posición; intentar acceder a él da como resultado un comportamiento indefinido.

 

parámetro

(ninguno)

valor devuelto

Un iterador que apunta al último elemento siguiente.

la complejidad

constante.

Devuelve un iterador inverso que apunta al último elemento del contenedor.

std::vector<T,Allocator>::rbegin, 
std::vector<T,Allocator>::crbegin

iterador_inverso rbegin();		(hasta C++11)
iterador_inverso rbegin() noexcept;		(desde C++11)
const_reverse_iterator rbegin() const;		(hasta C++11)
const_reverse_iterator rbegin() const noexcept;		(desde C++11)
const_reverse_iterator crbegin() const noexcept;		(desde C++11)

Devuelve un iterador inverso que apunta al primer elemento del contenedor invertido. Corresponde al último elemento del contenedor no inverso.

 parámetro

(ninguno)

valor devuelto

Iterador inverso que apunta al primer elemento.

la complejidad

constante.

devuelve un iterador inverso que apunta al frente

std::vector<T,Allocator>::rend, 
std::vector<T,Allocator>::crend

iterador_inverso rend();		(hasta C++11)
iterador_inverso rend() noexcept;		(desde C++11)
const_reverse_iterator rend() const;		(hasta C++11)
const_reverse_iterator rend() const noexcept;		(desde C++11)
const_reverse_iterator crend() const noexcept;		(desde C++11)

 Devuelve un iterador inverso que apunta al elemento que sigue al último elemento del contenedor invertido. Corresponde al elemento anterior del primer elemento del contenedor no inverso. Este elemento se comporta como un marcador de posición e intentar acceder a él da como resultado un comportamiento indefinido.

 

parámetro

(ninguno)

valor devuelto

Iterador inverso que apunta al elemento después del último elemento.

la complejidad

constante.

ejemplo de llamada

#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <time.h>
#include <vector>

using namespace std;

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }


    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator >(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y > cell.y;
        }
        else
        {
            return x > cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}


int main()
{
    std::cout << std::boolalpha;

    std::mt19937 g{std::random_device{}()};
    srand((unsigned)time(NULL));

    auto generate = []()
    {
        int n = std::rand() % 10 + 110;
        Cell cell{n, n};
        return cell;
    };


    //3) 构造拥有 count 个有值 value 的元素的容器。
    std::vector<Cell> vector1(6, generate());
    std::generate(vector1.begin(), vector1.end(), generate);
    std::cout << "vector1:  ";
    std::copy(vector1.begin(), vector1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    //返回指向容器首元素的迭代器。若容器为空，则返回的迭代器将等于 end() 。
    //返回指向容器末元素后一元素的迭代器。此元素表现为占位符；试图访问它导致未定义行为。
    for (std::vector<Cell>::iterator it = vector1.begin(); it != vector1.end(); it++)
    {
        Cell cell = generate();
        *it = cell;
        std::cout << "iterator: " << &(*it) << " = " << cell << std::endl;
    }
    std::cout << std::endl;

    for (std::vector<Cell>::const_iterator cit = vector1.cbegin(); cit != vector1.cend(); cit++)
    {
        std::cout << "const_iterator: " << &(*cit) << " : " << *cit << std::endl;
    }
    std::cout << std::endl;

    //返回指向逆向容器首元素的逆向迭代器。它对应非逆向容器的末元素。
    //返回指向逆向容器末元素后一元素的逆向迭代器。
    //它对应非逆向容器首元素的前一元素。此元素表现为占位符，试图访问它导致未定义行为。
    for (std::vector<Cell>::reverse_iterator rit = vector1.rbegin(); rit != vector1.rend(); rit++)
    {
        Cell cell = generate();
        *rit = cell;
        std::cout << "reverse_iterator: " << &(*rit) << " = " << cell << std::endl;
    }
    std::cout << std::endl;

    for (std::vector<Cell>::const_reverse_iterator crit = vector1.crbegin(); crit != vector1.crend(); crit++)
    {
        std::cout << "const_reverse_iterator: " << &(*crit) << " : " << *crit << std::endl;
    }
    std::cout << std::endl;

    return 0;
}

producción