如何为C++模板函数参数添加类型契约检查？

当然有办法实现这种类型契约编程的需求！针对你的场景，我们可以根据不同的C++版本选择更合适的方案，下面详细说明：

C++20及以后：用Concepts实现直观的类型约束 #

C++20引入的Concepts是专门为这类类型契约场景设计的，语法清晰且可读性强，能直接在模板参数上声明约束：

#include <concepts>
#include <utility> // 用于std::swap

// 定义Indexable概念：要求容器支持下标访问、size()方法，且下标返回元素的引用
template<typename Cont>
concept Indexable = requires(Cont& cont, std::size_t idx) {
    { cont[idx] } -> std::same_as<typename Cont::value_type&>;
    { cont.size() } -> std::convertible_to<std::size_t>;
};

// 定义Comparable概念：要求元素支持<比较（可根据需求扩展其他运算符）
template<typename T>
concept Comparable = requires(const T& a, const T& b) {
    { a < b } -> std::convertible_to<bool>;
};

// 带约束的排序函数
template<Indexable Cont>
    requires Comparable<typename Cont::value_type>
void my_sort(Cont& cont) {
    // 这里实现排序逻辑，比如简单的冒泡排序示例
    const std::size_t n = cont.size();
    for (std::size_t i = 0; i < n; ++i) {
        for (std::size_t j = 0; j < n - i - 1; ++j) {
            if (cont[j] > cont[j+1]) {
                std::swap(cont[j], cont[j+1]);
            }
        }
    }
}

当你调用my_sort(std::vector<int>{1,6,5,4})时，因为std::vector满足Indexable且元素int满足Comparable，所以编译正常；而调用my_sort(linkedlist<int>{1,6,5,4})时，由于linkedlist没有operator[]，编译器会直接抛出清晰的错误，提示违反了Indexable概念的约束。

C11/C14/C++17：用SFINAE和类型特性实现编译期检查 #

如果你还在使用C++11，可以借助**SFINAE（Substitution Failure Is Not An Error）**机制结合自定义类型特性（type traits）来实现编译期约束：

#include <type_traits>
#include <utility>

// 检查容器是否是Indexable的类型特性
template<typename Cont, typename = void>
struct is_indexable : std::false_type {};

template<typename Cont>
struct is_indexable<Cont, typename std::enable_if<
    // 检查operator[]是否存在且返回value_type的引用
    std::is_same<decltype(std::declval<Cont&>()[std::declval<std::size_t>()]), typename Cont::value_type&>::value &&
    // 检查size()是否存在且返回可转换为std::size_t的类型
    std::is_convertible<decltype(std::declval<Cont&>().size()), std::size_t>::value
>::type> : std::true_type {};

// 检查元素是否可比较的类型特性（以<运算符为例）
template<typename T, typename = void>
struct is_comparable : std::false_type {};

template<typename T>
struct is_comparable<T, typename std::enable_if<
    std::is_convertible<decltype(std::declval<const T&>() < std::declval<const T&>()), bool>::value
>::type> : std::true_type {};

// 带约束的排序函数：只有当容器满足Indexable且元素满足Comparable时才会被选中
template<typename Cont>
typename std::enable_if<
    is_indexable<Cont>::value && is_comparable<typename Cont::value_type>::value,
    void
>::type my_sort(Cont& cont) {
    const std::size_t n = cont.size();
    for (std::size_t i = 0; i < n; ++i) {
        for (std::size_t j = 0; j < n - i - 1; ++j) {
            if (cont[j] > cont[j+1]) {
                std::swap(cont[j], cont[j+1]);
            }
        }
    }
}

在这个方案中，当传入不满足约束的容器（比如你的linkedlist）时，编译器会因为找不到匹配的my_sort重载而报错，达到编译期检查的目的。如果是C++17，还可以用std::void_t简化类型特性的写法，让代码更简洁。

需要注意的是，以上方案都是编译期检查，比运行时检查更高效且能更早发现问题，完全符合你的需求。

内容的提问来源于stack exchange，提问作者pambda