#include <list.hpp>

类 cm::List< T > 继承关系图:

cm::List< T > 的协作图:

Public 成员函数
	List ()=default
	列表类的默认构造函数

	List (const List< T > &list)=default
	列表类的拷贝构造函数

	List (const std::vector< T > &list)
	列表类的带参构造函数

	~List ()=default
	列表类的析构函数

List< T > &	operator+= (const List< T > &list)
	列表类重载加等于运算符

template<typename FUNC >
List< T >	Filter (const FUNC &func) const
	过滤列表项

template<typename U , typename FUNC >
U	Reduce (const FUNC &func, U initial_value=U{}) const
	累计列表项

template<typename U = T, typename FUNC >
List< U >	Map (const FUNC &func) const
	列表项映射

template<typename FUNC >
List< T >	MutFilter (const FUNC &func)
	过滤列表项

template<typename U , typename FUNC >
U	MutReduce (const FUNC &func, U initial_value=U{})
	累计列表项

template<typename U = T, typename FUNC >
List< U >	MutMap (const FUNC &func)
	列表项映射

const_iterator	Max () const
	求列表中的最大值

template<typename FUNC >
const_iterator	Max (const FUNC &func) const
	求列表中的最大值

const_iterator	Min () const
	求列表中的最小值

template<typename FUNC >
const_iterator	Min (const FUNC &func) const
	求列表中的最小值

List< T > &	Sort ()
	对列表进行排序

template<typename FUNC >
List< T > &	Sort (const FUNC &func)
	对列表进行排序

iterator	Order (size_t index)
	按序获取列表中指定索引的元素

template<typename FUNC >
iterator	Order (size_t index, const FUNC &func)
	按序获取列表中指定索引的元素

bool	Include (const T &value) const
	判断列表中是否包含指定值

template<typename FUNC >
bool	Include (const FUNC &func) const
	判断列表中是否包含满足指定条件的值

size_t	Index (const T &value, size_t from_index=0) const
	查找指定值在列表中的索引

template<typename FUNC >
size_t	Index (const FUNC &func, size_t from_index=0) const
	查找指定值在列表中的索引

size_t	LastIndex (const T &value, size_t from_index=INT_MAX) const
	查找指定值在列表中的索引

template<typename FUNC >
size_t	LastIndex (const FUNC &func, size_t from_index=INT_MAX) const
	查找指定值在列表中的索引

size_t	Count (const T &value) const
	统计列表中指定值的出现次数

template<typename FUNC >
size_t	Count (const FUNC &func) const
	统计满足指定条件的元素个数

List< T > &	Reverse ()
	对列表中的元素进行反转

List< T > &	Shuffle ()
	对列表中的元素进行随机打乱

List< T > &	Fill (const T &value)
	将列表中所有元素填充为指定值

List< T >	Slice (size_t start, size_t end=UINT_MAX) const
	切片提取列表中指定范围的元素

友元
template<typename U >
List< U >	operator+ (const List< U > &list1, const List< U > &list2)
	列表类重载加法运算符

template<typename U >
std::ostream &	operator<< (std::ostream &out, const List< U > &list)
	列表类重载输出流运算符

详细描述

template<typename T>
class cm::List< T >

列表类

列表容器公有继承自 std::vector，能够在固定的时间内访问任意顺序的单个元素，并提供了多种便捷的方法。

模板参数

T 列表容器元素类型

作者: dreamy-xay

日期: 2024-03-01

在文件 list.hpp 第 36 行定义.

构造及析构函数说明

◆ List() [1/3]

template<typename T >

cm::List< T >::List ( )

default

列表类的默认构造函数

◆ List() [2/3]

template<typename T >

cm::List< T >::List ( const List< T > & list )

default

列表类的拷贝构造函数

◆ List() [3/3]

template<typename T >

cm::List< T >::List ( const std::vector< T > & list )

inline

列表类的带参构造函数

该构造函数通过接受一个 STL 向量作为参数来初始化列表，将向量中的元素逐一添加到列表中。

参数

list	STL 向量，用于初始化列表

作者: dreamy-xay

日期: 2023-12-03

在文件 list.hpp 第 129 行定义.

◆ ~List()

template<typename T >

cm::List< T >::~List ( )

default

列表类的析构函数

成员函数说明

◆ Count() [1/2]

template<typename T >

template<typename FUNC >

size_t cm::List< T >::Count ( const FUNC & func ) const

inline

统计满足指定条件的元素个数

该方法用于统计列表中满足指定条件的元素个数。需要提供一个判断函数，用于判断列表中的元素是否符合指定条件。

模板参数

FUNC	判断函数类型，接受一个列表项作为参数，返回`bool`值，形式为`(const T& value) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	判断是否指定值的函数，返回`true`时表示是，反之不是

返回: 满足指定条件的元素个数

注意

该函数是常函数，不支持修改原始列表中的项。判断函数切勿使用直接引用 (T& value) -> bool。
在使用 lambda 表达式作为判断函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 定义一个值判断函数，计算列表中大于2的数的个数

bool Check(const int& num) {

return num > 2;

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> numbers = {1, -5, 3, -10, 2, 6};

// 使用函数指针：计算列表中大于2的数的个数

size_t count = numbers.Count(Check); // count: 2

// 使用 Lambda 表达式：计算列表中绝对值大于2的数的个数

count = numbers.Count([](int num) { // 不使用引用时，参数类型可以不使用常量

return std::abs(num) > 2;

}); // count: 4

}

cm::Point
点类
Definition point.hpp:52

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 1274 行定义.

◆ Count() [2/2]

template<typename T >

size_t cm::List< T >::Count ( const T & value ) const

inline

统计列表中指定值的出现次数

该方法用于统计列表中指定值出现的次数。遍历整个列表，对每个元素与指定值进行比较，如果相等则计数器加1。最终返回指定值在列表中出现的总次数。

参数

value 要统计出现次数的值

返回: 指定值在列表中出现的次数

注意: 要求列表项类型 T 已经重载了等于运算符，否则程序将产生运行错误。

示例: // 初始化列表

cm::List<int> numbers = {1, 2, 3, 2, 4, 2, 5};

// 统计列表中2出现的次数

size_t count = numbers.Count(2); // count: 3

// 统计列表中3出现的次数

count = numbers.Count(3); // count: 1

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 1221 行定义.

◆ Fill()

template<typename T >

List< T > & cm::List< T >::Fill ( const T & value )

inline

将列表中所有元素填充为指定值

该方法遍历整个列表，将其中所有的元素设置为指定的填充值。

参数

value 要填充的值

返回: 类自身引用，方便链式调用

示例: // 创建一个整数列表

cm::List<int> my_list = { 1, 2, 3, 4, 5 };

// 将列表所有元素填充为10，并使用链式调用

my_list.Fill(10).push_back(6).push_back(7);

// 输出结果

for (const auto& item : my_list) {

std::cout << item << " ";

}

// 输出：10 10 10 10 10 6 7

作者: dreamy-xay

日期: 2024-01-13

在文件 list.hpp 第 1374 行定义.

◆ Filter()

template<typename T >

template<typename FUNC >

List< T > cm::List< T >::Filter ( const FUNC & func ) const

inline

过滤列表项

该方法用于过滤列表中的项，根据传入的过滤函数判断是否保留该项，将符合条件的项添加到新的列表中并返回。

模板参数

FUNC	过滤函数类型，接受一个列表项参数，返回`bool`值，形式为`(const T& item) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型。

参数

func	过滤函数，当返回`true`时保留该项，反之则过滤

返回: 过滤后的新列表

注意

该函数是常函数，不支持修改原始列表中的项。过滤函数切勿使用直接引用 (T& item) -> bool。如果想要修改原始列表中的项，请使用 MutFilter 函数。
在使用 lambda 表达式作为过滤函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 保留偶数，过滤奇数函数

void KeepEven(int num) { // 不使用引用时，参数类型可以不使用常量

return num % 2 == 0;

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> nums = {1, 2, 3, 4, 5, 6, 7};

// 使用函数指针：保留偶数，过滤所有奇数

nums = nums.Filter(KeepEven); // nums: [2, 4, 6]

// 使用 Lambda 表达式：保留奇数，过滤所有偶数

nums = nums.Filter([] (const int& num) { return num % 2 == 1; }); // nums: []

}

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 270 行定义.

这是这个函数的调用关系图:

◆ Include() [1/2]

template<typename T >

template<typename FUNC >

bool cm::List< T >::Include ( const FUNC & func ) const

inline

判断列表中是否包含满足指定条件的值

该方法用于判断列表中是否存在满足指定条件的值。需要提供一个判断函数，用于判断列表中的元素是否符合指定条件。内部调用了 Index 方法来查找满足条件的值的索引位置，若索引小于列表长度，则说明存在这样的值。

模板参数

FUNC	判断函数类型，接受一个列表项作为参数，返回`bool`值，形式为`(const T& value) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	判断是否指定值的函数，返回`true`时表示是，反之不是

返回: 列表中是否包含满足指定条件的值

返回值

true	列表中存在满足条件的值
false	列表中不存在满足条件的值

注意

该函数是常函数，不支持修改原始列表中的项。判断函数切勿使用直接引用 (T& value) -> bool。
在使用 lambda 表达式作为判断函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 定义一个值判断函数，判断列表中是否存在大于8的数

bool Check(const int& num) {

return num > 8;

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> numbers = {1, -5, 3, -10, 2, 6};

// 使用函数指针：判断列表中是否存在大于8的数

bool has_num = numbers.Include(Check); // has_num: false

// 使用 Lambda 表达式：判断列表中是否绝对值存在大于8的数

has_num = numbers.Include([](int num) { // 不使用引用时，参数类型可以不使用常量

return std::abs(num) > 8;

}); // has_num: true

}

返回: 列表中是否包含该值

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 1009 行定义.

◆ Include() [2/2]

template<typename T >

bool cm::List< T >::Include ( const T & value ) const

inline

判断列表中是否包含指定值

该方法用于判断列表中是否包含指定的值。内部调用了 Index 方法来查找指定值的索引位置，若索引小于列表长度，则说明列表中包含这个值。

参数

value 要判断是否存在的值

返回: 列表中是否包含指定值

返回值

true	列表中包含指定值
false	列表中不包含指定值

注意: 要求列表项类型 T 已经重载了等于运算符，否则程序将产生运行错误。

示例: // 初始化列表

cm::List<int> numbers = {1, 2, 3, 4, 5};

// 判断列表中是否存在3这个数

bool has_num = numbers.Index(3); // has_num: true

// 判断列表中是否存在6这个数

index = numbers.Index(6); // has_num: false

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 961 行定义.

◆ Index() [1/2]

template<typename T >

template<typename FUNC >

size_t cm::List< T >::Index	(	const FUNC &	func,
		size_t	from_index = 0 ) const

inline

查找指定值在列表中的索引

该方法用于在列表中查找满足指定条件的值的索引位置，采取的策略是自左向右逐一检索。一旦发现首个满足条件的元素，便立即返回该元素的索引值。另外需要提供一个判断函数，用于判断列表中的元素是否符合指定条件。

模板参数

FUNC	判断函数类型，接受一个列表项作为参数，返回`bool`值，形式为`(const T& value) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	判断是否指定值的函数，返回`true`时表示是，反之不是
from_index	从指定索引位置开始查找 `默认为 0`

返回: 找到的值在列表中的索引，如果未找到则返回列表长度

注意

该函数是常函数，不支持修改原始列表中的项。判断函数切勿使用直接引用 (T& value) -> bool。
在使用 lambda 表达式作为判断函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 定义一个值判断函数，从左往右查找第一个大于3的数

bool Check(const int& num) {

return num > 3;

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> numbers = {1, -5, 3, -10, 2, 6};

// 使用函数指针：从左往右查找绝对值从大到小排第三的元素

size_t index = numbers.Index(Check, 1); // 现在 index 的值为5，表示在索引位置1及之后第一个大于3的数(6)的索引为5

// 使用 Lambda 表达式：从左往右查找绝对值第一个大于3的数

index = numbers.Index([](int num) { // 不使用引用时，参数类型可以不使用常量

return std::abs(num) > 3;

}); // 现在 index 的值为1，表示在索引位置0及之后绝对值第一个大于3的数(-5)的索引为1

}

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 1093 行定义.

◆ Index() [2/2]

template<typename T >

size_t cm::List< T >::Index	(	const T &	value,
		size_t	from_index = 0 ) const

inline

查找指定值在列表中的索引

此方法用于在列表中查找指定值的索引位置，采取的策略是自左向右逐一检索。一旦发现首个满足条件的元素，便立即返回该元素的索引值。

参数

value	要查找的值
from_index	从指定索引位置开始查找 `默认为 0`

返回: 找到的值在列表中的索引，如果未找到则返回列表长度

注意: 要求列表项类型 T 已经重载了等于运算符，否则程序将产生运行错误。

示例: // 初始化列表

cm::List<int> my_list = {1, 2, 3, 4, 5};

// 从左往右查找指定值在列表中的索引

size_t index = my_list.Index(3, 1); // 现在 index 的值为2，表示在索引位置1及之后找到值3的索引为2

// 从左往右查找指定值在列表中的索引

index = my_list.Index(3, 3); // 现在 index 的值为5，表示在索引位置3及之后找不到值3

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 1040 行定义.

◆ LastIndex() [1/2]

template<typename T >

template<typename FUNC >

size_t cm::List< T >::LastIndex	(	const FUNC &	func,
		size_t	from_index = INT_MAX ) const

inline

查找指定值在列表中的索引

该方法用于在列表中查找满足指定条件的值的索引位置，采取的策略是自右向左逐一检索。一旦发现首个满足条件的元素，便立即返回该元素的索引值。另外需要提供一个判断函数，用于判断列表中的元素是否符合指定条件。

模板参数

FUNC	判断函数类型，接受一个列表项作为参数，返回`bool`值，形式为`(const T& value) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	判断是否指定值的函数，返回`true`时表示是，反之不是
from_index	从指定索引位置开始查找 `默认为 UINT_MAX，即从最后一个开始`

返回: 找到的值在列表中的索引，如果未找到则返回列表长度

注意

该函数是常函数，不支持修改原始列表中的项。判断函数切勿使用直接引用 (T& value) -> bool。
在使用 lambda 表达式作为判断函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 定义一个值判断函数，从右往左查找第一个大于3的数

bool Check(const int& num) {

return num > 3;

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> numbers = {1, -5, 3, -10, 2, 6};

// 使用函数指针：从右往左查找绝对值从大到小排第三的元素

size_t index = numbers.Index(Check); // 现在 index 的值为5，表示在索引位置5及之前第一个大于3的数(6)的索引为5

// 使用 Lambda 表达式：从右往左查找绝对值第一个大于3的数

index = numbers.Index([](int num) { // 不使用引用时，参数类型可以不使用常量

return std::abs(num) > 3;

}, 4); // 现在 index 的值为3，表示在索引位置4及之前绝对值第一个大于3的数(-10)的索引为3

}

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 1184 行定义.

◆ LastIndex() [2/2]

template<typename T >

size_t cm::List< T >::LastIndex	(	const T &	value,
		size_t	from_index = INT_MAX ) const

inline

查找指定值在列表中的索引

此方法用于在列表中查找指定值的索引位置，采取的策略是自右向左逐一检索。一旦发现首个满足条件的元素，便立即返回该元素的索引值。

参数

value	要查找的值
from_index	从指定索引位置开始查找 `默认为 UINT_MAX，即从最后一个开始`

返回: 找到的值在列表中的索引，如果未找到则返回列表长度

注意: 要求列表项类型 T 已经重载了等于运算符，否则程序将产生运行错误。

示例: // 初始化列表

cm::List<int> my_list = {1, 2, 3, 4, 5};

// 从右往左查找指定值在列表中的索引

size_t index = my_list.LastIndex(3, 3); // 现在 index 的值为2，表示在索引位置3及之前找到值3的索引为2

// 从右往左查找指定值在列表中的索引

index = my_list.Index(3, 1); // 现在 index 的值为5，表示在索引位置1及之前找不到值3

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 1131 行定义.

◆ Map()

template<typename T >

template<typename U , typename FUNC >

List< U > cm::List< T >::Map ( const FUNC & func ) const

inline

列表项映射

该方法用于对列表中的每个元素进行映射处理，根据传入的映射函数，返回映射后的新列表。

模板参数

U	映射值类型，支持编译器自行推导类型
FUNC	映射函数类型，接受列表项作为参数，返回映射后的值，形式为`(const T& item) -> U`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	映射函数，返回映射后的值

返回: 映射后的新列表

注意

该函数是常函数，不支持修改原始列表中的项。映射函数切勿使用直接引用 (T& item) -> bool。如果想要修改原始列表中的项，请使用 MutMap 函数。
在使用 lambda 表达式作为映射函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 将字符串列表转换为长度列表

int GetLength(const std::string& str) {

return str.length();

}

// 测试函数

void Test() {

// 初始化列表

cm::List<std::string> words = {"hello", "world", "c++"};

// 使用函数指针：将字符串列表转换为长度列表

cm::List<int> lengths = words.Map<int>(GetLength); // lengths: [5, 5, 3]

// 使用 Lambda 表达式：将字符串列表转换为大写形式列表，并获取最后一个字符作为映射值

cm::List<char> chars = words.Map<char>([] (const std::string& str) { return std::toupper(str).back(); }); // chars: ['O', 'D', '+']

}

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 370 行定义.

◆ Max() [1/2]

template<typename T >

List< T >::const_iterator cm::List< T >::Max ( ) const

inline

求列表中的最大值

该方法用于获取列表中的最大元素。

返回: 指向最大元素的常量迭代器，如果列表为空则返回结束迭代器

注意: 要求列表项类型 T 已经重载了比较运算符（要求支持小于操作符 <），否则程序将产生运行错误。

示例: // 初始化列表

cm::List<int> list = {1, 8, 0, 2, -5 , 6, 121};

// 打印列表中的最大值

std::cout << *list.Max() << "\n"; // 输出：121

// 初始化字符串列表

cm::List<std::string> str_list = {"hello", "world", "cpp"};

// 打印列表中的最大值以及其长度

cm::List<std::string>::const_iterator iter = str_list.Max();

std::cout << *iter << " " << iter->length() << "\n"; // 输出：world 5

cm::List
列表类
Definition list.hpp:36

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 572 行定义.

◆ Max() [2/2]

template<typename T >

template<typename FUNC >

List< T >::const_iterator cm::List< T >::Max ( const FUNC & func ) const

inline

求列表中的最大值

该方法用于获取列表中的最大元素，并根据传入的比较函数进行比较。

模板参数

FUNC	比较函数类型，接受两个列表项作为参数，返回`bool`值，形式为`(const T& item1, const T& item2) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	比较函数，返回 true 时更新第二个列表项参数`item2`作为最大值，反之不更新

返回: 指向最大元素的常量迭代器，如果列表为空则返回结束迭代器

注意

该函数是常函数，不支持修改原始列表中的项。比较函数切勿使用直接引用 (T& item1, T& item2) -> bool。
在使用 lambda 表达式作为比较函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 定义一个比较函数，按照绝对值大小比较

bool CompareAbs(const int num1, const int& num2) {

return std::abs(num1) < std::abs(num2);

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> numbers = {1, -5, 3, -10, 2};

// 使用函数指针：获取绝对值最大的元素

auto max_iter = numbers.Max(CompareAbs); // max_iter 指向 -10

// 使用 Lambda 表达式：获取正数中绝对值最大的元素

auto max_pos_iter = numbers.Max([](int num1, int num2) { // 不使用引用时，参数类型可以不使用常量

return num2 > 0 && std::abs(num1) < std::abs(num2);

}); // max_pos_iter 指向 3

}

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 629 行定义.

◆ Min() [1/2]

template<typename T >

List< T >::const_iterator cm::List< T >::Min ( ) const

inline

求列表中的最小值

该方法用于获取列表中的最小元素。

返回: 指向最小元素的常量迭代器，如果列表为空则返回结束迭代器

注意: 要求列表项类型 T 已经重载了比较运算符（要求支持小于操作符 <），否则程序将产生运行错误。

示例: // 初始化列表

cm::List<int> list = {1, 8, 0, 2, -5 , 6, 121};

// 打印列表中的最小值

std::cout << *list.Min() << "\n"; // 输出：-5

// 初始化字符串列表

cm::List<std::string> str_list = {"hello", "world", "cpp"};

// 打印列表中的最小值以及其长度

cm::List<std::string>::const_iterator iter = str_list.Min();

std::cout << *iter << " " << iter->length() << "\n"; // 输出：cpp 3

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 673 行定义.

◆ Min() [2/2]

template<typename T >

template<typename FUNC >

List< T >::const_iterator cm::List< T >::Min ( const FUNC & func ) const

inline

求列表中的最小值

该方法用于获取列表中的最小元素，并根据传入的比较函数进行比较。

模板参数

FUNC	比较函数类型，接受两个列表项作为参数，返回`bool`值，形式为`(const T& item1, const T& item2) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	比较函数，返回 true 时更新第一个列表项参数`item1`作为最小值，反之不更新

返回: 指向最小元素的常量迭代器，如果列表为空则返回结束迭代器

注意

该函数是常函数，不支持修改原始列表中的项。比较函数切勿使用直接引用 (T& item1, T& item2) -> bool。
在使用 lambda 表达式作为比较函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 定义一个比较函数，按照绝对值大小比较

bool CompareAbs(const int num1, const int& num2) {

return std::abs(num1) < std::abs(num2);

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> numbers = {1, -5, 3, -10, 2};

// 使用函数指针：获取绝对值最小的元素

auto max_iter = numbers.Min(CompareAbs); // max_iter 指向 1

// 使用 Lambda 表达式：获取负数中绝对值最小的元素

auto max_neg_iter = numbers.Min([](int num1, int num2) { // 不使用引用时，参数类型可以不使用常量

return num1 < 0 && std::abs(num1) < std::abs(num2);

}); // max_neg_iter 指向 -5

}

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 730 行定义.

◆ MutFilter()

template<typename T >

template<typename FUNC >

List< T > cm::List< T >::MutFilter ( const FUNC & func )

inline

过滤列表项

该方法用于过滤列表中的项，根据传入的过滤函数判断是否保留该项，将符合条件的项添加到新的列表中并返回。

模板参数

FUNC	过滤函数类型，接受一个列表项参数，返回`bool`值，形式为`(T& item) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型。

参数

func	过滤函数，当返回`true`时保留该项，反之则过滤

返回: 过滤后的新列表

注意

与 Filter 函数不同的是， MutFilter 函数并不是常函数。当过滤函数中列表项参数为引用时，可以修改原始项的值。
在使用 lambda 表达式作为过滤函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 保留偶数，过滤奇数函数，同时将偶数的值乘以2，小于5奇数的值减少1，大于等于5的奇数增加2

void KeepEven(int& num) {

if(num % 2 == 0) {

num *= 2;

return true;

}

if(num < 5)

num -= 1;

else

num += 2;

return false;

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> nums = {1, 2, 3, 4, 5, 6, 7};

// 使用函数指针：保留偶数，过滤所有奇数，同时将偶数的值乘以2，小于5奇数的值减少1，大于等于5的奇数增加2

cm::List<int> new_nums = nums.MutFilter(KeepEven); // new_nums: [4, 8, 12] nums: [0, 4, 2, 8, 7, 12, 9]

// 使用 Lambda 表达式：保留奇数，过滤所有偶数

nums = nums.MutFilter([] (int num) { return num % 2 == 1; }); // nums: [7, 9]

}

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 427 行定义.

◆ MutMap()

template<typename T >

template<typename U , typename FUNC >

List< U > cm::List< T >::MutMap ( const FUNC & func )

inline

列表项映射

该方法用于对列表中的每个元素进行映射处理，根据传入的映射函数，返回映射后的新列表。

模板参数

U	映射值类型，支持编译器自行推导类型
FUNC	映射函数类型，接受列表项作为参数，返回映射后的值，形式为`(const T& item) -> U`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	映射函数，返回映射后的值

返回: 映射后的新列表

注意

与 Map 函数不同的是， MutMap 函数并不是常函数。当映射函数中列表项参数为引用时，可以修改原始项的值。
在使用 lambda 表达式作为映射函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 将字符串列表转换为长度列表，同时将字符串转换为大写形式

int GetLength(std::string& str) {

str = std::toupper(str);

return str.length();

}

// 测试函数

void Test() {

// 初始化列表

cm::List<std::string> words = {"hello", "world", "c++"};

// 使用函数指针：将字符串列表转换为长度列表

cm::List<int> lengths = words.MutMap<int>(GetLength); // lengths: [5, 5, 3] words: ["HELLO", "WORLD", "C++"]

// 使用 Lambda 表达式：获取第一个字符作为映射值

cm::List<char> chars = words.MutMap<char>([] (const std::string str) { return str.front(); }); // chars: ['H', 'W', 'C']

}

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 534 行定义.

◆ MutReduce()

template<typename T >

template<typename U , typename FUNC >

U cm::List< T >::MutReduce	(	const FUNC &	func,
		U	initial_value = U{} )

inline

累计列表项

该方法用于对列表中的所有元素进行累积处理，根据传入的累计函数和初始值，返回最终累积后的值。

模板参数

U	累计值类型，支持编译器自行推导类型
FUNC	累计函数类型，接受当前累计值和列表项作为参数，返回累计后的值，形式为`(U accumulator, T& item) -> U`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	累计函数
initial_value	累计初始值 `默认为 U{}`

返回: 累计后的值

注意

与 Reduce 函数不同的是， MutReduce 函数并不是常函数。当累计函数中列表项参数为引用时，可以修改原始项的值。
在使用 lambda 表达式作为累计函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 单步求和函数，同时将大于5的数向上取整

void Sum(double cur_sum, double& num) {

cur_sum += num;

if(num > 5)

num = std::ceil(num);

return cur_sum;

}

// 测试函数

void Test() {

// 初始化列表

cm::List<double> nums = {1.5, 2, 3.5, 4, 5.5, 6, 7.5};

// 使用函数指针：求和并将大于5的数向上取整，求和初始值设置为 0.0，默认是 double 类型

double sum = nums.MutReduce(Sum, 0.0); // sum: 30.0 nums: [1.5, 2, 3.5, 4, 6, 6, 8]

// 使用 Lambda 表达式：求向下取整数的和，设置默认初始值类型是 int 类型，求和初始值不设置，默认为 int{} = 0

nums = nums.MutReduce<int>([] (int cur_sum, double num) { return cur_sum + std::floor(num); }); // nums: 30

}

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 484 行定义.

◆ operator+=()

template<typename T >

List< T > & cm::List< T >::operator+= ( const List< T > & list )

inline

列表类重载加等于运算符

该方法用于重载列表的加等于运算符，实现列表的拼接功能。将另一个列表中的元素逐一添加到当前列表的末尾。

参数

list	另一个列表，将其内容添加到当前列表的末尾

返回: 拼接后的当前列表的引用，方便链式调用

示例: // 初始化三个列表

cm::List<int> list1 = {1, 2, 3, 4};

cm::List<int> list2 = {6, 7, 2};

cm::List<int> list3 = {3, 3, 8};

// 第三个列表拼接第一个列表

list3 += list1 // list3: [3, 3, 8, 1, 2, 3, 4]

// 第二个列表拼接第一个列表

list2 += list1; // list2: [6, 7, 2, 1, 2, 3, 4]

// 第三个列表拼接第二个列表

list3 += list2; // list3: [3, 3, 8, 1, 2, 3, 4, 6, 7, 2, 1, 2, 3, 4]

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 160 行定义.

◆ Order() [1/2]

template<typename T >

List< T >::iterator cm::List< T >::Order ( size_t index )

inline

按序获取列表中指定索引的元素

该方法实现按照大小进行排序，默认从小到大，然后找到列表中第index个元素（index从 0 开始）。

参数

index 要查找的元素索引，从 0 开始

返回: 指向第index个元素的迭代器（如果index超出范围，则返回结束迭代器）

注解: 该函数底层调用 std::nth_element 实现，因此算法的时间复杂度为 O(n)，其中 n 为列表的大小。

注意

要求列表项类型 T 已经重载了比较运算符（要求支持小于操作符 <），否则程序将产生运行错误。
无论源列表是否有序，该函数都可能会改变源列表中值的顺序，因此需要注意对有序列表的使用。
虽然该函数都可能会改变源列表中值的顺序，但可以保证所有在第 index 个位置之前的元素都不大于位于第 index 个位置的元素，而所有在它之后的元素都不小于它。

示例: // 创建一个整数列表

cm::List<int> my_list = { 5, 3, 9, 1, 7 };

// 按序获取第三个元素（索引为2），算法的时间复杂度为 O(n)

auto it = my_list.Order(2);

// 输出结果

std::cout << "第三个元素为: " << *it << std::endl;

// 输出：第三个元素为: 5

作者: dreamy-xay

日期: 2024-1-29

在文件 list.hpp 第 856 行定义.

◆ Order() [2/2]

template<typename T >

template<typename FUNC >

List< T >::iterator cm::List< T >::Order	(	size_t	index,
		const FUNC &	func )

inline

按序获取列表中指定索引的元素

该方法实现按照大小进行排序，默认从小到大，然后找到列表中第index个元素（index从 0 开始）。需要提供一个比较函数，根据其返回值确定是否交换两个元素的位置。

模板参数

FUNC	比较函数类型，接受两个列表项作为参数，返回`bool`值，形式为`(const T& item1, const T& item2) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

index	要查找的元素索引，从 0 开始
func	比较函数，返回 false 时交换两值位置，反之不交换

返回: 指向第index个元素的迭代器（如果index超出范围，则返回结束迭代器）

注解: 该函数底层调用 std::nth_element 实现，因此算法的时间复杂度为 O(n)，其中 n 为列表的大小。

注意

无论源列表是否有序，该函数都可能会改变源列表中值的顺序，因此需要注意对有序列表的使用。
虽然该函数都可能会改变源列表中值的顺序，但可以保证所有在第 index 个位置之前的元素都不大于位于第 index 个位置的元素，而所有在它之后的元素都不小于它。
在使用 lambda 表达式作为比较函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 定义一个比较函数，按照绝对值大小比较

bool CompareAbs(const int& num1, const int& num2) {

return std::abs(num1) > std::abs(num2);

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> numbers = {1, -5, 3, -10, 2, 6};

// 使用函数指针：获取绝对值从大到小排第三的元素

auto iter = numbers.Order(3, CompareAbs); // iter 指向 -5

// 使用 Lambda 表达式：获取绝对值从小到大排第5的元素

iter = numbers.Order(5, [](int num1, int num2) { // 不使用引用时，参数类型可以不使用常量

return num1 < num2;

}); // iter 指向 3

}

作者: dreamy-xay

日期: 2024-1-29

在文件 list.hpp 第 917 行定义.

◆ Reduce()

template<typename T >

template<typename U , typename FUNC >

U cm::List< T >::Reduce	(	const FUNC &	func,
		U	initial_value = U{} ) const

inline

累计列表项

该方法用于对列表中的所有元素进行累积处理，根据传入的累计函数和初始值，返回最终累积后的值。

模板参数

U	累计值类型，支持编译器自行推导类型
FUNC	累计函数类型，接受当前累计值和列表项作为参数，返回累计后的值，形式为`(U accumulator, const T& item) -> U`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	累计函数
initial_value	累计初始值 `默认为 U{}`

返回: 累计后的值

注意

该函数是常函数，不支持修改原始列表中的项。累计函数切勿使用直接引用 (U accumulator, T& item) -> U。如果想要修改原始列表中的项，请使用 MutReduce 函数。
在使用 lambda 表达式作为累计函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 单步求和函数

void Sum(double cur_sum, double num) { // 不使用引用时，参数类型可以不使用常量

return cur_sum + num;

}

// 测试函数

void Test() {

// 初始化列表

cm::List<double> nums = {1.5, 2, 3.5, 4, 5.5, 6, 7.5};

// 使用函数指针：求和，求和初始值设置为 0.0，默认是 double 类型

double sum = nums.Reduce(Sum, 0.0); // sum: 30.0

// 使用 Lambda 表达式：求向下取整数的和，设置默认初始值类型是 int 类型，求和初始值不设置，默认为 int{} = 0

nums = nums.Reduce<int>([] (int cur_sum, const double& num) { return cur_sum + std::floor(num); }); // nums: 28

}

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 322 行定义.

◆ Reverse()

template<typename T >

List< T > & cm::List< T >::Reverse ( )

inline

对列表中的元素进行反转

该方法用于将列表中的元素进行反转操作，如果列表是升序排列的，那么反转后将变成降序排列的。

返回: 类自身引用，方便链式调用

示例: // 初始化列表

cm::List<int> my_ist = {1, 2, 3, 4, 5};

// 反转列表

my_list.Reverse(); // my_list [5, 4, 3, 2, 1]

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 1305 行定义.

◆ Shuffle()

template<typename T >

List< T > & cm::List< T >::Shuffle ( )

inline

对列表中的元素进行随机打乱

该方法利用伪随机数生成算法对列表中的元素进行随机打乱。

返回: 类自身引用，方便链式调用

作者: justliulong

日期: 2023-12-08

在文件 list.hpp 第 1328 行定义.

◆ Slice()

template<typename T >

List< T > cm::List< T >::Slice	(	size_t	start,
		size_t	end = UINT_MAX ) const

inline

切片提取列表中指定范围的元素

该方法根据起始位置和结束位置从原列表中提取出一个新的列表，并返回该新列表。起始位置和结束位置都是以索引值表示，起始位置包含在切片内，结束位置不包含在切片内，默认结束位置为列表长度。

参数

start	起始位置
end	结束位置（不包括结束位置本身） `默认为 UINT_MAX，即列表长度`

返回: 提取的新列表

注意

该方法返回一个新的列表，原列表不会被修改。
要求列表项类型 T 已经重载了拷贝构造函数。

示例: // 创建一个整数列表

cm::List<int> my_list = { 1, 2, 3, 4, 5 };

// 提取索引为1到3的切片

cm::List<int> slice = my_list.Slice(1, 4); // slice: [2, 3, 4]

// 提取索引从2到结尾位置的切片

slice = my_list.Slice(2); // slice: [3, 4, 5]

作者: dreamy-xay

日期: 2024-01-13

在文件 list.hpp 第 1411 行定义.

◆ Sort() [1/2]

template<typename T >

List< T > & cm::List< T >::Sort ( )

inline

对列表进行排序

该方法使用 std::sort 对列表进行排序，默认使用 < 运算符进行比较，根据比较的结果确定是否交换两个元素的位置。

返回: 类自身引用，方便链式调用

注意: 要求列表项类型 T 已经重载了比较运算符（要求支持小于操作符 <），否则程序将产生运行错误。

示例: // 初始化列表数据

cm::List<int> numbers = {5, 2, 8, 1, 3};

// 对列表进行排序

numbers.Sort(); // numbers: [1, 2, 3, 5, 8]

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 767 行定义.

◆ Sort() [2/2]

template<typename T >

template<typename FUNC >

List< T > & cm::List< T >::Sort ( const FUNC & func )

inline

对列表进行排序

该方法利用 std::sort 对列表进行排序。需要提供一个比较函数，根据其返回值确定是否交换两个元素的位置。

模板参数

FUNC	比较函数类型，接受两个列表项作为参数，返回`bool`值，形式为`(const T& item1, const T& item2) -> bool`，支持函数指针、lambda 表达式、仿函数等，通常由编译器自行推导类型

参数

func	比较函数，返回 false 时交换两值位置，反之不交换

注解

自定义比较函数，建议保证比较函数的稳定性和可传递性，遵循严格弱序关系，即满足以下条件：

反对称性（Anti-symmetry）：如果对于所有的 x 和 y，当且仅当 x == y 时才有 compare(x, y) 和 compare(y, x) 的结果相同；
传递性（Transitivity）：如果对于所有的 x、y 和 z，当 compare(x, y) 和 compare(y, z) 的结果分别为 true 和 true 时，则 compare(x, z) 的结果也为 true；
稳定性（Stability）：如果对于所有的 x 和 y，当且仅当 x == y 时才有 compare(x, y) 的结果为 false，那么 compare 函数应该保持稳定，即对于列表中的相等元素保持原始顺序。

返回: 类自身引用，方便链式调用

注意: 在使用 lambda 表达式作为比较函数时，注意捕获变量的方式和生命周期，避免悬空引用或未定义行为。

示例: // 定义一个比较函数，按照绝对值大小比较

bool CompareAbs(const int& num1, const int& num2) {

return std::abs(num1) > std::abs(num2);

}

// 测试函数

void Test() {

// 初始化列表

cm::List<int> numbers = {1, -5, 3, -10, 2, 6};

// 使用函数指针：对列表进行排序

numbers.Sort(CompareAbs); // numbers: [-10, 6, -5, 3, 2, 1]

// 使用 Lambda 表达式：对列表进行排序

numbers.Sort([](int num1, int num2) { // 不使用引用时，参数类型可以不使用常量

return num1 < num2;

}); // numbers: [-10, -5, 1, 2, 3, 6]

}

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 817 行定义.

友元及相关函数文档

◆ operator+

template<typename T >

template<typename U >

List< U > operator+	(	const List< U > &	list1,
		const List< U > &	list2 )

friend

列表类重载加法运算符

该方法用于重载列表的加法运算符，实现两个列表的拼接功能。将两个列表中的元素合并到一个新的列表中，并返回新的列表。

模板参数

U	列表中存储的元素类型

参数

list1	第一个列表
list1	第二个列表

返回: 拼接后的新列表

示例: // 初始化两个列表

cm::List<int> list1 = {1, 2, 3, 4};

cm::List<int> list2 = {6, 7, 2};

// 拼接两个列表

cm::List<int> new_list1 = list1 + list2; // new_list1: [1, 2, 3, 4, 6, 7, 2]

cm::List<int> new_list2 = list2 + list1; // new_list2: [6, 7, 2, 1, 2, 3, 4]

作者: dreamy-xay

日期: 2023-12-08

在文件 list.hpp 第 192 行定义.

◆ operator<<

template<typename T >

template<typename U >

std::ostream & operator<<	(	std::ostream &	out,
		const List< U > &	list )

friend

列表类重载输出流运算符

该方法用于重载列表类的输出流运算符，以便将列表的内容输出到流中。格式为[element1, element2, ...]。

模板参数

U	列表中存储的元素类型，通常由编译器自行推导

参数

out	输出流
list	要输出的列表

返回: 输出流对象自身的引用，方便链式调用

作者: dreamy-xay

日期: 2023-12-04

在文件 list.hpp 第 215 行定义.

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

common/include/common/base/list.hpp

Public 成员函数

友元

详细描述

构造及析构函数说明

◆ List() [1/3]

◆ List() [2/3]

◆ List() [3/3]

◆ ~List()

成员函数说明

◆ Count() [1/2]

◆ Count() [2/2]

◆ Fill()

◆ Filter()

◆ Include() [1/2]

◆ Include() [2/2]

◆ Index() [1/2]

◆ Index() [2/2]

◆ LastIndex() [1/2]

◆ LastIndex() [2/2]

◆ Map()

◆ Max() [1/2]

◆ Max() [2/2]

◆ Min() [1/2]

◆ Min() [2/2]

◆ MutFilter()

◆ MutMap()

◆ MutReduce()

◆ operator+=()

◆ Order() [1/2]

◆ Order() [2/2]

◆ Reduce()

◆ Reverse()

◆ Shuffle()

◆ Slice()

◆ Sort() [1/2]

◆ Sort() [2/2]

友元及相关函数文档

◆ operator+

◆ operator<<