Question

template<typename T>
struct S {
    using type = T;
};

volatile S<int> s;

template<typename T>
void f(T& v) {
    using n = typename T::type;

    S<n>::_; // to show

}

int main() {
     f(s);
}

在f中，T被推导为volatile S<int>，而n是只有1个}}。为了保存int，我该怎么做，将volatile设为n？

Answer 1

using n = typename std::conditional< std::is_volatile<T>::value, 
            volatile typename T::type,
            typename T::type >::type;

如果volatile为n，则将T添加到volatile。

Answer 2

有趣。如果您需要经常执行此类操作，则可以将其封装在元函数中。这是c++17中可能的实现：

#include <type_traits>

template<class Trait, typename=void>
struct propogate_cv_to_type{};

template<class Trait>
struct propogate_cv_to_type<Trait, std::void_t<typename Trait::type>>
{ using type = typename Trait::type; }; 

template<class Trait>
struct propogate_cv_to_type<Trait const, std::void_t<typename Trait::type>>
{ using type = typename Trait::type const; }; 

template<class Trait>
struct propogate_cv_to_type<Trait volatile, std::void_t<typename Trait::type>>
{ using type = typename Trait::type volatile; }; 

template<class Trait>
struct propogate_cv_to_type<Trait const volatile, std::void_t<typename Trait::type>>
{ using type = typename Trait::type const volatile; };

它是SFINAE友好的，因此，如果所传递的类型没有::type成员，则也不会。否则，它将通过向其转发限定符来公开相同的类型。

Here it应用于您的示例。

保留嵌套类型中的volatile

2 个答案: