c++ - 值容器与智能指针容器的模板重载

Question

模板的新手，所以我认为代码片段最能说明我的问题。

#include <iostream>
#include <memory>
#include <string>
#include <algorithm>
#include <vector>
#include <type_traits>


template <typename TContainer, typename T>
bool contains(const TContainer& container, const T& t){
    auto begin = container.begin();
    auto end   = container.end();
    auto predicate = [&t](const auto& cT){
        return cT == t;
    };
    auto iter = std::find_if(begin, end, predicate);

    return iter != end;
}

struct Foo{
    int _value;
    Foo(int value) : _value{value} {}

    bool operator==(const Foo& other) const{
        return _value == other._value;
    }
};


int main(){
    using SmartFoo      = std::shared_ptr<Foo>;
    auto valueContainer = std::vector<Foo>{{1},{2},{3}};
    auto ptrContainer   = std::vector<SmartFoo>{{std::make_unique<Foo>(1)},
                                                {std::make_unique<Foo>(2)},
                                                {std::make_unique<Foo>(3)}};

    auto needle         = Foo(2);
    auto smartNeedle    = std::make_shared<Foo>(3);

    auto found          = contains(valueContainer, needle);
    auto smartFound     = contains(ptrContainer, smartNeedle);

    std::cout<<std::boolalpha;
    std::cout<<"Found by value?: " <<  found << "\n";
    std::cout<<"Found by smartptr?: " << smartFound << "\n";
    return 0;
}

本质上，我有一些包含智能指针的容器，还有一些包含值对象的容器，但在这两种情况下，我只对值对象本身感兴趣。上面的输出是

Found by value?: true
Found by smartptr?: false

这显然是因为 shared_ptr 的 operator== 检查地址而不是内容。

我正在努力实现一个谓词，如果 T 是一个智能指针，那么该谓词将对 T 进行推导，因此比较发生在值而不是地址上。理想情况下，我想将任一类型的容器传递给相同的 contains。两种选择都可能吗？如果是这样，怎么做到的？

Answer 1

你可以使用重载:

template <typename T>
bool cmp_value(const T& lhs, const T& rhs)
{
    return lhs == rhs;
}

template <typename T>
bool cmp_value(const std::shared_ptr<T>& lhs, const std::shared_ptr<T>& rhs)
{
    return *lhs == *rhs;
}

然后

template <typename TContainer, typename T>
bool contains(const TContainer& container, const T& t){
    auto begin = container.begin();
    auto end   = container.end();
    auto predicate = [&t](const auto& cT){
        return cmp_value(cT, t);
    };
    auto iter = std::find_if(begin, end, predicate);

    return iter != end;
}