YouTipCpp Libs Array Size
## C++ size() Function
The `size()` function is one of the most fundamental and frequently used member functions of the `std::array` container. It is used to **retrieve the number of elements** currently stored in the container.
Unlike `std::vector`, whose size can change dynamically at runtime, a `std::array` has a fixed size that is determined at compile time. Consequently, the `size()` function of `std::array` returns a compile-time constant, making it highly efficient and useful in template metaprogramming and static assertions.
---
## Syntax and Parameters
The `size()` function is a member of the `std::array` class template and does not accept any arguments.
### Syntax
```cpp
constexpr size_type size() const noexcept;
```
### Parameters & Return Value
* **Parameters**: None.
* **Return Value**: Returns a value of type `size_type` (which is an alias for `std::size_t`, an unsigned integer type). This value represents the exact number of elements the array is defined to hold.
* **Key Properties**:
* **`constexpr`**: The function is evaluated at compile time.
* **`noexcept`**: The function is guaranteed not to throw exceptions.
---
## Code Examples
Let's explore how to use `size()` in different scenarios, from basic usage to compile-time evaluation.
### Example 1: Basic Usage - Retrieving Array Size
This example demonstrates how to call `size()` on arrays of different dimensions.
```cpp
#include
#include
int main() {
// Arrays of different sizes
std::array small = {1, 2, 3};
std::array medium = {1, 2, 3, 4, 5};
std::array large = {}; // Value-initialized to all zeros
std::cout << "Small array size: " << small.size() << std::endl;
std::cout << "Medium array size: " << medium.size() << std::endl;
std::cout << "Large array size: " << large.size() << std::endl;
return 0;
}
```
#### Expected Output:
```text
Small array size: 3
Medium array size: 5
Large array size: 10
```
#### Code Analysis:
1. The size of each `std::array` is specified as the second template argument (e.g., `3`, `5`, `10`) and is fixed at compile time.
2. Calling `.size()` simply returns this template parameter.
---
### Example 2: Using size() in Loops
The `size()` function is commonly used to define the boundaries of loops when iterating through array elements.
```cpp
#include
#include
int main() {
std::array numbers = {10, 20, 30, 40, 50};
// Forward iteration using size()
std::cout << "Forward iteration: ";
for (size_t i = 0; i < numbers.size(); ++i) {
std::cout << numbers << " ";
}
std::cout << std::endl;
// Reverse iteration using size()
std::cout << "Reverse iteration: ";
for (size_t i = numbers.size(); i > 0; --i) {
std::cout << numbers << " ";
}
std::cout << std::endl;
return 0;
}
```
#### Expected Output:
```text
Forward iteration: 10 20 30 40 50
Reverse iteration: 50 40 30 20 10
```
#### Code Analysis:
* `numbers.size()` returns `5`. The condition `i < numbers.size()` prevents out-of-bounds access.
* For the reverse loop, we start index `i` at `numbers.size()` and decrement down to `1`, accessing elements using `` to safely handle unsigned integer boundaries.
---
### Example 3: Compile-Time Evaluation (constexpr)
Because `std::array::size()` is a `constexpr` function, its return value can be used in contexts that require compile-time constants, such as template instantiation or defining other static arrays.
```cpp
#include
#include
// Template function that accepts any std::array
template
void printSize(const std::array& arr) {
// size() can be used to initialize a constexpr variable
constexpr size_t s = arr.size();
// We can also use it to declare another array at compile time
std::array doubleArr = {};
std::cout << "Array size evaluated at compile time: " << s << std::endl;
std::cout << "New double array size: " << doubleArr.size() << std::endl;
}
int main() {
std::array arr = {1, 2, 3, 4, 5};
printSize(arr);
return 0;
}
```
#### Expected Output:
```text
Array size evaluated at compile time: 5
New double array size: 5
```
#### Code Analysis:
* Unlike `std::vector::size()`, which can only be evaluated at runtime, `std::array::size()` is fully resolved by the compiler.
* This allows you to safely use the size of one array to allocate or configure other compile-time structures.
---
## Key Considerations
1. **Fixed Size**: The value returned by `size()` will always match the second template parameter of the `std::array` declaration. It does not change even if you do not explicitly initialize all elements (uninitialized elements will be default-initialized or contain garbage values depending on the type and initialization style).
2. **Performance**: Since `size()` is a `constexpr` inline function, it has zero runtime overhead. The compiler replaces the function call with the constant value directly.
3. **`size()` vs `max_size()`**: For `std::array`, `size()` and `max_size()` always return the same value because the capacity of the container is fixed at compile time.