원시 포인터와 스마트 포인터를 모두 허용하는 C++ 펑터를 작성할 수 있습니까? 주어진 다음의

Question

는 :

struct Foo 
{ 
    int bar() const; 
}; 

struct IsEqual : public std::unary_function<Foo*, bool> 
{ 
    int val; 
    IsEqual(int v) : val(v) {} 

    bool operator()(const Foo* elem) const 
    { 
     return elem->bar() == val; 
    } 
}; 

나는 Foo*의 컨테이너를하고 난 컨테이너의 모든 요소가 있는지 확인하기 위해 std::find_if 및 std::not1를 사용하는 경우 주어진 값과 다른 bar() 반환 뭔가. 이번에는 std::tr1::shared_ptr<Foo>을 포함, 미래로

// Are all elements equal to '2'? 
bool isAllEqual(const std::vector<Foo*> &vec) 
{ 
    return find_if(vec.begin(), vec.end(), std::not1(IsEqual(2))) == vec.end(); 
} 

빨리 감기와 지금은 다른 용기를 가지고 : 코드는 다음과 같습니다. isAllEqual()의 오버로드 된 버전에서 필자의 펑터를 간단히 다시 사용하고 싶습니다. 그러나 나는 할 수 없다. Foo* 및 shared_ptr<Foo>은 다른 유형입니다. 그리고 unary_function에서 상속해야하므로 not1을 사용할 수 있습니다. 같은 펑터를 두 번 쓰는 것을 피할 수 있다면 더 우아 할 것입니다.

질문 :

• IsEqual는 그래서 모두 원시와 스마트 포인터를 사용하여 쓸 수있는 방법이 있나요?
• std::not1을 사용하여 수갑을 채웠습니까? 대신 IsNotEqual을 작성해야합니까?

제한 :

1. 내가 부스트 라이브러리에서 아무것도를 사용할 수 없습니다.
2. 우리의 컴파일러는 C++ 0x lambdas를 지원할 정도로 멋지지 않습니다.

Answer 1

// --*-- C++ --*-- 

#include <vector> 
#include <algorithm> 
#include <iostream> 

// Template unary function example. 
template <typename T> 
struct IsEqual : public std::unary_function<T, bool> 
{ 
    int v; 

    IsEqual (int v) : v (v) {} 

    bool operator() (const T & elem) const 
    { 
     return elem ? elem->bar() == v : false; 
    } 
}; 

// Generic algorithm implementation example... 
template <typename T1, typename T2> 
bool isAllEqual (const T1 & c, T2 v) 
{ 
    return find_if (
     c.begin(), c.end(), 
     std::not1 (IsEqual <typename T1::value_type> (v))) == c.end(); 
} 

// Some arbitrary pointer wrapper implementation, 
// provided just for an example, not to include any 
// specific smart pointer implementation. 
template <typename T> 
class WrappedPtr 
{ 
    const T *v; 

public: 
    typedef void (WrappedPtr<T>::*unspecified_boolean_type)() const; 

    WrappedPtr (const T *v) : v (v) {} 

    const T *operator ->() const { return v; } 

    operator unspecified_boolean_type() const 
    { 
     return v != NULL ? 
      &WrappedPtr<T>::unspecified_boolean_true : NULL; 
    } 

private: 
    void unspecified_boolean_true() const {} 
}; 

// Example of structure that could be used with our algorithm. 
struct Foo 
{ 
    int v; 

    Foo (int v) : v (v) {} 

    int bar() const 
    { 
     return v; 
    } 
}; 

// Usage examples... 
int main() 
{ 
    Foo f1 (2), f2 (2); 

    // Example of using raw pointers... 
    { 
     std::vector<Foo *> vec; 
     vec.push_back (NULL); 
     vec.push_back (&f1); 
     vec.push_back (&f2); 

     if (isAllEqual (vec, 2)) 
      std::cout << "All equal to 2" << std::endl; 
     else 
      std::cout << "Not all equal to 2" << std::endl; 
    } 

    // Example of using smart pointers... 
    { 
     std::vector< WrappedPtr<Foo> > vec; 
     vec.push_back (NULL); 
     vec.push_back (&f1); 
     vec.push_back (&f2); 

     if (isAllEqual (vec, 2)) 
      std::cout << "All equal to 2" << std::endl; 
     else 
      std::cout << "Not all equal to 2" << std::endl; 
    } 
} 

Answer 2

내 샷은 다음과 같이 될 것이다 :

template<typename PtrToFoo> 
struct IsEqual : public std::unary_function<PtrToFoo, bool> 
{ 
    int val; 
    IsEqual(int v) : val(v) {} 

    bool operator()(PtrToFoo elem) const 
    { 
     return elem->bar() == val; 
    } 
}; 

당신은 ->와 dereferencable 모든 것을, 그래서 원시 포인터와 스마트 포인터에 대해 다른 operator() 인스턴스화를해야합니다.

template<typename T> 
struct IsEqual : public std::unary_function<const T&, bool> 
{ 
    int val; 
    IsEqual(int v) : val(v) {} 

    bool operator()(const T& elem) const 
    { 
     return elem->bar() == val; 
    } 
}; 

template<typename T> 
IsEqual<T> DeduceEqualityComparer(int v, T) { return IsEqual<T>(v); } 

// Are all elements equal to '2'? 
template<typename TContainer> 
bool isAllEqual(const TContainer& coll) 
{ 
    using std::begin; // in C++0x, or else write this really simple function yourself 
    using std::end; 
    if (begin(coll) == end(coll)) return true; 
    return find_if(begin(coll), end(coll), std::not1(DeduceEqualityComparer(2, *begin(coll)))) == end(coll); 
} 

Answer 3

class IsEqualArg { 
public: 
    // Implicit conversion constructors! 
    IsEqualArg(Foo* foo) : ptr(foo) {} 
    IsEqualArg(const std::tr1::shared_ptr<Foo>& foo) : ptr(&*foo) {} 
private: 
    Foo* ptr; 
    friend struct IsEqual; 
}; 

struct IsEqualArg : public std::unary_function<IsEqualArg, bool> { 
    bool operator()(const IsEqualArg& arg) const; 
    //... 
}; 

하지만 난 정말이 아니라 단지 IsNotEqual 쓰기 것입니다.

Answer 4

당신은 어쩌면 암시 적 변환과 까다로운 뭔가를 할 수 :에 대해 어떻게

Answer 5

벤의 대답은 정말로 C++ 03에서 할 수있는 유일한 것입니다. C++ 0x 및/또는 boost :: bind에서는 unary_function으로부터 상속 할 필요가 없습니다. 이렇게하면 templated() 연산자를 사용할 수 있습니다. 대개 C++ 03에서 같은 것을 사용할 수는 있지만 기술적으로 올바르지 않다고 생각합니다.