如何将C++模板函数与自由函数合并？探寻更优雅实现方式

一、能否将模板函数与自由函数合并为单个函数？ #

你给出的合并写法不可行，原因如下：

1. 语法错误：C++不允许同时声明模板函数和带默认参数的普通函数并共享同一函数体，这种写法不符合函数声明的语法规则。
2. 依赖无效：默认参数&driveable->speed中的模板参数driveable只有在模板实例化时才会确定类型，但默认参数的求值检查是在函数声明阶段进行的，此时driveable的类型尚未明确，编译器无法解析该表达式。

原有的重载写法是符合C++语法的，模板函数负责接收拥有speed成员的对象指针，再转发给接收float*的自由函数，这种分离逻辑是合理的。

二、更优雅的实现方式 #

方式1：简化模板函数，去掉单独的自由函数 #

直接在模板函数中访问speed成员，无需额外转发，代码更简洁：

#include <stdio.h>

struct car { float speed; };
struct bike { float speed; };

template<typename T>
void drive(T* driveable) {
    printf("driving at speed %f\n", driveable->speed);
}

int main() {
    car car = { .speed = 10.f };
    bike bike = { .speed = 20.f };
    drive(&car);
    drive(&bike);
}

如果需要同时支持对象引用和指针，可再重载一个模板：

template<typename T>
void drive(const T& driveable) {
    printf("driving at speed %f\n", driveable.speed);
}

template<typename T>
void drive(T* driveable) {
    drive(*driveable); // 转发到引用版本
}

方式2：用C++20 Concepts做类型约束（推荐） #

如果使用C++20及以上版本，可通过**概念（Concepts）**明确约束只有拥有float类型speed成员的类型才能调用drive函数，避免传入非法类型导致模糊的编译错误：

#include <stdio.h>
#include <concepts>

// 定义概念：拥有float类型的speed成员
template<typename T>
concept HasFloatSpeed = requires(T t) {
    { t.speed } -> std::convertible_to<float>;
};

struct car { float speed; };
struct bike { float speed; };

// 仅对满足HasFloatSpeed的类型实例化
template<HasFloatSpeed T>
void drive(const T& driveable) {
    printf("driving at speed %f\n", driveable.speed);
}

// 支持指针类型
template<HasFloatSpeed T>
void drive(T* driveable) {
    drive(*driveable);
}

int main() {
    car car{.speed = 10.f};
    bike bike{.speed = 20.f};
    drive(&car);
    drive(&bike);
    drive(car); // 也支持直接传入对象
}

方式3：C++11/14的SFINAE类型检查 #

如果需要兼容C11或C14，可使用SFINAE技术实现类似的类型约束：

#include <stdio.h>
#include <type_traits>

struct car { float speed; };
struct bike { float speed; };

// 辅助模板：检测类型是否拥有float类型的speed成员
template<typename T, typename = void>
struct HasFloatSpeed : std::false_type {};

template<typename T>
struct HasFloatSpeed<T, std::void_t<decltype(std::declval<T>().speed)>> :
    std::is_same<decltype(std::declval<T>().speed), float> {};

// 仅对满足条件的类型启用函数
template<typename T>
typename std::enable_if<HasFloatSpeed<T>::value>::type
drive(const T& driveable) {
    printf("driving at speed %f\n", driveable.speed);
}

template<typename T>
typename std::enable_if<HasFloatSpeed<typename std::remove_pointer<T>::type>::value>::type
drive(T* driveable) {
    drive(*driveable);
}

int main() {
    car car{.speed = 10.f};
    bike bike{.speed = 20.f};
    drive(&car);
    drive(&bike);
}

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