C++ type list 模板

C++ 实现一个type list 模板，在编译期计算。这个type list主要有构造，列表头类型，列表尾类型，concat操作，去除列表元素重复，获取指定元素，删除指定元素的操作。实现代码贴在下面：

#pragma once
#include <iostream>
#include <typeinfo>


namespace type_list {
	// Step 1: 基础类型列表定义
	// 定义空列表
	template <typename ...Types>
	struct list {};

	// 非空列表的递归定义
	template <typename Type, typename ...Types>
	struct list<Type, Types...> {
		using head = Type;
		using tail = list<Types...>;
	};

	// 定义空列表类型
	using empty_list = list<>;

	// Step 2: 获取列表头部类型
	template <typename TypeList>
	using head_t = typename TypeList::head;

	// 获取列表尾部类型
	template <typename TypeList>
	using tail_t = typename TypeList::tail;

	// 构造新列表
	template <typename Head, typename Tail>
	struct construct;

	template <typename Head, typename Tail>
	using construct_t = typename construct<Head, Tail>::type;

	template <typename Head, typename ...Types>
	struct construct<Head, list<Types...>> {
		using type = list<Head, Types...>;
	};

	///

	template<typename TypeList>
	struct size;

	// 模板辅助类
	template<typename TypeList>
	constexpr size_t size_v = size<TypeList>::value;

	//size的模板特化，继承了std::integral_constant
	template<typename...Types>
	struct size<list<Types...>> : std::integral_constant<std::size_t, sizeof...(Types)> {};

	

	template<class TypeList>
	constexpr bool empty_v = (size_v<TypeList> == 0);

	template<class TypeList>
	struct empty : std::bool_constant<empty_v<TypeList>> {};

	template<class TypeList>
	constexpr bool empty_s = empty<TypeList>::value;

	/


	// 查找模板的制定索引的value
	//声明一个模板;
	template<std::size_t Index, class TypeList>
	struct get;

	template<std::size_t Index, class TypeList>
	using get_t = typename get<Index, TypeList>::type;

	template<std::size_t Index, class TypeList>
	struct get {
		using type = get_t<Index - 1, tail_t<TypeList>>;
	};

	template<class TypeList>
	struct get<0, TypeList> {
		using type = head_t<TypeList>;
	};

	/
	// concat
	template<typename TypeList1, typename TypeList2>
	class concat;

	template<typename T, typename U>
	using concat_t = typename concat<T, U>::type;

	template<typename ...T, typename ...U>
	class concat<list<T...>, list<U...>> {
	public:
		using type = list<T..., U...>;
	};

	
	// delete specific type

	template<typename TypeList, typename Type>
	class remove_all;

	template<typename TypeList, typename Type>
	using remove_all_t = typename remove_all<TypeList, Type>::type;


	template<typename TypeList, typename Type>
	class remove_all {
	public:
		using head = head_t<TypeList>;
		using tail = tail_t<TypeList>;
		using clean_tail = remove_all_t<tail, Type>;
		using type = std::conditional_t<std::is_same_v<head, Type>, clean_tail, construct_t<head, clean_tail>>;
	};

	template<typename Type>
	class remove_all<empty_list, Type> {
	public:
		using type = empty_list;
	};

	
	// get the last type
	template<typename TypeList>
	class last;

	template<typename TypeList>
	using last_t = typename last<TypeList>::type;

	template<typename TypeList>
	class last {
	public:
		using type = last_t<tail_t<TypeList>>;
	};

	// 递归终止
	template<typename Type>
	class last<list<Type>> {
	public:
		using type = Type;
	};

	
	// distinct list type
	template<typename TypeList>
	class distinct;

	template<typename TypeList>
	using distinct_t = typename distinct<TypeList>::type;

	template <typename TypeList>
	class distinct{
	public:
		using type = construct_t<
			head_t<TypeList>,
			distinct_t<
			remove_all_t<tail_t<TypeList>, head_t<TypeList>>>>;
	};

	// 递归终止
	template <>
	struct distinct<empty_list> {
		using type = empty_list;
	};

	
	// print list
	template<typename T>
	void print_type() {
		int status;
		std::cout << typeid(T).name() << std::endl;
	}

	// 打印类型列表
	template <typename TypeList>
	struct print_list;

	template <typename TypeList>
	void print_list_func() {
		print_list<TypeList>::print();
	}

	// 主模板，递归地打印类型列表
	template <typename TypeList>
	struct print_list {
		static void print() {
			print_type<head_t<TypeList>>();
			print_list_func<tail_t<TypeList>>();
		}
	};

	// 终止递归的特化版本
	template <>
	struct print_list<empty_list> {
		static void print() {
			// 空列表，不打印任何内容
		}
	};
	

} // namespace type_list

测试代码

#pragma once

#include "type_list.h"
#include <iostream>

using namespace std;


void test_type_list() {

	//1.define list
	using MyList = type_list::list<int, double, char>;
	using AnotherList = type_list::list<float, int>;

	using EmptyList = type_list::list<>;

	//2. get the head and tail type of list
	using MyListHead = type_list::head_t<MyList>;
	using MyListTail = type_list::tail_t<MyList>;
	static_assert(std::is_same_v<MyList::tail, type_list::list<double,char>>, "MyList head shoud be int");
	static_assert(std::is_same_v<MyListTail, type_list::list<double, char>>, "MyList head shoud be int");
	static_assert(std::is_same_v<MyListHead, int>, "MyList head shoud be int");
	static_assert(std::is_same_v<MyList::head, int>, "MyList head shoud be int");


	//3. get list size
	constexpr std::size_t listSize = type_list::size_v<MyList>;
	std::cout << listSize << std::endl;

	// 4. empty
	static_assert(type_list::empty_s<EmptyList>, "is empty");
	static_assert(type_list::empty_v<EmptyList>, "is empty");


	// 5. get index pos
	using FirstType = type_list::get_t<1, MyList>;
	static_assert(std::is_same_v<FirstType, double>, "not equal");

	// 6.concat list
	using ConcatList = type_list::concat_t<MyList, AnotherList>;
	using ConcatListHead = type_list::head_t<ConcatList>;
	static_assert(std::is_same_v<ConcatListHead, int>, "head should be int");
	static_assert(std::is_same_v<ConcatList::head, int>, "head should be int");

	constexpr std::size_t concat_list_size = type_list::size_v<ConcatList>;
	cout << "concat_list_size : " << concat_list_size << endl;

	// 6.delete list type
	using RemoveIntList = type_list::remove_all<MyList, int>;
	static_assert(std::is_same_v<type_list::head_t<RemoveIntList>, int>, "the list head shoud not be int");

	// 6.delete list type
	using LastType = type_list::last_t<MyList>;

	static_assert(std::is_same_v<LastType, char>, "the last type should be char");

	// distinct list type
	using RepeatList = type_list::list<int, double, char, int, double, char, int,int,int>;
	using DistType = type_list::distinct_t<RepeatList>;

	std::cout << "--------------------------" << endl;
	type_list::print_list_func<RepeatList>();
	std::cout << "--------------------------" << endl;
	type_list::print_list_func<DistType>();
	std::cout << "--------------------------" << endl;

}