std::vector::vector

 

C++

Linguaggio

Concetti

Libreria di Utilità

Stringhe

Contenitori

Algoritmi

Iteratori

Libreria matematca

Input/output

Localizzazione

Espressioni regolari (C++11)

Operazioni atomicche (C++11)

Multithreading (C++11)

 

Contenitori libreria

array (C++11)

vector

deque

forward_list (C++11)

list

set

multiset

map

multimap

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

stack

queue

priority_queue

 

std::vector

Membri funzioni Original: Member functions The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

vector::vector

vector::~vector

vector::operator=

vector::assign

vector::get_allocator

Elemento accesso Original: Element access The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

vector::at

vector::operator[]

vector::front

vector::back

vector::data (C++11)

Iteratori Original: Iterators The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

vector::begin vector::cbegin (C++11)

vector::end vector::cend (C++11)

vector::rbegin vector::crbegin (C++11)

vector::rend vector::crend (C++11)

Capacità Original: Capacity The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

vector::empty

vector::size

vector::max_size

vector::reserve

vector::capacity

vector::shrink_to_fit (C++11)

Modificatori Original: Modifiers The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

vector::clear

vector::insert

vector::emplace (C++11)

vector::erase

vector::push_back

vector::emplace_back (C++11)

vector::pop_back

vector::resize

vector::swap

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>

	(1)
vector();
vector() noexcept(noexcept(Allocator()));
		(2)
explicit vector( const Allocator& alloc );
explicit vector( const Allocator& alloc ) noexcept;
			(3)
explicit vector( size_type count, {{#pad:|6}} const T& value = T(), {{#pad:|6}} const Allocator& alloc = Allocator());					(fino al c++11)
vector( size_type count, {{#pad:|6}} const T& value, {{#pad:|6}} const Allocator& alloc = Allocator());					(dal C++11)
				(4)
explicit vector( size_type count );						(dal C++11) (fino al c++14)
explicit vector( size_type count, const Allocator& alloc = Allocator() );						(dal C++14)
template< class InputIt > vector( InputIt first, InputIt last, {{#pad:|6}} const Allocator& alloc = Allocator() );					(5)
vector( const vector& other );					(6)
vector( const vector& other, const Allocator& alloc );					(6)	(dal C++11)
					(7)
vector( vector&& other );							(dal C++11)
vector( vector&& other ) noexcept;
vector( vector&& other, const Allocator& alloc );						(8)	(dal C++11)
vector( std::initializer_list<T> init, {{#pad:|6}} const Allocator& alloc = Allocator() );						(9)	(dal C++11)

Costruisce un nuovo container da una varietà di origini, eventualmente utilizzando un allocatore alloc fornito dall'utente.

1) Default constructor. Costruisce un container vuoto con un allocatore default-costruito.

2) Costruisce un container vuoto con l'allocatore alloc.

3) Costruisce il container con count copie di elementi di valore value.

4) Costruisce il container con count default-inserted istanze di T. Non vengono attuate copie.

5) Costruisce il container con il contenuto del range [first, last).

Questo costruttore ha lo stesso effetto di vector(static_cast<size_type>(first), static_cast<value_type>(last), a) se InputIt è un integral type.	(fino al c++11)
Questi overload partecipano nella overload resolution solo se InputIt soddisfa LegacyInputIterator, per evitare ambiguità con l'overload (3).	(dal C++11)

6) Copy constructor. Costruisce il container con una copia del contenuto di other. Se alloc non viene fornito, allocator viene ottenuto come se fosse stato invocato std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.get_allocator()).

7) Move constructor. Costruisce il container con il contenuto di other utilizzando la move semantics. L'allocator è ottenuto per move-construction dall'allocator appartenente a other. Dopo il move, è garantito che other.empty() restituirà true.

8) Allocator-extended move constructor. Utilizza alloc come allocator per il nuovo container, muovendo il contenuto da other; se alloc != other.get_allocator(), questo si traduce in un move elemento per elemento. (in questo caso, non vi è garanzia che other sia vuoto dopo il move)

9) Costruisce il container con il contenuto della initializer list init.

Parametri

alloc	-	allocator da utilizzare per tutte le allocazioni di memoria di questo container
count	-	la dimensione del container
value	-	il valore con cui inizializzare gli elementi del container
first, last	-	il range da cui copiare gli elementi
other	-	un secondo container da utilizzare come sorgente per inizializzare gli elementi del nuovo container
init	-	initializer list per inizializzare gli elementi del container

Complessità

1-2) Costante

3-4) Lineare in count

5) Lineare nella distanza fra first e last

6) Lineare nella dimensione di other

7) Costante.

8) Lineare se alloc != other.get_allocator(), altrimenti costante.

9) Lineare nella dimensione di init.

Eccezioni

Chiamate a Allocator::allocate possono lanciare eccezioni.

Note

Dopo la move construction del container (overload (7)), riferimenti, puntatori e iteratori (diversi da end) a other rimangono validi, ma si riferiscono a elementi che ora si trovano in *this. Lo standard corrente rende questa garanzia tramite la dichiarazione generale in [container.requirements.general]/12, ed una garanzia più diretta è in esame in LWG 2321.
L'overload (4) azzera gli elementi di non-class types come int, comportamento che non corrisponde a quello di new[], che invece li lascia non inizializzati. Per ottenere lo stesso comportamento, deve essere fornita una custom Allocator::construct che lasci gli elementi non inizializzati.

Esempio

#include <vector>
#include <string>
#include <iostream>

template<typename T>
std::ostream& operator<<(std::ostream& s, const std::vector<T>& v) 
{
    s.put('[');
    char comma[3] = {'\0', ' ', '\0'};
    for (const auto& e : v) {
        s << comma << e;
        comma[0] = ',';
    }
    return s << ']';
}

int main() 
{
    // c++11 initializer list syntax:
    std::vector<std::string> words1 {"the", "frogurt", "is", "also", "cursed"};
    std::cout << "words1: " << words1 << '\n';

    // words2 == words1
    std::vector<std::string> words2(words1.begin(), words1.end());
    std::cout << "words2: " << words2 << '\n';

    // words3 == words1
    std::vector<std::string> words3(words1);
    std::cout << "words3: " << words3 << '\n';

    // words4 is {"Mo", "Mo", "Mo", "Mo", "Mo"}
    std::vector<std::string> words4(5, "Mo");
    std::cout << "words4: " << words4 << '\n';
}

Output:

words1: [the, frogurt, is, also, cursed]
words2: [the, frogurt, is, also, cursed]
words3: [the, frogurt, is, also, cursed]
words4: [Mo, Mo, Mo, Mo, Mo]

See also

assign	assegna valori al contenitore Original: assigns values to the container The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)
operator=	assegna valori al contenitore Original: assigns values to the container The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)