Cpp Libs List Size
📅 2026-06-23 | 📂 C++
## C++ `std::list::size()` Function
The `std::list::size()` is a member function of the C++ Standard Template Library (STL) `` container. It is used to **retrieve the number of elements** currently stored in the list.
Unlike some custom linked list implementations where calculating the size requires traversing the entire list, the `std::list::size()` function in modern C++ (C++11 and later) is guaranteed to execute in constant time, $O(1)$.
---
## Syntax and Parameters
### Syntax
```cpp
size_type size() const noexcept;
```
### Parameters & Return Value
* **Parameters**: None.
* **Return Value**: The number of elements in the container. The return type is `size_type`, which is an unsigned integer type (typically alias to `std::size_t`).
* **Exceptions**: This function is marked `noexcept` and is guaranteed not to throw exceptions.
---
## Code Example
The following example demonstrates how to use `std::list::size()` to monitor the size of a list during initialization and after modifying its elements.
```cpp
#include
#include
int main() {
// 1. Initialize an empty list
std::list empty_list;
std::cout << "Empty list size: " << empty_list.size() << std::endl;
// 2. Initialize a list with 5 elements
std::list numbers = {1, 2, 3, 4, 5};
std::cout << "Initial list size: " << numbers.size() << std::endl;
// 3. Add an element to the list
numbers.push_back(6);
std::cout << "Size after push_back: " << numbers.size() << std::endl;
// 4. Remove an element from the list
numbers.pop_front();
std::cout << "Size after pop_front: " << numbers.size() << std::endl;
return 0;
}
```
### Expected Output
```text
Empty list size: 0
Initial list size: 5
Size after push_back: 6
Size after pop_front: 5
```
---
## Key Considerations
### 1. Time Complexity: $O(1)$ vs $O(N)$
Prior to the C++11 standard, the complexity of `std::list::size()` was allowed to be $O(N)$ to allow for $O(1)$ list splicing (`std::list::splice`). However, since **C++11**, the standard mandates that `size()` must have **constant time complexity, $O(1)$**. This means calling `size()` is highly efficient and does not traverse the list.
### 2. Checking for Emptiness: `empty()` vs `size() == 0`
While you can check if a list is empty using `my_list.size() == 0`, it is highly recommended to use `my_list.empty()` instead.
* `empty()` is more expressive and clearly communicates your intent.
* `empty()` is guaranteed to be $O(1)$ across all C++ standards and containers, making it a safer and more consistent best practice.
YouTip