如何让C++函数Foo支持接收任意指针类型（智能指针、迭代器等）？

针对你希望Foo函数接受任意类指针类型（智能指针、迭代器等），同时明确API意图的需求，有几种公认的实现方式，无需手动编写繁琐的包装类：

方法一：模板+静态断言（C++11及以上兼容） #

这种方式既保留模板的通用性，又通过编译期断言明确约束参数类型，利用标准库的std::pointer_traits统一提取各种指针类型的指向元素：

#include <memory>
#include <type_traits>

class MyType {
public:
    void some_method() {}
    void another_method() {}
};

template <typename PointerLike>
void Foo(PointerLike ptr) {
    // 提取指针类型指向的元素类型
    using ElementType = typename std::pointer_traits<PointerLike>::element_type;
    
    // 静态断言：确保指向的是MyType（如需支持派生类可改用std::is_base_of_v）
    static_assert(std::is_same_v<ElementType, MyType>,
                  "Foo requires a pointer-like type that points to MyType");

    // 内部使用类指针操作（operator-> / operator*）
    ptr->some_method();
    (*ptr).another_method();
}

// 调用示例
int main() {
    MyType mt;
    Foo(&mt); // 原生指针

    std::unique_ptr<MyType> uptr(new MyType);
    Foo(uptr); // unique_ptr

    std::shared_ptr<MyType> sptr = std::make_shared<MyType>();
    Foo(sptr); // shared_ptr
}

优点：

• 自动适配所有支持std::pointer_traits的类型，无需手动适配每种智能指针；
• 编译期给出明确错误提示，API意图清晰；
• 兼容C++11及以上版本。

方法二：C++20概念（Concepts）——最优雅的方案 #

C++20的概念可以直接在函数参数上定义类型约束，让API意图一目了然，同时编译器会生成更友好的错误提示：

#include <memory>
#include <concepts>

class MyType {
public:
    void some_method() {}
    void another_method() {}
};

// 定义概念：能指向MyType的类指针/迭代器类型
template <typename T>
concept MyTypePointerLike = requires(T ptr) {
    // 支持解引用得到MyType的引用
    { *ptr } -> std::convertible_to<MyType&>;
    // 支持箭头操作符访问MyType的成员
    { ptr->some_method() };
} && std::same_as<typename std::pointer_traits<T>::element_type, MyType>;

// 使用概念约束参数类型
void Foo(MyTypePointerLike auto ptr) {
    ptr->some_method();
    (*ptr).another_method();
}

// 调用示例同方法一

优点：

• API意图极其明确，调用者一眼就能知道需要传递什么类型的参数；
• 编译器错误提示比静态断言更直观；
• 代码更简洁，无需在函数内部写断言逻辑。

扩展：兼容迭代器类型 #

如果需要同时支持指向MyType元素的迭代器，可以扩展类型提取逻辑，结合std::iterator_traits处理迭代器：

#include <vector>
#include <iterator>

// 辅助模板：统一提取指针/迭代器的元素类型
template <typename T>
struct element_type {
    using type = typename std::pointer_traits<T>::element_type;
};

// 特化处理迭代器类型
template <typename Iter>
requires std::input_iterator<Iter>
struct element_type<Iter> {
    using type = typename std::iterator_traits<Iter>::value_type;
};

template <typename T>
using element_type_t = typename element_type<T>::type;

// 修改后的Foo函数
template <typename PointerOrIter>
void Foo(PointerOrIter ptr) {
    using ElementType = element_type_t<PointerOrIter>;
    static_assert(std::is_same_v<ElementType, MyType>,
                  "Foo requires a pointer-like type or iterator pointing to MyType");
    
    // 迭代器同样支持解引用，内部逻辑可复用
    (*ptr).some_method();
}

// 迭代器调用示例
int main() {
    std::vector<MyType> vec{MyType{}, MyType{}};
    Foo(vec.begin()); // 支持vector迭代器
}

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