Лучший способ написать значение обертку класс

Question

Supose мне нужно написать класс, который действует как оболочка для значений:

template<typename T> 
struct value_wrapper 
{ 
    T value; 

    value_wrapper(const T& v) : value(v) {} 

    //etc... 
}; 

Класс dessigned будет использоваться в качестве псевдонима от исходного значения, так что если это значение было rvalue, обертка содержит значение, а если это значение lvalue, то обертка содержит ссылку на него. Класс должен перегружать, скажем, операторы сравнения и использовать таким образом:

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

Или это:

int main() 
{ 
    int a , b; 
    bool flag = wrapper(a) == wrapper(b) || wrapper(a) == wrapper(2); 
} 

Мой вопрос: Что лучший (эффективный) способ реализации такая вещь? Это вопросы, кажется широким, я имею в виду:

• Как определить элемент value? Как T& для lvalues ​​и T для rvalues?
• Есть ли стандартный способ создания такого универсального (rvalue и lvalue) псевдонима?

Answer 1

Я думаю, что Kerrek SB находится на правильном пути, предоставляя специализацию (получил мой +1 давно), поэтому каждый случай обрабатывается наиболее эффективно.

Проблема заключается в том, что вы не можете просто добавлять неявные операторы преобразования, и если вы хотите предоставить свои собственные перегрузки оператора, все может стать довольно сложным.

Решение, с которым я столкнулся, пытается справиться с этим, помещая информацию о том, какая случайная переменная находится в логическом параметре шаблона.Вот основные рамки для value_wrapper класса:

template< typename T, bool > 
class value_wrapper 
{ 
private: 
    T t_; // store a value 

public: 
    explicit value_wrapper(T&& t) : t_(std::move(t)) {} 
    const T& cref() const { return t_; } 
}; 

template< typename T > 
struct value_wrapper< T, true > // specialization for lvalue references 
{ 
private: 
    const T& t_; // store a reference 

public: 
    explicit value_wrapper(const T& t) : t_(t) {} 
    const T& cref() const { return t_; } 
}; 

Хитрости это удобный метод, чтобы обернуть значение:

// needs a better name and needs to be moved into a "detail" or "impl" namespace 
template< typename T > 
using helper = value_wrapper< typename std::decay<T>::type, 
           std::is_lvalue_reference<T>::value >; 

template< typename T > 
helper<T> wrap(T&& t) 
{ 
    return helper<T>(std::forward<T>(t)); 
} 

Таким образом value_wrapper «первый параметр шаблона всегда гнилой типа, теперь все упрощается:

template< typename T, bool BL, bool BR > 
bool operator==(const value_wrapper< T, BL >& lhs, const value_wrapper< T, BR >& rhs) 
{ 
    return lhs.cref() == rhs.cref(); 
} 

(очевидно, вы хотите реализовать их по-разному, но вы всегда можете получить доступ к s tored значения через cref() единообразно)

Live example

Вы, возможно, потребуется изменить это, если вам нужно непостоянный доступ, и т.д., но я надеюсь, что выше поможет вам начать работу. Если вам нужна дополнительная помощь/идеи, не стесняйтесь спрашивать :)

Answer 2

я бы просто обеспечить подходящие операторы преобразования:

#include <utility> 
#include <type_traits> 

template <typename T> struct Wrapper 
{ 
    static_assert(!std::is_reference<T>::value, "Do not use a reference type"); 

    using type = T; 

    T value; 
    Wrapper(T && t) : value(std::move(t)) {} 
    Wrapper(T const & t) : value(t) {} 

    operator T const &() const noexcept { return value; } 
    operator T  &()  & noexcept { return value; } 
    operator T  &&() && noexcept { return std::move(value); } 

    // maybe some more CV variants... 
}; 

template <typename U> struct Wrapper<U &> 
{ 
    using type = U &; 

    U & ref; 
    Wrapper(U & u) : ref(u) {} 

    operator U &() { return ref; } 
}; 

Я бы сопровождать это с помощью функции выведения: использование

template <typename T> Wrapper<T> wrap(T && t) 
{ return Wrapper<T>(std::forward<T>(t)); } 

Пример:

int n = 10; 
bool b = wrap(n) == wrap(5 + 5) 

Конверсия операторы позволяют использовать любые операторы ed на базовом типе.