实现一个安全向量模板类 SiVector，其设计目标是：在保持 std::vector 易用性的基础上，增强越界访问的安全性（避免崩溃），同时兼容 std::vector 的核心接口和使用习惯。支持嵌套使用（如 SiVector<std::vector<double>>），提供越界访问时的默认值返回或自动扩容机制，并支持与 std::vector 的双向类型转换。
实现
代码示例
#include <string>#include <iostream>#include <vector>#include <iterator>template <typename T>class SiVector{public:SiVector(T value) : m_defaultValue(value) {}SiVector(std::vector<T> data) : m_datas(data) {}SiVector(std::vector<T> data, T value) : m_datas(data), m_defaultValue(value) {}// ========== 构造函数：模仿std::vector ==========SiVector() : m_defaultValue(T()) {}// 构造指定大小的容器，元素初始化为value（默认用默认值）explicit SiVector(uint32_t size, const T& value = T()): m_datas(size, value), m_defaultValue(T()) {}// 从迭代器范围构造template <typename InputIt>SiVector(InputIt first, InputIt last): m_datas(first, last), m_defaultValue(T()) {}// 从初始化列表构造（支持 SiVector<int> v = {1,2,3};）SiVector(std::initializer_list<T> init): m_datas(init), m_defaultValue(T()) {}// 拷贝构造SiVector(const SiVector& other) = default;// 移动构造SiVector(SiVector&& other) noexcept = default;// 类型别名：模仿std::vector的迭代器类型// using value_type = T;using iterator = typename std::vector<T>::iterator;using const_iterator = typename std::vector<T>::const_iterator;// using reference = T&;// using const_reference = const T&;// using size_type = size_t;// ========== 赋值操作：模仿std::vector ==========SiVector&operator=(const SiVector& other) = default;SiVector&operator=(SiVector&& other) noexcept = default;SiVector&operator=(std::initializer_list<T> init) {m_datas = init;return *this;}// 重载[]：越界时返回默认值（const版）T&operator[](uint32_t index) {if (index >= m_datas.size()) {std::cout <<"index out of range. ";m_datas.resize(index + 1, m_defaultValue);}return m_datas[index];}const T&operator[](uint32_t index) const {if (index >= m_datas.size()) {std::cout <<"index out of range. ";return m_defaultValue;}return m_datas[index];}T&at(uint32_t index) {if (index >= m_datas.size()) {std::cout <<"at index out of range. ";return m_defaultValue;}return m_datas[index];}const T&at(uint32_t index) const {if (index >= m_datas.size()) {std::cout <<"at index out of range. ";return m_defaultValue;}return m_datas[index];}// 首尾元素访问T&front() {return m_datas.front();}const T&front() const {return m_datas.front();}T&back() {return m_datas.back();}const T&back() const {return m_datas.back();}// ========== 迭代器：支持范围for循环 ==========iterator begin() noexcept {return m_datas.begin();}// const_iterator const begin() noexcept { return m_datas.begin(); }const_iterator const cbegin() noexcept {return m_datas.cbegin();}iterator end() noexcept {return m_datas.end();}// const_iterator const end() noexcept { return m_datas.end(); }const_iterator const cend() noexcept {return m_datas.cend();}// ========== 容量操作：与std::vector一致 ==========bool empty() const noexcept {return m_datas.empty();}uint32_t const size() noexcept {return m_datas.size();}uint32_t capacity() const noexcept {return m_datas.capacity();}// 调整大小（多余元素用默认值填充）void resize(uint32_t size) { m_datas.resize(size, m_defaultValue);}void resize(uint32_t size , const T& value) { m_datas.resize(size, value);}// 预留容量void reserve(uint32_t size) { m_datas.reserve(size);}void shrink_to_fit() { m_datas.shrink_to_fit();}operator std::vector<T>() const {return m_datas;}// ========== 修改操作：与std::vector一致 ==========void push_back(const T& value) { m_datas.push_back(value);}void push_back(T&& value) { m_datas.push_back(std::move(value));}template <typename... Args>T&emplace_back(Args&&... args) {return m_datas.emplace_back(std::forward<Args>(args)...);} // std::forward<Args>(args)... 中的 ... 是必须的，它的作用是：将参数包 args 中的所有参数逐个展开，传递给 m_datas.emplace_back. 保持每个参数的转发语义（完美转发）void pop_back() {if (!m_datas.empty()) {m_datas.pop_back();}}// 插入元素（在pos位置插入value）iterator insert(const iterator pos, const T& value) {return m_datas.insert(pos, value);}iterator insert(const iterator pos, uint32_t size, const T& value) {return m_datas.insert(pos, size, value);}// 清除元素void clear() noexcept {m_datas.clear();}// 交换两个容器void swap(SiVector& other) noexcept {m_datas.swap(other.m_datas);std::swap(m_defaultValue, other.m_defaultValue);}operator std::vector<std::vector<T>>() const {std::vector<std::vector<T>> result;for (uint32_t i = 0; i< m_datas.size(); i++) {result.push_back(m_datas[i]);}return result;}void setDefault(const T& defaultValue) {m_defaultValue = defaultValue;}private:std::vector<T> m_datas;T m_defaultValue{0};};int main() {std::vector<std::vector<double>> data{{0.2, 0.5}, {0.4, 100.5, 100.6}};SiVector<std::vector<double>>vec(data);uint32_t index = 0;for (auto it : vec) {std::cout <<"index[" << index <<"]" << std::endl;index++;for (const auto& in : it) {std::cout <<"value : " << in << std::endl;}}std::vector<std::vector<double>> vec1 = vec;index = 0;for (auto it : vec1) {std::cout <<"index[" << index <<"]" << std::endl;index++;for (const auto& in : it) {std::cout <<"value : " << in << std::endl;}}std::cout << vec[10000][5000] << std::endl;std::vector<double> vec2 = vec[3];// 访问vec2[5]有可能崩溃std::cout << vec2[5] << vec2.size() << std::endl;return 1;}重点解释
1. 类定义与模板基础
template <
typename T>
class SiVector
{
...
};template <typename T>：模板类定义，使SiVector支持任意数据类型（如int、double、std::vector<double>等），具备通用性。- 核心成员：
m_datas：内部使用std::vector<T>存储数据，复用标准容器的内存管理逻辑；m_defaultValue：越界访问时返回的默认值（通过setDefault可自定义）。
2. 构造函数：兼容 std::vector 的初始化方式
SiVector 提供了多种构造函数，覆盖 std::vector 的常见初始化场景：
// 无参构造
SiVector() : m_defaultValue(T()) {
}
// 指定大小和初始值构造（explicit避免隐式类型转换）
explicit SiVector(uint32_t size, const T& value = T())
: m_datas(size, value), m_defaultValue(T()) {
}
// 迭代器范围构造（支持从其他容器复制元素）
template <
typename InputIt>
SiVector(InputIt first, InputIt last)
: m_datas(first, last), m_defaultValue(T()) {
}
// 初始化列表构造（支持 SiVector<int> v = {1,2,3}; 语法）SiVector(std::initializer_list<T> init): m_datas(init), m_defaultValue(T()) {}// 拷贝构造与移动构造（=default 复用编译器默认实现）SiVector(const SiVector& other) = default;SiVector(SiVector&& other) noexcept = default;explicit：修饰单参数构造函数，避免意外的隐式类型转换（如SiVector<int> v = 5;会编译报错，需显式构造）。= default：对拷贝/移动构造使用默认实现，编译器会自动生成“逐成员拷贝/移动”的逻辑，简洁高效。
3. 元素访问：安全的 operator[] 与 at()
SiVector 的核心安全特性体现在元素访问接口，解决了 std::vector 越界访问崩溃的问题：
（1）operator[] 重载
// 非const版本：越界时自动扩容（保证修改操作安全）
T&
operator[](uint32_t index) {
if (index >= m_datas.size()) {
std::cout <<
"index out of range. ";
m_datas.resize(index + 1, m_defaultValue);
// 扩容并填充默认值
}
return m_datas[index];
}
// const版本：越界时返回默认值（只读场景不修改容器）
const T&
operator[](uint32_t index) const {
if (index >= m_datas.size()) {
std::cout <<
"index out of range. ";
return m_defaultValue;
// 不扩容，返回默认值
}
return m_datas[index];
}- 核心逻辑：通过
index >= m_datas.size()检查越界，非const对象越界时自动扩容（确保后续访问有效），const对象越界时返回默认值（避免修改const对象）。 - 优势：既避免了
std::vector::operator[]越界导致的未定义行为（崩溃/数据错乱），又保持了类似数组的便捷访问语法。
（2）at() 方法
T&
at(uint32_t index) {
if (index >= m_datas.size()) {
std::cout <<
"at index out of range. ";
return m_defaultValue;
// 越界返回默认值（与std::vector::at()抛异常不同）
}
return m_datas[index];
}- 与
std::vector::at()不同：std::vector::at()越界会抛出std::out_of_range异常，而SiVector::at()越界返回默认值，进一步避免程序终止。
4. 迭代器：支持范围for循环
// 类型别名：复用std::vector的迭代器类型
using iterator = typename std::vector<T>::iterator;using const_iterator = typename std::vector<T>::const_iterator;// 迭代器接口iterator begin() noexcept {return m_datas.begin();}const_iterator cbegin() noexcept {return m_datas.cbegin();}iterator end() noexcept {return m_datas.end();}const_iterator cend() noexcept {return m_datas.cend();}- 作用：通过提供
begin()/end()等迭代器接口，SiVector支持 C++ 范围for循环（for (auto x : vec) { ... }），语法与std::vector完全一致。 - 实现逻辑：直接复用内部
m_datas（std::vector）的迭代器，无需手动实现迭代器逻辑，简化代码且保证兼容性。
5. 容量管理：与 std::vector 行为一致
// 容量操作
uint32_t const size() noexcept {
return m_datas.size();
} // 实际元素数量
uint32_t capacity() const noexcept {
return m_datas.capacity();
} // 已分配内存容量
void resize(uint32_t size) { m_datas.resize(size, m_defaultValue);
} // 调整大小（填充默认值）
void reserve(uint32_t size) { m_datas.reserve(size);
} // 预分配容量（不改变大小）
void shrink_to_fit() { m_datas.shrink_to_fit();
} // 收缩容量至实际大小- 这些接口与
std::vector功能完全一致，确保用户可以像管理std::vector一样管理SiVector的内存（如预分配容量提升性能、收缩容量节省内存）。
6. 类型转换：与 std::vector 双向兼容
SiVector 定义了类型转换运算符，支持与 std::vector 无缝转换：
// 转换为单层std::vector<T>
operator std::vector<T>() const {return m_datas;}// 转换为嵌套std::vector<std::vector<T>>（针对嵌套SiVector）operator std::vector<std::vector<T>>() const {std::vector<std::vector<T>> result;for (uint32_t i = 0; i < m_datas.size(); i++) {result.push_back(m_datas[i]);}return result;}- 使用场景：当需要调用接受
std::vector参数的函数时，SiVector对象可自动转换为std::vector，无需手动拷贝（如std::vector<std::vector<double>> vec1 = vec;）。
7. 修改操作：高效元素添加/删除
// 尾部添加元素（支持拷贝和移动语义）
void push_back(const T& value) { m_datas.push_back(value);
}
void push_back(T&& value) { m_datas.push_back(std::move(value));
}
// 原地构造元素（避免拷贝，高效）
template <
typename... Args>
T&
emplace_back(Args&&
... args) {
return m_datas.emplace_back(std::forward<Args>(args)...);}emplace_back与完美转发：Args&&... args是可变参数模板（参数包），支持任意数量和类型的参数；std::forward<Args>(args)...中的...用于展开参数包，将参数“完美转发”给m_datas.emplace_back，实现元素在容器内部直接构造（无需临时对象拷贝），性能优于push_back。
8. main 函数示例解析
int main() {
// 1. 初始化嵌套SiVector（从std::vector<std::vector<double>>构造）std::vector<std::vector<double>> data{{0.2, 0.5}, {0.4, 100.5, 100.6}};SiVector<std::vector<double>>vec(data);// 2. 范围for循环遍历（依赖迭代器实现）for (auto it : vec) {...}// 3. 转换为std::vector并遍历std::vector<std::vector<double>> vec1 = vec;// 4. 越界访问测试（非const版本自动扩容）std::cout << vec[10000][5000] << std::endl;// 外层越界自动扩容，内层同理// 5. 验证转换后的std::vector越界行为（可能崩溃，体现SiVector的安全性）std::vector<double> vec2 = vec[3];std::cout << vec2[5] << vec2.size() << std::endl;// std::vector越界是未定义行为}- 示例展示了
SiVector的核心特性：嵌套使用、范围遍历、类型转换、安全越界访问，同时对比了std::vector越界的风险，突出SiVector的安全性。
总结
SiVector 通过以下设计实现了“安全”与“兼容”的平衡：
- 安全访问：
operator[]和at()越界时返回默认值或自动扩容，避免崩溃； - 接口兼容：模仿
std::vector的构造函数、迭代器、容量管理接口，降低使用成本； - 高效转换：支持与
std::vector双向转换，兼容标准库生态； - 性能优化：通过
emplace_back完美转发和复用std::vector内存管理，保证效率。
适用于需要频繁访问元素且对稳定性要求高的场景。