da_vector_table.hpp

#ifndef DA_VECTOR_TABLE_H
#define DA_VECTOR_TABLE_H
 
#include <vector>
#include <algorithm>
#include <stdexcept>
#include <utility>
#include <initializer_list>
#include <type_traits>
 
namespace DA
{
template< typename T >
class da_vector_table
{
public:
    using value_type       = T;                                      
    using table_index_type = std::pair< std::size_t, std::size_t >;  
 
    // 迭代器类型定义
    using iterator               = typename std::vector< T >::iterator;
    using const_iterator         = typename std::vector< T >::const_iterator;
    using reverse_iterator       = typename std::vector< T >::reverse_iterator;
    using const_reverse_iterator = typename std::vector< T >::const_reverse_iterator;
 
public:
    // 构造函数
    da_vector_table();
    explicit da_vector_table(std::size_t rows, std::size_t cols = 0, const T& value = T());
    da_vector_table(std::initializer_list< std::initializer_list< T > > init);
 
    // 拷贝和移动构造函数
    da_vector_table(const da_vector_table& other);
    da_vector_table(da_vector_table&& other) noexcept;
 
    // 赋值运算符
    da_vector_table& operator=(const da_vector_table& other);
    da_vector_table& operator=(da_vector_table&& other) noexcept;
 
    // 容量操作
    bool empty() const noexcept;
    std::size_t size() const noexcept;
    std::size_t max_size() const noexcept;
    void reserve(std::size_t new_cap);
    std::size_t capacity() const noexcept;
    void shrink_to_fit();
 
    // 迭代器访问
    iterator begin() noexcept;
    const_iterator begin() const noexcept;
    const_iterator cbegin() const noexcept;
    iterator end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cend() const noexcept;
    reverse_iterator rbegin() noexcept;
    const_reverse_iterator rbegin() const noexcept;
    const_reverse_iterator crbegin() const noexcept;
    reverse_iterator rend() noexcept;
    const_reverse_iterator rend() const noexcept;
    const_reverse_iterator crend() const noexcept;
 
    // 元素访问
    T& operator()(std::size_t row, std::size_t col);
    const T& operator()(std::size_t row, std::size_t col) const;
    T& at(std::size_t row, std::size_t col);
    const T& at(std::size_t row, std::size_t col) const;
    T& front();
    const T& front() const;
    T& back();
    const T& back() const;
    T* data() noexcept;
    const T* data() const noexcept;
 
    // 修改器
    void assign(std::size_t rows, std::size_t cols, const T& value);
    template< typename InputIt >
    void assign(InputIt first, InputIt last);
    void push_back(const T& value);
    void push_back(T&& value);
    template< typename... Args >
    void emplace_back(Args&&... args);
    void pop_back();
    void clear() noexcept;
    void swap(da_vector_table& other) noexcept;
 
    // 行操作
    void append_row(const std::vector< T >& row);
    void append_row(std::vector< T >&& row);
    template< typename InputIt >
    void append_row(InputIt first, InputIt last);
    void append_row(std::initializer_list< T > il);
    void insert_row(std::size_t pos, const std::vector< T >& row);
    void insert_row(std::size_t pos, std::vector< T >&& row);
    void erase_row(std::size_t pos);
 
    // 列操作
    void append_column(const std::vector< T >& col);
    void append_column(std::vector< T >&& col);
    template< typename InputIt >
    void append_column(InputIt first, InputIt last);
    void append_column(std::initializer_list< T > il);
    void insert_column(std::size_t pos, const std::vector< T >& col);
    void insert_column(std::size_t pos, std::vector< T >&& col);
    void erase_column(std::size_t pos);
 
    // 形状操作
    table_index_type shape() const noexcept;
    std::size_t row_count() const noexcept;
    std::size_t column_count() const noexcept;
    void resize(std::size_t rows, std::size_t cols, const T& value = T());
    void resize(table_index_type sh, const T& value = T());
    void reshape(std::size_t rows, std::size_t cols);
 
    // 辅助功能
    bool is_rectangular() const noexcept
    {
        return true;
    }  // 一维存储总是矩形的
    std::vector< T > get_row(std::size_t row) const;
    std::vector< T > get_column(std::size_t col) const;
    void set_row(std::size_t row, const std::vector< T >& values);
    void set_column(std::size_t col, const std::vector< T >& values);
 
private:
    std::vector< T > data_;  // 一维数据存储
    std::size_t rows_;       // 行数
    std::size_t cols_;       // 列数
 
    // 辅助函数
    std::size_t index(std::size_t row, std::size_t col) const noexcept;
    void check_bounds(std::size_t row, std::size_t col) const;
    void check_row_bounds(std::size_t row) const;
    void check_column_bounds(std::size_t col) const;
};
 
// ============================================================================
// 实现部分
// ============================================================================
 
template< typename T >
da_vector_table< T >::da_vector_table() : data_(), rows_(0), cols_(0)
{
}
 
template< typename T >
da_vector_table< T >::da_vector_table(std::size_t rows, std::size_t cols, const T& value)
    : data_(rows * cols, value), rows_(rows), cols_(cols)
{
}
 
template< typename T >
da_vector_table< T >::da_vector_table(std::initializer_list< std::initializer_list< T > > init)
    : rows_(init.size()), cols_(0)
{
    // 确定最大列数
    for (const auto& row : init) {
        if (row.size() > cols_) {
            cols_ = row.size();
        }
    }
 
    // 分配内存
    data_.resize(rows_ * cols_);
 
    // 填充数据
    std::size_t row_idx = 0;
    for (const auto& row : init) {
        std::size_t col_idx = 0;
        for (const auto& value : row) {
            data_[ index(row_idx, col_idx) ] = value;
            ++col_idx;
        }
        // 填充剩余部分（如果有）
        for (; col_idx < cols_; ++col_idx) {
            data_[ index(row_idx, col_idx) ] = T();
        }
        ++row_idx;
    }
}
 
template< typename T >
da_vector_table< T >::da_vector_table(const da_vector_table& other)
    : data_(other.data_), rows_(other.rows_), cols_(other.cols_)
{
}
 
template< typename T >
da_vector_table< T >::da_vector_table(da_vector_table&& other) noexcept
    : data_(std::move(other.data_)), rows_(other.rows_), cols_(other.cols_)
{
    other.rows_ = 0;
    other.cols_ = 0;
}
 
template< typename T >
da_vector_table< T >& da_vector_table< T >::operator=(const da_vector_table& other)
{
    if (this != &other) {
        data_ = other.data_;
        rows_ = other.rows_;
        cols_ = other.cols_;
    }
    return *this;
}
 
template< typename T >
da_vector_table< T >& da_vector_table< T >::operator=(da_vector_table&& other) noexcept
{
    if (this != &other) {
        data_       = std::move(other.data_);
        rows_       = other.rows_;
        cols_       = other.cols_;
        other.rows_ = 0;
        other.cols_ = 0;
    }
    return *this;
}
 
template< typename T >
bool da_vector_table< T >::empty() const noexcept
{
    return data_.empty();
}
 
template< typename T >
std::size_t da_vector_table< T >::size() const noexcept
{
    return data_.size();
}
 
template< typename T >
std::size_t da_vector_table< T >::max_size() const noexcept
{
    return data_.max_size();
}
 
template< typename T >
void da_vector_table< T >::reserve(std::size_t new_cap)
{
    data_.reserve(new_cap);
}
 
template< typename T >
std::size_t da_vector_table< T >::capacity() const noexcept
{
    return data_.capacity();
}
 
template< typename T >
void da_vector_table< T >::shrink_to_fit()
{
    data_.shrink_to_fit();
}
 
template< typename T >
typename da_vector_table< T >::iterator da_vector_table< T >::begin() noexcept
{
    return data_.begin();
}
 
template< typename T >
typename da_vector_table< T >::const_iterator da_vector_table< T >::begin() const noexcept
{
    return data_.begin();
}
 
template< typename T >
typename da_vector_table< T >::const_iterator da_vector_table< T >::cbegin() const noexcept
{
    return data_.cbegin();
}
 
template< typename T >
typename da_vector_table< T >::iterator da_vector_table< T >::end() noexcept
{
    return data_.end();
}
 
template< typename T >
typename da_vector_table< T >::const_iterator da_vector_table< T >::end() const noexcept
{
    return data_.end();
}
 
template< typename T >
typename da_vector_table< T >::const_iterator da_vector_table< T >::cend() const noexcept
{
    return data_.cend();
}
 
template< typename T >
typename da_vector_table< T >::reverse_iterator da_vector_table< T >::rbegin() noexcept
{
    return data_.rbegin();
}
 
template< typename T >
typename da_vector_table< T >::const_reverse_iterator da_vector_table< T >::rbegin() const noexcept
{
    return data_.rbegin();
}
 
template< typename T >
typename da_vector_table< T >::const_reverse_iterator da_vector_table< T >::crbegin() const noexcept
{
    return data_.crbegin();
}
 
template< typename T >
typename da_vector_table< T >::reverse_iterator da_vector_table< T >::rend() noexcept
{
    return data_.rend();
}
 
template< typename T >
typename da_vector_table< T >::const_reverse_iterator da_vector_table< T >::rend() const noexcept
{
    return data_.rend();
}
 
template< typename T >
typename da_vector_table< T >::const_reverse_iterator da_vector_table< T >::crend() const noexcept
{
    return data_.crend();
}
 
template< typename T >
T& da_vector_table< T >::operator()(std::size_t row, std::size_t col)
{
    return data_[ index(row, col) ];
}
 
template< typename T >
const T& da_vector_table< T >::operator()(std::size_t row, std::size_t col) const
{
    return data_[ index(row, col) ];
}
 
template< typename T >
T& da_vector_table< T >::at(std::size_t row, std::size_t col)
{
    check_bounds(row, col);
    return data_[ index(row, col) ];
}
 
template< typename T >
const T& da_vector_table< T >::at(std::size_t row, std::size_t col) const
{
    check_bounds(row, col);
    return data_[ index(row, col) ];
}
 
template< typename T >
T& da_vector_table< T >::front()
{
    return data_.front();
}
 
template< typename T >
const T& da_vector_table< T >::front() const
{
    return data_.front();
}
 
template< typename T >
T& da_vector_table< T >::back()
{
    return data_.back();
}
 
template< typename T >
const T& da_vector_table< T >::back() const
{
    return data_.back();
}
 
template< typename T >
T* da_vector_table< T >::data() noexcept
{
    return data_.data();
}
 
template< typename T >
const T* da_vector_table< T >::data() const noexcept
{
    return data_.data();
}
 
template< typename T >
void da_vector_table< T >::assign(std::size_t rows, std::size_t cols, const T& value)
{
    data_.assign(rows * cols, value);
    rows_ = rows;
    cols_ = cols;
}
 
template< typename T >
template< typename InputIt >
void da_vector_table< T >::assign(InputIt first, InputIt last)
{
    data_.assign(first, last);
    // 注意：调用此方法后需要手动设置rows_和cols_，或者调用reshape
}
 
template< typename T >
void da_vector_table< T >::push_back(const T& value)
{
    data_.push_back(value);
    // 注意：此操作会破坏表格结构，需要谨慎使用
}
 
template< typename T >
void da_vector_table< T >::push_back(T&& value)
{
    data_.push_back(std::move(value));
    // 注意：此操作会破坏表格结构，需要谨慎使用
}
 
template< typename T >
template< typename... Args >
void da_vector_table< T >::emplace_back(Args&&... args)
{
    data_.emplace_back(std::forward< Args >(args)...);
    // 注意：此操作会破坏表格结构，需要谨慎使用
}
 
template< typename T >
void da_vector_table< T >::pop_back()
{
    data_.pop_back();
    // 注意：此操作会破坏表格结构，需要谨慎使用
}
 
template< typename T >
void da_vector_table< T >::clear() noexcept
{
    data_.clear();
    rows_ = 0;
    cols_ = 0;
}
 
template< typename T >
void da_vector_table< T >::swap(da_vector_table& other) noexcept
{
    data_.swap(other.data_);
    std::swap(rows_, other.rows_);
    std::swap(cols_, other.cols_);
}
 
template< typename T >
void da_vector_table< T >::append_row(const std::vector< T >& row)
{
    if (cols_ == 0) {
        // 空表格，设置列数
        cols_ = row.size();
    } else if (row.size() != cols_) {
        throw std::invalid_argument("Row size must match table column count");
    }
 
    data_.insert(data_.end(), row.begin(), row.end());
    ++rows_;
}
 
template< typename T >
void da_vector_table< T >::append_row(std::vector< T >&& row)
{
    if (cols_ == 0) {
        // 空表格，设置列数
        cols_ = row.size();
    } else if (row.size() != cols_) {
        throw std::invalid_argument("Row size must match table column count");
    }
 
    data_.insert(data_.end(), std::make_move_iterator(row.begin()), std::make_move_iterator(row.end()));
    ++rows_;
}
 
template< typename T >
template< typename InputIt >
void da_vector_table< T >::append_row(InputIt first, InputIt last)
{
    const std::size_t count = std::distance(first, last);
    if (cols_ == 0) {
        // 空表格，设置列数
        cols_ = count;
    } else if (count != cols_) {
        throw std::invalid_argument("Row size must match table column count");
    }
 
    data_.insert(data_.end(), first, last);
    ++rows_;
}
 
template< typename T >
void da_vector_table< T >::append_row(std::initializer_list< T > il)
{
    if (cols_ == 0) {
        // 空表格，设置列数
        cols_ = il.size();
    } else if (il.size() != cols_) {
        throw std::invalid_argument("Row size must match table column count");
    }
 
    data_.insert(data_.end(), il.begin(), il.end());
    ++rows_;
}
 
template< typename T >
void da_vector_table< T >::insert_row(std::size_t pos, const std::vector< T >& row)
{
    check_row_bounds(pos);  // 允许在末尾插入(pos == rows_)
 
    if (cols_ == 0) {
        // 空表格，设置列数
        cols_ = row.size();
    } else if (row.size() != cols_) {
        throw std::invalid_argument("Row size must match table column count");
    }
 
    // 计算插入位置
    const std::size_t insert_pos = pos * cols_;
    data_.insert(data_.begin() + insert_pos, row.begin(), row.end());
    ++rows_;
}
 
template< typename T >
void da_vector_table< T >::insert_row(std::size_t pos, std::vector< T >&& row)
{
    check_row_bounds(pos);  // 允许在末尾插入(pos == rows_)
 
    if (cols_ == 0) {
        // 空表格，设置列数
        cols_ = row.size();
    } else if (row.size() != cols_) {
        throw std::invalid_argument("Row size must match table column count");
    }
 
    // 预留足够空间避免重新分配
    if (data_.capacity() < data_.size() + cols_) {
        data_.reserve(data_.capacity() + std::max(data_.capacity(), cols_ * 2));
    }
 
    // 计算插入位置
    const std::size_t insert_pos = pos * cols_;
    data_.insert(data_.begin() + insert_pos, std::make_move_iterator(row.begin()), std::make_move_iterator(row.end()));
    ++rows_;
}
 
template< typename T >
void da_vector_table< T >::erase_row(std::size_t pos)
{
    check_row_bounds(pos);
 
    // 计算要删除的范围
    const std::size_t start_pos = pos * cols_;
    const std::size_t end_pos   = start_pos + cols_;
 
    data_.erase(data_.begin() + start_pos, data_.begin() + end_pos);
    --rows_;
}
 
template<typename T>
template<typename InputIt>
void da_vector_table<T>::append_column(InputIt first, InputIt last)
{
    // 计算元素数量
    const std::size_t count = std::distance(first, last);
    if (count != rows_) {
        throw std::invalid_argument("Column size must match table row count");
    }
    
    // 创建新向量，容量为添加一列后的大小
    std::vector<T> new_data;
    new_data.reserve(rows_ * (cols_ + 1));
    
    // 复制现有数据并添加新列
    auto it = first;
    for (std::size_t i = 0; i < rows_; ++i) {
        const std::size_t row_start = i * cols_;
        
        // 复制当前行的所有元素
        for (std::size_t j = 0; j < cols_; ++j) {
            new_data.push_back(std::move(data_[row_start + j]));
        }
        
        // 添加新列的元素
        new_data.push_back(*it);
        ++it;
    }
    
    // 更新数据
    data_ = std::move(new_data);
    ++cols_;
}
 
template<typename T>
void da_vector_table<T>::append_column(const std::vector<T>& col)
{
    // 使用迭代器版本
    append_column(col.begin(), col.end());
}
 
template<typename T>
void da_vector_table<T>::append_column(std::vector<T>&& col)
{
    // 使用迭代器版本
    append_column(std::make_move_iterator(col.begin()), 
                  std::make_move_iterator(col.end()));
}
 
template<typename T>
void da_vector_table<T>::append_column(std::initializer_list<T> il)
{
    // 使用迭代器版本
    append_column(il.begin(), il.end());
}
 
template< typename T >
void da_vector_table< T >::insert_column(std::size_t pos, const std::vector< T >& col)
{
    check_column_bounds(pos);  // 允许在末尾插入(pos == cols_)
 
    if (col.size() != rows_) {
        throw std::invalid_argument("Column size must match table row count");
    }
 
    // 创建新向量，容量为插入一列后的大小
    std::vector< T > new_data;
    new_data.reserve(rows_ * (cols_ + 1));
 
    // 复制数据并插入新列
    for (std::size_t i = 0; i < rows_; ++i) {
        const std::size_t row_start = i * cols_;
 
        // 复制当前行中插入位置之前的元素
        for (std::size_t j = 0; j < pos; ++j) {
            new_data.push_back(data_[ row_start + j ]);
        }
 
        // 插入新列的元素
        new_data.push_back(col[ i ]);
 
        // 复制当前行中插入位置之后的元素
        for (std::size_t j = pos; j < cols_; ++j) {
            new_data.push_back(data_[ row_start + j ]);
        }
    }
 
    // 更新数据
    data_ = std::move(new_data);
    ++cols_;
}
 
template<typename T>
void da_vector_table<T>::insert_column(std::size_t pos, std::vector<T>&& col)
{
    check_column_bounds(pos); // 允许在末尾插入(pos == cols_)
    
    if (col.size() != rows_) {
        throw std::invalid_argument("Column size must match table row count");
    }
    
    // 创建新向量，容量为插入一列后的大小
    std::vector<T> new_data;
    new_data.reserve(rows_ * (cols_ + 1));
    
    // 复制数据并插入新列
    for (std::size_t i = 0; i < rows_; ++i) {
        const std::size_t row_start = i * cols_;
        
        // 复制当前行中插入位置之前的元素
        for (std::size_t j = 0; j < pos; ++j) {
            new_data.push_back(std::move(data_[row_start + j]));
        }
        
        // 插入新列的元素（使用移动语义）
        new_data.push_back(std::move(col[i]));
        
        // 复制当前行中插入位置之后的元素
        for (std::size_t j = pos; j < cols_; ++j) {
            new_data.push_back(std::move(data_[row_start + j]));
        }
    }
    
    // 更新数据
    data_ = std::move(new_data);
    ++cols_;
}
 
template< typename T >
void da_vector_table< T >::erase_column(std::size_t pos)
{
    check_column_bounds(pos);
 
    // 创建新向量，容量为移除一列后的大小
    std::vector< T > new_data;
    new_data.reserve(rows_ * (cols_ - 1));
 
    // 复制除了指定列之外的所有元素
    for (std::size_t i = 0; i < rows_; ++i) {
        const std::size_t row_start = i * cols_;
 
        // 复制当前行中指定列之前的元素
        for (std::size_t j = 0; j < pos; ++j) {
            new_data.push_back(data_[ row_start + j ]);
        }
 
        // 跳过指定列，复制之后的元素
        for (std::size_t j = pos + 1; j < cols_; ++j) {
            new_data.push_back(data_[ row_start + j ]);
        }
    }
 
    // 更新数据
    data_ = std::move(new_data);
    --cols_;
}
 
template< typename T >
typename da_vector_table< T >::table_index_type da_vector_table< T >::shape() const noexcept
{
    return { rows_, cols_ };
}
 
template< typename T >
std::size_t da_vector_table< T >::row_count() const noexcept
{
    return rows_;
}
 
template< typename T >
std::size_t da_vector_table< T >::column_count() const noexcept
{
    return cols_;
}
 
template< typename T >
void da_vector_table< T >::resize(std::size_t rows, std::size_t cols, const T& value)
{
    if (rows == rows_ && cols == cols_) {
        return;
    }
 
    // 如果新大小小于等于当前容量，且列数不变，可以原地调整
    if (cols == cols_ && rows * cols <= data_.capacity()) {
        if (rows > rows_) {
            // 增加行数
            data_.resize(rows * cols, value);
        } else {
            // 减少行数
            data_.resize(rows * cols);
        }
        rows_ = rows;
        return;
    }
 
    // 否则需要重新移动
    std::vector< T > new_data(rows * cols, value);
 
    const std::size_t copy_rows = std::min(rows, rows_);
    const std::size_t copy_cols = std::min(cols, cols_);
 
    for (std::size_t i = 0; i < copy_rows; ++i) {
        for (std::size_t j = 0; j < copy_cols; ++j) {
            new_data[ i * cols + j ] = data_[ i * cols_ + j ];
        }
    }
 
    data_ = std::move(new_data);
    rows_ = rows;
    cols_ = cols;
}
 
template< typename T >
void da_vector_table< T >::resize(table_index_type sh, const T& value)
{
    resize(sh.first, sh.second, value);
}
 
template< typename T >
void da_vector_table< T >::reshape(std::size_t rows, std::size_t cols)
{
    if (rows * cols != data_.size()) {
        throw std::invalid_argument("New shape must have the same number of elements");
    }
 
    rows_ = rows;
    cols_ = cols;
}
 
template< typename T >
std::vector< T > da_vector_table< T >::get_row(std::size_t row) const
{
    check_row_bounds(row);
 
    std::vector< T > result;
    result.reserve(cols_);
 
    const std::size_t start = row * cols_;
    for (std::size_t i = 0; i < cols_; ++i) {
        result.push_back(data_[ start + i ]);
    }
 
    return result;
}
 
template< typename T >
std::vector< T > da_vector_table< T >::get_column(std::size_t col) const
{
    check_column_bounds(col);
 
    std::vector< T > result;
    result.reserve(rows_);
 
    for (std::size_t i = 0; i < rows_; ++i) {
        result.push_back(data_[ i * cols_ + col ]);
    }
 
    return result;
}
 
template< typename T >
void da_vector_table< T >::set_row(std::size_t row, const std::vector< T >& values)
{
    check_row_bounds(row);
 
    if (values.size() != cols_) {
        throw std::invalid_argument("Number of values must match column count");
    }
 
    const std::size_t start = row * cols_;
    for (std::size_t i = 0; i < cols_; ++i) {
        data_[ start + i ] = values[ i ];
    }
}
 
template< typename T >
void da_vector_table< T >::set_column(std::size_t col, const std::vector< T >& values)
{
    check_column_bounds(col);
 
    if (values.size() != rows_) {
        throw std::invalid_argument("Number of values must match row count");
    }
 
    for (std::size_t i = 0; i < rows_; ++i) {
        data_[ i * cols_ + col ] = values[ i ];
    }
}
 
// ============================================================================
// 私有辅助函数实现
// ============================================================================
 
template< typename T >
std::size_t da_vector_table< T >::index(std::size_t row, std::size_t col) const noexcept
{
    return row * cols_ + col;
}
 
template< typename T >
void da_vector_table< T >::check_bounds(std::size_t row, std::size_t col) const
{
    if (row >= rows_) {
        throw std::out_of_range("Row index out of range");
    }
    if (col >= cols_) {
        throw std::out_of_range("Column index out of range");
    }
}
 
template< typename T >
void da_vector_table< T >::check_row_bounds(std::size_t row) const
{
    if (row > rows_) {  // 允许在末尾插入，所以可以等于rows_
        throw std::out_of_range("Row index out of range");
    }
}
 
template< typename T >
void da_vector_table< T >::check_column_bounds(std::size_t col) const
{
    if (col > cols_) {  // 允许在末尾插入，所以可以等于cols_
        throw std::out_of_range("Column index out of range");
    }
}
 
}  // namespace DA
 
#endif  // DA_VECTOR_TABLE_H