一个功能的类模板专业化

Question

I've got a templated class that looks like this:

template<typename T>
class TemplatedClass
{
    // ... Other functions
    void AssignTo(const T & value)
    {
        m_value = value;
    }

private:
    T m_value;
    // ...
}

that I want to work with std::atomic<> , but doesn't at the moment because std::atomic<> is non-copyable.

Is there any way to only re-implement the AssignTo() function, but keep using all the other functions without modification so that we can have eg TemplatedClass<std::atomic<bool> ? I've thought about using std::enable_if or template specialization, but haven't come up with an elegant solution.

Answer 1

#include <type_traits>

template <typename T>
class TemplatedClass
{
public:
    void AssignTo(const T& value)
    {
        if constexpr (std::is_copy_assignable_v<T>) {
            m_value = value;
        } else {
            // Something else
        }
    }

private:
    T m_value;
};

DEMO

---

For atomic-only types, replace std::is_copy_assignable_v<T> with !is_atomic_v<T> :

template <typename>
constexpr bool is_atomic_v = false;

template <typename T>
constexpr bool is_atomic_v<std::atomic<T>> = true;

Answer 2

Is there any way to only re-implement the AssignTo() function, but keep using all the other functions without modification so that we can have eg TemplatedClass<std::atomic<bool> ?

Do you mean something as follows?

template <typename>
struct isAtomic : public std::false_type
 { };

template <typename T>
struct isAtomic<std::atomic<T>> : public std::true_type
 { };

template <typename T>
constexpr auto isAtomic_v = isAtomic<T>::value;

template <typename T>
class TemplatedClass
 {
    public: 
       // ... Other functions

       template <typename U = T>
       std::enable_if_t<false == isAtomic_v<U>> AssignTo(const T & value)
        { m_value = value; }

       template <typename U = T>
       std::enable_if_t<true == isAtomic_v<U>> AssignTo(const T & value)
        { /* ??? */ }

    private:
       T m_value;
    // ...
  };