2つの異なるバージョンの矢印演算子がありますか？

Question

Iは、オブジェクトをロックするための次のクラスがあります。私は次のようにロックし、共有オブジェクトへのアクセスのロックを解除するためにそれを使用したい

#include <memory> 

template <class Type, class Mutex> 
class LockableObject { 
public: 
    class UnlockedObject { 
    public: 
    UnlockedObject(Mutex &mutex, Type &object) 
     : mutex_(mutex), object_(object) {} 
    UnlockedObject(UnlockedObject &&other) = default; 

    // No copying allowed 
    UnlockedObject(const UnlockedObject &) = delete; 
    UnlockedObject &operator=(const UnlockedObject &) = delete; 

    ~UnlockedObject() { mutex_.unlock(); } 

    Type *operator->() { return &object_; } // Version 1 
    // Type &operator->() { return object_; } // Version 2 


    private: 
    Mutex &mutex_; 
    Type &object_; 
    }; 

    template <typename... Args> 
    LockableObject(Args &&... args) : object_(std::forward<Args>(args)...) {} 

    UnlockedObject Lock() { 
    mutex_.lock(); 
    return UnlockedObject(mutex_, object_); 
    } 

private: 
    Mutex mutex_; 
    Type object_; 
}; 

を。第二の例は、自分自身を適用する->事業者の能力を複数回を使用しています：

// Example 1 
    { 
    LockableObject<std::string, std::mutex> locked_string; 
    auto unlocked_string = locked_string.Lock(); 
    // This is what I want: 
    unlocked_string->size(); // works for version 1, breaks for version 2 
    } 

    // Example 2 
    { 
    LockableObject<std::unique_ptr<std::string>, std::mutex> locked_string(std::unique_ptr<std::string>(new std::string())); 
    auto unlocked_string = locked_string.Lock(); 
    // This is what I want: 
    unlocked_string->size(); // works for version 2, breaks for Version 1 

    // Workaround 
    unlocked_string->get()->size(); // works for version 1, but is not nice 
    } 

クラスは何とか両方の例は、->get()と回避策の代わりにunlocked_string->size()を使っ持つように変更することができますか？おそらく、テンプレートの特殊化などを使用してですか？

Answer 1

ヒントと回答ありがとうございます。 `LockablePtr`タイプを考えてみましょう

template <class CopyType = Type> 
typename std::enable_if<!has_arrow<CopyType>::value, CopyType *>::type 
operator->() { return &object_; } // Version 1 

template <class CopyType = Type> 
typename std::enable_if<has_arrow<CopyType>::value, CopyType &>::type 
operator->() { return object_; } // Version 2 

Answer 2

書き込みLockablePtrとLockableValueタイプです。

LockableObjectは、渡された型に基づいて上記のいずれかを条件付きで選択します。スマートポインタを何らかの種類のSFINAEまたは特質やsomesuchを使用して検出します。

この選択肢は、usingエイリアス、またはusingの継承を介して親コンストラクタを得ることができます。

namespace details { 
    template<template<class...>class, class, class...> 
    struct can_apply : std::false_type {}; 
    template<class...>struct voider{using type=void;}; 
    template<class...Ts>using void_t=typename voider<Ts...>::type; 
    template<template<class...>class Z, class...Ts> 
    struct can_apply<Z, void_t<Z<Ts...>>, Ts...> : std::true_type {}; 
} 
template<template<class...>class Z, class...Ts> 
using can_apply = details::can_apply<Z, void, Ts...>; 

template<class T> 
using star_r = decltype(*std::declval<T>()); 
template<class T> 
using is_ptr_like = can_apply< star_r, T >; 

is_ptr_likeは、物事のことができます。単項間接参照のための形質です。

LockablePtr<T,M>とLockableValue<T,M>の両方が書かれているとします。

template<class T, class M> 
using Lockable = 
    typename std::conditional< is_ptr_like<T&>::value, 
    LockablePtr<T, M>, 
    LockableValue<T, M> 
    >::type; 

template<class T, class M> 
struct LockableObject:Lockable<T,M> { 
    using Lockable<T,M>::Lockable; 
}; 

とされています。余談として、あなたの選択を保存する

Type& 

は悪いもののように思えます。