DA::da_vector_table< T > 模板类 参考

二维表格数据结构，使用一维数组存储以提高缓存友好性 更多...

#include <da_vector_table.hpp>

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 ()
	默认构造函数
	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
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)
	设置指定列的数据

详细描述

template<typename T>
class DA::da_vector_table< T >

二维表格数据结构，使用一维数组存储以提高缓存友好性

模板参数

T	表格中存储的元素类型

此类提供了一个二维表格数据结构，内部使用一维数组存储以提高内存局部性和缓存友好性。 适合存放规则的结构化数据，并提供高效的随机访问性能。

构造及析构函数说明

da_vector_table() [1/5]

template<typename T >

DA::da_vector_table< T >::da_vector_table

(

)

默认构造函数

模板参数

T

表格元素类型

// 创建一个空的表格
DA::da_vector_table<int> table;

da_vector_table() [2/5]

template<typename T >

DA::da_vector_table< T >::da_vector_table ( std::size_t  rows, std::size_t  cols = 0, const T &  value = T()  )

explicit

构造函数，创建指定大小的表格

模板参数

T

表格元素类型

参数

rows	行数
cols	列数
value	初始值

// 创建一个3行4列的表格，所有元素初始化为0
DA::da_vector_table<int> table(3, 4, 0);
 
// 创建一个2行3列的表格，所有元素使用默认构造
DA::da_vector_table<std::string> table(2, 3);

da_vector_table() [3/5]

template<typename T >

DA::da_vector_table< T >::da_vector_table

(

std::initializer_list< std::initializer_list< T > >

init

)

使用初始化列表构造表格

模板参数

T

表格元素类型

参数

init

初始化列表

// 使用初始化列表创建表格
DA::da_vector_table<int> table = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

da_vector_table() [4/5]

template<typename T >

DA::da_vector_table< T >::da_vector_table

(

const da_vector_table< T > &

other

)

拷贝构造函数

模板参数

T

表格元素类型

参数

other

要拷贝的表格

DA::da_vector_table<int> table1(2, 3, 5);
// 创建table1的副本
DA::da_vector_table<int> table2(table1);

da_vector_table() [5/5]

template<typename T >

DA::da_vector_table< T >::da_vector_table ( da_vector_table< T > &&  other )

noexcept

移动构造函数

模板参数

T

表格元素类型

参数

other

要移动的表格

DA::da_vector_table<int> create_table() {
    DA::da_vector_table<int> table(3, 4, 1);
    return table; // 使用移动语义
}
 
auto table = create_table(); // 高效，不会拷贝数据

成员函数说明

append_column() [1/4]

template<typename T >

void DA::da_vector_table< T >::append_column

(

const std::vector< T > &

col

)

在表格末尾添加一列

模板参数

T

表格元素类型

参数

col

要添加的列

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
std::vector<int> new_col = {5, 6};
table.append_column(new_col); // 添加一列
// 现在表格为 {{1, 2, 5}, {3, 4, 6}}

append_column() [2/4]

template<typename T >

template<typename InputIt >

void DA::da_vector_table< T >::append_column	(	InputIt	first,
		InputIt	last
	)

使用迭代器范围在表格末尾添加一列

模板参数

T	表格元素类型
InputIt	输入迭代器类型

参数

first	范围起始迭代器
last	范围结束迭代器

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
std::vector<int> new_col = {5, 6};
// 添加新列
table.append_column(new_col.begin(), new_col.end());
// 现在表格为 {{1, 2, 5}, {3, 4, 6}}

append_column() [3/4]

template<typename T >

void DA::da_vector_table< T >::append_column

(

std::initializer_list< T >

il

)

使用初始化列表在表格末尾添加一列

模板参数

T

表格元素类型

参数

il

初始化列表

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
// 使用初始化列表添加新列
table.append_column({5, 6});
// 现在表格为 {{1, 2, 5}, {3, 4, 6}}

append_column() [4/4]

template<typename T >

void DA::da_vector_table< T >::append_column

(

std::vector< T > &&

col

)

在表格末尾添加一列（移动语义）

模板参数

T

表格元素类型

参数

col

要添加的列

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
std::vector<int> new_col = {5, 6};
table.append_column(std::move(new_col)); // 移动添加一列
// 现在表格为 {{1, 2, 5}, {3, 4, 6}}，new_col变为空

append_row() [1/4]

template<typename T >

void DA::da_vector_table< T >::append_row

(

const std::vector< T > &

row

)

在表格末尾添加一行

模板参数

T

表格元素类型

参数

row

要添加的行

DA::da_vector_table<int> table(2, 2, 1); // 2x2表格
std::vector<int> new_row = {2, 3};
table.append_row(new_row); // 添加一行
// 现在表格为3x2

append_row() [2/4]

template<typename T >

template<typename InputIt >

void DA::da_vector_table< T >::append_row	(	InputIt	first,
		InputIt	last
	)

使用迭代器范围在表格末尾添加一行

模板参数

T	表格元素类型
InputIt	输入迭代器类型

参数

first	范围起始迭代器
last	范围结束迭代器

DA::da_vector_table<int> table(2, 2, 1); // 2x2表格
std::vector<int> values = {2, 3};
// 添加前2个元素作为一行
table.append_row(values.begin(), values.end());
// 现在表格为3x2

append_row() [3/4]

template<typename T >

void DA::da_vector_table< T >::append_row

(

std::initializer_list< T >

il

)

使用初始化列表在表格末尾添加一行

模板参数

T

表格元素类型

参数

il

初始化列表

DA::da_vector_table<int> table(2, 2, 1); // 2x2表格
// 使用初始化列表添加一行
table.append_row({2, 3});
// 现在表格为3x2

append_row() [4/4]

template<typename T >

void DA::da_vector_table< T >::append_row

(

std::vector< T > &&

row

)

在表格末尾添加一行（移动语义）

模板参数

T

表格元素类型

参数

row

要添加的行

DA::da_vector_table<int> table(2, 2, 1); // 2x2表格
std::vector<int> new_row = {2, 3};
table.append_row(std::move(new_row)); // 移动添加一行
// 现在表格为3x2，new_row变为空

assign() [1/2]

template<typename T >

template<typename InputIt >

void DA::da_vector_table< T >::assign	(	InputIt	first,
		InputIt	last
	)

使用迭代器范围分配新内容替换当前内容

模板参数

T	表格元素类型
InputIt	输入迭代器类型

参数

first	范围起始迭代器
last	范围结束迭代器

注解

此方法假设输入数据是按行优先顺序排列的，并且行数和列数需要预先知道

DA::da_vector_table<int> table;
std::vector<int> values = {1, 2, 3, 4, 5, 6};
// 分配2行3列，使用前6个元素
table.assign(values.begin(), values.end());
// 需要手动设置行列数
table.reshape(2, 3);

assign() [2/2]

template<typename T >

void DA::da_vector_table< T >::assign	(	std::size_t	rows,
		std::size_t	cols,
		const T &	value
	)

分配新内容替换当前内容

模板参数

T

表格元素类型

参数

rows	新行数
cols	新列数
value	填充值

DA::da_vector_table<int> table;
// 分配3行4列，所有元素初始化为5
table.assign(3, 4, 5);

at() [1/2]

template<typename T >

T & DA::da_vector_table< T >::at	(	std::size_t	row,
		std::size_t	col
	)

访问指定位置的元素，带边界检查

模板参数

T

表格元素类型

参数

row	行索引
col	列索引

返回

指定位置元素的引用

异常

std::out_of_range

如果row或col超出范围

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
try {
    int& value = table.at(0, 1); // 获取第一行第二列的元素
    value = 10; // 修改为10
 
    // 尝试访问不存在的元素
    int& invalid = table.at(5, 5); // 抛出异常
} catch (const std::out_of_range& e) {
    std::cerr << "错误: " << e.what() << std::endl;
}

at() [2/2]

template<typename T >

const T & DA::da_vector_table< T >::at	(	std::size_t	row,
		std::size_t	col
	)		const

访问指定位置的元素，带边界检查（常量版本）

模板参数

T

表格元素类型

参数

row	行索引
col	列索引

返回

指定位置元素的常量引用

异常

std::out_of_range

如果row或col超出范围

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
try {
    const int& value = table.at(0, 1); // 获取第一行第二列的元素
    std::cout << "值: " << value << std::endl;
 
    // 尝试访问不存在的元素
    const int& invalid = table.at(5, 5); // 抛出异常
} catch (const std::out_of_range& e) {
    std::cerr << "错误: " << e.what() << std::endl;
}

back() [1/2]

template<typename T >

T & DA::da_vector_table< T >::back

(

)

访问表格的最后一个元素

模板参数

T

表格元素类型

返回

最后一个元素的引用

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
T& last = table.back();
last = 10; // 修改最后一个元素

back() [2/2]

template<typename T >

const T & DA::da_vector_table< T >::back

(

)

const

访问表格的最后一个元素（常量版本）

模板参数

T

表格元素类型

返回

最后一个元素的常量引用

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
const T& last = table.back();
std::cout << "最后一个元素: " << last << std::endl;

begin() [1/2]

template<typename T >

da_vector_table< T >::const_iterator DA::da_vector_table< T >::begin ( ) const

noexcept

返回指向表格第一个元素的常量迭代器

模板参数

T

表格元素类型

返回

指向表格第一个元素的常量迭代器

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
// 使用常量迭代器遍历所有元素
for (auto it = table.begin(); it != table.end(); ++it) {
    std::cout << *it << " ";
}

begin() [2/2]

template<typename T >

da_vector_table< T >::iterator DA::da_vector_table< T >::begin ( )

noexcept

返回指向表格第一个元素的迭代器

模板参数

T

表格元素类型

返回

指向表格第一个元素的迭代器

DA::da_vector_table<int> table = {{1, 2}, {3, 4}, {5, 6}};
// 使用迭代器遍历所有元素
for (auto it = table.begin(); it != table.end(); ++it) {
    std::cout << *it << " ";
}

capacity()

template<typename T >

std::size_t DA::da_vector_table< T >::capacity ( ) const

noexcept

返回当前分配的存储容量

模板参数

T

表格元素类型

返回

当前分配的存储容量

DA::da_vector_table<int> table;
table.reserve(50);
std::cout << "表格容量: " << table.capacity() << std::endl;

cbegin()

template<typename T >

da_vector_table< T >::const_iterator DA::da_vector_table< T >::cbegin ( ) const

noexcept

返回指向表格第一个元素的常量迭代器

模板参数

T

表格元素类型

返回

指向表格第一个元素的常量迭代器

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
// 使用常量迭代器遍历所有元素
for (auto it = table.cbegin(); it != table.cend(); ++it) {
    std::cout << *it << " ";
}

cend()

template<typename T >

da_vector_table< T >::const_iterator DA::da_vector_table< T >::cend ( ) const

noexcept

返回指向表格尾后位置的常量迭代器

模板参数

T

表格元素类型

返回

指向表格尾后位置的常量迭代器

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
// 使用常量迭代器遍历所有元素
for (auto it = table.cbegin(); it != table.cend(); ++it) {
    // 处理每个元素
}

clear()

template<typename T >

void DA::da_vector_table< T >::clear ( )

noexcept

清空表格中的所有元素

模板参数

T

表格元素类型

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
table.clear(); // 清空表格
// 现在表格为空

column_count()

template<typename T >

std::size_t DA::da_vector_table< T >::column_count ( ) const

noexcept

获取表格的列数

模板参数

T

表格元素类型

返回

表格的列数

DA::da_vector_table<int> table(3, 4);
std::cout << "表格有 " << table.column_count() << " 列" << std::endl;
// 输出: 表格有 4 列

crbegin()

template<typename T >

da_vector_table< T >::const_reverse_iterator DA::da_vector_table< T >::crbegin ( ) const

noexcept

返回指向表格最后一个元素的常量反向迭代器

模板参数

T

表格元素类型

返回

指向表格最后一个元素的常量反向迭代器

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}, {5, 6}};
// 使用常量反向迭代器逆序遍历所有元素
for (auto it = table.crbegin(); it != table.crend(); ++it) {
    std::cout << *it << " ";
}

crend()

template<typename T >

da_vector_table< T >::const_reverse_iterator DA::da_vector_table< T >::crend ( ) const

noexcept

返回指向表格第一个元素前一个位置的常量反向迭代器

模板参数

T

表格元素类型

返回

指向表格第一个元素前一个位置的常量反向迭代器

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}, {5, 6}};
// 使用常量反向迭代器逆序遍历所有元素
for (auto it = table.crbegin(); it != table.crend(); ++it) {
    // 处理每个元素
}

data() [1/2]

template<typename T >

const T * DA::da_vector_table< T >::data ( ) const

noexcept

返回指向底层数组的指针（常量版本）

模板参数

T

表格元素类型

返回

指向底层数组的常量指针

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
const int* ptr = table.data();
// 可以读取底层数组
for (std::size_t i = 0; i < table.size(); ++i) {
    std::cout << ptr[i] << " ";
}

data() [2/2]

template<typename T >

T * DA::da_vector_table< T >::data ( )

noexcept

返回指向底层数组的指针

模板参数

T

表格元素类型

返回

指向底层数组的指针

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
int* ptr = table.data();
// 可以直接操作底层数组
for (std::size_t i = 0; i < table.size(); ++i) {
    ptr[i] += 1;
}

emplace_back()

template<typename T >

template<typename... Args>

void DA::da_vector_table< T >::emplace_back

(

Args &&...

args

)

在表格末尾原位构造一个元素

模板参数

T	表格元素类型
Args	参数类型

参数

args

构造参数

注解

此操作会破坏表格的矩形结构，慎用

DA::da_vector_table<std::pair<int, std::string>> table;
// 原位构造一个元素
table.emplace_back(1, "one");

empty()

template<typename T >

bool DA::da_vector_table< T >::empty ( ) const

noexcept

检查表格是否为空

模板参数

T

表格元素类型

返回

如果表格为空返回true，否则返回false

DA::da_vector_table<int> table;
if (table.empty()) {
    std::cout << "表格为空" << std::endl;
}

end() [1/2]

template<typename T >

da_vector_table< T >::const_iterator DA::da_vector_table< T >::end ( ) const

noexcept

返回指向表格尾后位置的常量迭代器

模板参数

T

表格元素类型

返回

指向表格尾后位置的常量迭代器

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
// 使用常量迭代器遍历所有元素
for (auto it = table.begin(); it != table.end(); ++it) {
    // 处理每个元素
}

end() [2/2]

template<typename T >

da_vector_table< T >::iterator DA::da_vector_table< T >::end ( )

noexcept

返回指向表格尾后位置的迭代器

模板参数

T

表格元素类型

返回

指向表格尾后位置的迭代器

DA::da_vector_table<int> table = {{1, 2}, {3, 4}, {5, 6}};
// 使用迭代器遍历所有元素
for (auto it = table.begin(); it != table.end(); ++it) {
    // 处理每个元素
}

erase_column()

template<typename T >

void DA::da_vector_table< T >::erase_column

(

std::size_t

pos

)

移除指定位置的列（高效版本）

模板参数

T

表格元素类型

参数

pos

要移除的列位置

此版本通过创建新向量来避免多次数据移动，提高大型表格的操作效率。

DA::da_vector_table<int> table = {{1, 2, 3}, {4, 5, 6}};
// 移除第二列
table.erase_column(1);
// 现在表格为 {{1, 3}, {4, 6}}

erase_row()

template<typename T >

void DA::da_vector_table< T >::erase_row

(

std::size_t

pos

)

移除指定位置的行

模板参数

T

表格元素类型

参数

pos

要移除的行位置

DA::da_vector_table<int> table = {{1, 2}, {3, 4}, {5, 6}};
// 移除第二行
table.erase_row(1);
// 现在表格为 {{1, 2}, {5, 6}}

front() [1/2]

template<typename T >

T & DA::da_vector_table< T >::front

(

)

访问表格的第一个元素

模板参数

T

表格元素类型

返回

第一个元素的引用

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
T& first = table.front();
first = 10; // 修改第一个元素

front() [2/2]

template<typename T >

const T & DA::da_vector_table< T >::front

(

)

const

访问表格的第一个元素（常量版本）

模板参数

T

表格元素类型

返回

第一个元素的常量引用

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
const T& first = table.front();
std::cout << "第一个元素: " << first << std::endl;

get_column()

template<typename T >

std::vector< T > DA::da_vector_table< T >::get_column

(

std::size_t

col

)

const

获取指定列的数据

模板参数

T

表格元素类型

参数

col

列索引

返回

包含指定列数据的向量

DA::da_vector_table<int> table = {{1, 2, 3}, {4, 5, 6}};
// 获取第二列
std::vector<int> col1 = table.get_column(1);
// col1 包含 {2, 5}

get_row()

template<typename T >

std::vector< T > DA::da_vector_table< T >::get_row

(

std::size_t

row

)

const

获取指定行的数据

模板参数

T

表格元素类型

参数

row

行索引

返回

包含指定行数据的向量

DA::da_vector_table<int> table = {{1, 2, 3}, {4, 5, 6}};
// 获取第一行
std::vector<int> row0 = table.get_row(0);
// row0 包含 {1, 2, 3}

insert_column() [1/2]

template<typename T >

void DA::da_vector_table< T >::insert_column	(	std::size_t	pos,
		const std::vector< T > &	col
	)

在指定位置插入一列

模板参数

T

表格元素类型

参数

pos	插入位置
col	要插入的列

DA::da_vector_table<int> table = {{1, 3}, {4, 6}};
std::vector<int> new_col = {2, 5};
// 在第一列后插入新列
table.insert_column(1, new_col);
// 现在表格为 {{1, 2, 3}, {4, 5, 6}}

insert_column() [2/2]

template<typename T >

void DA::da_vector_table< T >::insert_column	(	std::size_t	pos,
		std::vector< T > &&	col
	)

在指定位置插入一列（移动语义）

模板参数

T

表格元素类型

参数

pos	插入位置
col	要插入的列

DA::da_vector_table<int> table = {{1, 3}, {4, 6}};
std::vector<int> new_col = {2, 5};
// 在第一列后插入新列
table.insert_column(1, std::move(new_col));
// 现在表格为 {{1, 2, 3}, {4, 5, 6}}，new_col变为空

insert_row() [1/2]

template<typename T >

void DA::da_vector_table< T >::insert_row	(	std::size_t	pos,
		const std::vector< T > &	row
	)

在指定位置插入一行

模板参数

T

表格元素类型

参数

pos	插入位置
row	要插入的行

DA::da_vector_table<int> table = {{1, 2}, {4, 5}};
std::vector<int> new_row = {7, 8};
// 在第一行后插入新行
table.insert_row(1, new_row);
// 现在表格为 {{1, 2}, {7, 8}, {4, 5}}

insert_row() [2/2]

template<typename T >

void DA::da_vector_table< T >::insert_row	(	std::size_t	pos,
		std::vector< T > &&	row
	)

在指定位置插入一行（移动语义）

模板参数

T

表格元素类型

参数

pos	插入位置
row	要插入的行

DA::da_vector_table<int> table = {{1, 2}, {4, 5}};
std::vector<int> new_row = {7, 8};
// 在第一行后插入新行
table.insert_row(1, std::move(new_row));
// 现在表格为 {{1, 2}, {7, 8}, {4, 5}}，new_row变为空

max_size()

template<typename T >

std::size_t DA::da_vector_table< T >::max_size ( ) const

noexcept

返回表格可容纳的最大元素数

模板参数

T

表格元素类型

返回

表格可容纳的最大元素数

DA::da_vector_table<int> table;
std::cout << "表格最大可容纳 " << table.max_size() << " 个元素" << std::endl;

operator()() [1/2]

template<typename T >

T & DA::da_vector_table< T >::operator()	(	std::size_t	row,
		std::size_t	col
	)

访问指定位置的元素（函数调用运算符）

模板参数

T

表格元素类型

参数

row	行索引
col	列索引

返回

指定位置元素的引用

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
// 访问第一行第二列的元素
int& value = table(0, 1);
value = 10; // 修改为10

operator()() [2/2]

template<typename T >

const T & DA::da_vector_table< T >::operator()	(	std::size_t	row,
		std::size_t	col
	)		const

访问指定位置的元素（函数调用运算符，常量版本）

模板参数

T

表格元素类型

参数

row	行索引
col	列索引

返回

指定位置元素的常量引用

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
// 访问第一行第二列的元素
const int& value = table(0, 1);
std::cout << "值: " << value << std::endl;

operator=() [1/2]

template<typename T >

da_vector_table< T > & DA::da_vector_table< T >::operator=

(

const da_vector_table< T > &

other

)

拷贝赋值运算符

模板参数

T

表格元素类型

参数

other

要拷贝的表格

返回

当前表格的引用

DA::da_vector_table<int> table1(2, 3, 5);
DA::da_vector_table<int> table2;
table2 = table1; // 拷贝赋值

operator=() [2/2]

template<typename T >

da_vector_table< T > & DA::da_vector_table< T >::operator= ( da_vector_table< T > &&  other )

noexcept

移动赋值运算符

模板参数

T

表格元素类型

参数

other

要移动的表格

返回

当前表格的引用

DA::da_vector_table<int> table1(2, 3, 5);
DA::da_vector_table<int> table2;
table2 = std::move(table1); // 移动赋值，table1变为空

pop_back()

template<typename T >

void DA::da_vector_table< T >::pop_back

(

)

移除表格的最后一个元素

模板参数

T

表格元素类型

注解

此操作会破坏表格的矩形结构，慎用

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
table.pop_back(); // 移除最后一个元素4

push_back() [1/2]

template<typename T >

void DA::da_vector_table< T >::push_back

(

const T &

value

)

在表格末尾添加一个元素

模板参数

T

表格元素类型

参数

value

要添加的元素

注解

此操作会破坏表格的矩形结构，慎用

DA::da_vector_table<int> table(2, 2, 1); // 2x2表格
table.push_back(5); // 添加一个元素，表格变为非矩形

push_back() [2/2]

template<typename T >

void DA::da_vector_table< T >::push_back

(

T &&

value

)

在表格末尾添加一个元素（移动语义）

模板参数

T

表格元素类型

参数

value

要添加的元素

注解

此操作会破坏表格的矩形结构，慎用

DA::da_vector_table<std::string> table(2, 2, "hello");
std::string s = "world";
table.push_back(std::move(s)); // 移动添加一个元素

rbegin() [1/2]

template<typename T >

da_vector_table< T >::const_reverse_iterator DA::da_vector_table< T >::rbegin ( ) const

noexcept

返回指向表格最后一个元素的常量反向迭代器

模板参数

T

表格元素类型

返回

指向表格最后一个元素的常量反向迭代器

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}, {5, 6}};
// 使用常量反向迭代器逆序遍历所有元素
for (auto it = table.rbegin(); it != table.rend(); ++it) {
    std::cout << *it << " ";
}

rbegin() [2/2]

template<typename T >

da_vector_table< T >::reverse_iterator DA::da_vector_table< T >::rbegin ( )

noexcept

返回指向表格最后一个元素的反向迭代器

模板参数

T

表格元素类型

返回

指向表格最后一个元素的反向迭代器

DA::da_vector_table<int> table = {{1, 2}, {3, 4}, {5, 6}};
// 使用反向迭代器逆序遍历所有元素
for (auto it = table.rbegin(); it != table.rend(); ++it) {
    std::cout << *it << " ";
}

rend() [1/2]

template<typename T >

da_vector_table< T >::const_reverse_iterator DA::da_vector_table< T >::rend ( ) const

noexcept

返回指向表格第一个元素前一个位置的常量反向迭代器

模板参数

T

表格元素类型

返回

指向表格第一个元素前一个位置的常量反向迭代器

const DA::da_vector_table<int> table = {{1, 2}, {3, 4}, {5, 6}};
// 使用常量反向迭代器逆序遍历所有元素
for (auto it = table.rbegin(); it != table.rend(); ++it) {
    // 处理每个元素
}

rend() [2/2]

template<typename T >

da_vector_table< T >::reverse_iterator DA::da_vector_table< T >::rend ( )

noexcept

返回指向表格第一个元素前一个位置的反向迭代器

模板参数

T

表格元素类型

返回

指向表格第一个元素前一个位置的反向迭代器

DA::da_vector_table<int> table = {{1, 2}, {3, 4}, {5, 6}};
// 使用反向迭代器逆序遍历所有元素
for (auto it = table.rbegin(); it != table.rend(); ++it) {
    // 处理每个元素
}

reserve()

template<typename T >

void DA::da_vector_table< T >::reserve

(

std::size_t

new_cap

)

预留存储空间

模板参数

T

表格元素类型

参数

new_cap

新的容量值

DA::da_vector_table<int> table;
// 预留空间以提高后续添加元素的性能
table.reserve(100);

reshape()

template<typename T >

void DA::da_vector_table< T >::reshape	(	std::size_t	rows,
		std::size_t	cols
	)

改变表格形状而不改变数据总量

模板参数

T

表格元素类型

参数

rows	新的行数
cols	新的列数

异常

std::invalid_argument

如果新形状的元素总数与当前不同

DA::da_vector_table<int> table = {{1, 2, 3, 4}};
// 改变形状为2x2
table.reshape(2, 2);
// 现在表格为 {{1, 2}, {3, 4}}

resize() [1/2]

template<typename T >

void DA::da_vector_table< T >::resize	(	std::size_t	rows,
		std::size_t	cols,
		const T &	value = T()
	)

调整表格大小

模板参数

T

表格元素类型

参数

rows	新的行数
cols	新的列数
value	新元素的初始值

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
// 调整大小为3行4列，新元素初始化为0
table.resize(3, 4, 0);
// 现在表格为3行4列，新增元素为0

resize() [2/2]

template<typename T >

void DA::da_vector_table< T >::resize	(	table_index_type	sh,
		const T &	value = T()
	)

使用形状对象调整表格大小

模板参数

T

表格元素类型

参数

sh	包含新行数和列数的形状对象
value	新元素的初始值

DA::da_vector_table<int> table = {{1, 2}, {3, 4}};
// 调整大小为3行4列，新元素初始化为0
table.resize({3, 4}, 0);
// 现在表格为3行4列，新增元素为0

row_count()

template<typename T >

std::size_t DA::da_vector_table< T >::row_count ( ) const

noexcept

获取表格的行数

模板参数

T

表格元素类型

返回

表格的行数

DA::da_vector_table<int> table(3, 4);
std::cout << "表格有 " << table.row_count() << " 行" << std::endl;
// 输出: 表格有 3 行

set_column()

template<typename T >

void DA::da_vector_table< T >::set_column	(	std::size_t	col,
		const std::vector< T > &	values
	)

设置指定列的数据

模板参数

T

表格元素类型

参数

col	列索引
values	要设置的值

异常

std::invalid_argument

如果值数量与行数不匹配

DA::da_vector_table<int> table = {{1, 2, 3}, {4, 5, 6}};
// 设置第二列
table.set_column(1, {7, 8});
// 现在表格为 {{1, 7, 3}, {4, 8, 6}}

set_row()

template<typename T >

void DA::da_vector_table< T >::set_row	(	std::size_t	row,
		const std::vector< T > &	values
	)

设置指定行的数据

模板参数

T

表格元素类型

参数

row	行索引
values	要设置的值

异常

std::invalid_argument

如果值数量与列数不匹配

DA::da_vector_table<int> table = {{1, 2, 3}, {4, 5, 6}};
// 设置第一行
table.set_row(0, {7, 8, 9});
// 现在表格为 {{7, 8, 9}, {4, 5, 6}}

shape()

template<typename T >

da_vector_table< T >::table_index_type DA::da_vector_table< T >::shape ( ) const

noexcept

获取表格的形状（行数和列数）

模板参数

T

表格元素类型

返回

包含行数和列数的pair

DA::da_vector_table<int> table(3, 4, 1);
auto shape = table.shape();
std::cout << "表格形状: " << shape.first << " 行, "
          << shape.second << " 列" << std::endl;
// 输出: 表格形状: 3 行, 4 列

shrink_to_fit()

template<typename T >

void DA::da_vector_table< T >::shrink_to_fit

(

)

请求移除未使用的容量

模板参数

T

表格元素类型

DA::da_vector_table<int> table;
// 添加一些元素
table.resize(3, 4, 1);
// 释放多余内存
table.shrink_to_fit();

size()

template<typename T >

std::size_t DA::da_vector_table< T >::size ( ) const

noexcept

返回表格中的元素总数

模板参数

T

表格元素类型

返回

表格中的元素总数

DA::da_vector_table<int> table(3, 4);
std::cout << "表格有 " << table.size() << " 个元素" << std::endl;

swap()

template<typename T >

void DA::da_vector_table< T >::swap ( da_vector_table< T > &  other )

noexcept

交换两个表格的内容

模板参数

T

表格元素类型

参数

other

要交换的另一个表格

DA::da_vector_table<int> table1 = {{1, 2}, {3, 4}};
DA::da_vector_table<int> table2 = {{5, 6}};
table1.swap(table2);
// 现在table1包含{{5, 6}}，table2包含{{1, 2}, {3, 4}}

---

该类的文档由以下文件生成:

• /home/runner/work/data-workbench/data-workbench/src/DAShared/da_vector_table.hpp