std::vector<T,Allocator>::capacity

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Containers library

Sequence

array (C++11)

vector

vector<bool>

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Iterator invalidation

Member function table

Non-member function table

 

std::vector

Member types

Member functions

vector::vector

vector::~vector

vector::operator=

vector::assign

vector::assign_range (C++23)

vector::get_allocator

Element access

vector::at

vector::operator[]

vector::front

vector::back

vector::data

Iterators

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

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

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

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

Capacity

vector::empty

vector::size

vector::max_size

vector::reserve

vector::capacity

vector::shrink_to_fit (DR*)

Modifiers

vector::clear

vector::insert

vector::emplace (C++11)

vector::insert_range (C++23)

vector::erase

vector::push_back

vector::emplace_back (C++11)

vector::append_range (C++23)

vector::pop_back

vector::resize

vector::swap

Non-member functions

std::swap

eraseerase_if (C++20)(C++20)

operator==operator!=operator<operator>operator<=operator>=operator<=> (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)

Deduction guides(C++17)

 

size_type capacity() const;		(until C++11)
size_type capacity() const noexcept;		(since C++11) (until C++20)
constexpr size_type capacity() const noexcept;		(since C++20)

Returns the number of elements that the container has currently allocated space for.

Parameters

(none)

Return value

Capacity of the currently allocated storage.

Complexity

Constant.

Example

Run this code

#include <iomanip>
#include <iostream>
#include <vector>
 
int main()
{
    int sz = 100;
    std::vector<int> v;
 
    auto cap = v.capacity();
    std::cout << "Initial size: " << v.size() << ", capacity: " << cap << '\n';
 
    std::cout << "\nDemonstrate the capacity's growth policy."
                 "\nSize:  Capacity:  Ratio:\n" << std::left;
    while (sz-- > 0) {
        v.push_back(sz);
        if (cap != v.capacity()) {
            std::cout << std::setw( 7) << v.size()
                      << std::setw(11) << v.capacity()
                      << std::setw(10) << v.capacity() / static_cast<float>(cap) << '\n';
            cap = v.capacity();
        }
    }
 
    std::cout << "\nFinal size: " << v.size() << ", capacity: " << v.capacity() << '\n';
}

Possible output:

Initial size: 0, capacity: 0
 
Demonstrate the capacity's growth policy.
Size:  Capacity:  Ratio:
1      1          inf
2      2          2
3      4          2
5      8          2
9      16         2
17     32         2
33     64         2
65     128        2
 
Final size: 100, capacity: 128

See also

size	returns the number of elements (public member function)
reserve	reserves storage (public member function)