C++模板返回类型复用问题：如何摆脱固定返回类型限制

思路：把数组遍历逻辑抽成通用模板，用回调决定返回值 #

你可以把原来只返回长度的模板，改成一个通用遍历/操作模板，让它接受一个自定义的回调函数（或lambda），回调负责处理每个元素并返回最终结果。这样同一个模板就能适配不同的返回类型——不管是size_t还是bool，甚至其他类型都能支持，完全不用std::any。

代码示例 #

1. 通用数组操作模板 #

这个模板负责遍历只读数组，把元素传递给回调，最终返回回调的结果：

#include <cctype>
#include <string_view>
#include <array>

// 通用只读数组操作模板：支持原生数组
template <typename T, size_t N, typename Func>
constexpr auto ArrayOperation(const T (&arr)[N], Func&& func) {
    return func(arr, N);
}

// 针对std::array的重载（可选，支持标准容器）
template <typename T, size_t N, typename Func>
constexpr auto ArrayOperation(const std::array<T, N>& arr, Func&& func) {
    return func(arr.data(), N);
}

2. 复用模板实现原有的长度获取函数 #

// 获取数组长度：复用通用模板，回调直接返回size_t
template <typename T, size_t N>
constexpr size_t GetArrayLength(const T (&arr)[N]) {
    return ArrayOperation(arr, [](const auto*, size_t len) { return len; });
}

// std::array版本
template <typename T, size_t N>
constexpr size_t GetArrayLength(const std::array<T, N>& arr) {
    return ArrayOperation(arr, [](const auto*, size_t len) { return len; });
}

3. 复用模板实现ContainsNullOrWhitespace函数 #

针对字符串类型的数组，判断是否存在空指针、空字符串或全空白字符串：

// 判断数组中是否包含空/空白字符串
template <typename StringT, size_t N>
constexpr bool ContainsNullOrWhitespace(const StringT (&arr)[N]) {
    return ArrayOperation(arr, [](const auto* arr_ptr, size_t len) {
        for (size_t i = 0; i < len; ++i) {
            // 处理const char*类型的空指针
            if constexpr (std::is_same_v<StringT, const char*>) {
                if (!arr_ptr[i]) return true;
                const std::string_view sv(arr_ptr[i]);
                if (sv.empty()) return true;
                // 检查是否全是空白字符
                bool all_whitespace = true;
                for (char c : sv) {
                    if (!std::isspace(static_cast<unsigned char>(c))) {
                        all_whitespace = false;
                        break;
                    }
                }
                if (all_whitespace) return true;
            }
            // 处理std::string/std::string_view类型
            else if constexpr (std::is_convertible_v<StringT, std::string_view>) {
                const std::string_view sv(arr_ptr[i]);
                if (sv.empty()) return true;
                bool all_whitespace = true;
                for (char c : sv) {
                    if (!std::isspace(static_cast<unsigned char>(c))) {
                        all_whitespace = false;
                        break;
                    }
                }
                if (all_whitespace) return true;
            }
            // 其他类型可自行扩展判断逻辑
        }
        return false;
    });
}

另一种思路：模板参数指定返回类型（更直接） #

如果不想用回调，也可以给模板加一个返回类型参数，默认是size_t，既兼容原有逻辑，又能自定义返回类型：

// 带返回类型参数的模板，默认返回size_t
template <typename Ret = size_t, typename T, size_t N>
constexpr Ret ArrayOperation(const T (&arr)[N]) {
    if constexpr (std::is_same_v<Ret, size_t>) {
        return N;
    } else if constexpr (std::is_same_v<Ret, bool>) {
        // 这里写ContainsNullOrWhitespace的逻辑
        for (const auto& elem : arr) {
            // 省略具体判断逻辑，和上面一致
        }
        return false;
    }
    // 其他返回类型可继续扩展
}

// 使用示例：
const char* strs[] = {"hello", "   ", nullptr, "world"};
size_t len = ArrayOperation(strs); // 默认返回size_t，获取长度
bool has_blank = ArrayOperation<bool>(strs); // 指定返回bool，判断是否有空/空白

不过这种方式扩展性不如回调——回调能支持任意复杂的逻辑和返回类型，而模板分支判断需要提前枚举类型。

注意事项 #

• 用constexpr修饰模板，让函数在编译期就能计算结果，提升性能。
• 用std::string_view处理字符串类型，避免不必要的内存拷贝。
• 针对不同元素类型，用if constexpr做编译期分支判断，保证类型安全。

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