在c++中，有没有一个c++特性可以在两个类型之间找到最受限制的类型

Question

我想要一个类型特征common

因此

common<int,int>::type              -> int
common<const int, int>::type       -> const int
common<int, int &>::type           -> int
common<int &, int &>::type         -> int &
common<int &, int const &>::type   -> int const &

也就是说，结果类型应该是两者中限制性较大的一种。C++11标准中有没有一个特性可以做到这一点，或者我必须自己滚动？

我的用例是我有一个类似的东西

template <typename T0, typename T1>
struct Foo {
BOOST_STATIC_ASSERT(
std::is_same
< typename std::decay<T0>::type
, typename std::decay<T1>::type
>::value
);
// I need to find T which is the most restrictive common
// type between T0 and T1
typedef typename common<T0,T1>::type T
T0 t0;
T1 t1;
T choose(bool c){
return c ? t0 : t1;
}
} 

Answer 1

恐怕您需要自己滚动。您可以在std:：元组中扭曲类型，然后将其传递给std::common_type，例如

#include <tuple>
#include <type_traits>
template <class T1, class T2>
struct common {
using type = typename std::tuple_element<0, typename std::common_type<std::tuple<T1>, std::tuple<T2>>::type>::type;
};
template <class T>
struct common<const T, T> {
using type = const T;
};
template <class T>
struct common<T, const T> {
using type = const T;
};
template <class T>
struct common<const T, const T> {
using type = const T;
};
int main()
{
static_assert(std::is_same<common<int, int>::type, int>::value, "");
static_assert(std::is_same<common<const int, int>::type, const int>::value, "");
static_assert(std::is_same<common<int, int &>::type, int>::value, "");
static_assert(std::is_same<common<int &, int &>::type, int &>::value, "");
static_assert(std::is_same<common<int &, int const &>::type, int const &>::value, "");
return 0;
}

但是您必须为const创建特殊情况。

Answer 2

从Oliv的解决方案中获得灵感，一个可能的C++11版本

#include <utility>
#include <type_traits>
template <typename T1, typename T2>
using cond_t = decltype(false ? std::declval<T1>() : std::declval<T2>());
template <typename T1, typename T2>
using common = typename std::conditional<
std::is_reference<T1>::value || std::is_reference<T2>::value,
cond_t<T1, T2>,
typename std::remove_reference<cond_t<T1 &, T2 &>>::type>::type;
int main()
{
using t1 = common<int,int>;
using t2 = common<const int, int>;
using t3 = common<int, int &>;
using t4 = common<int &, int &>;
using t5 = common<int &, int const &>;
static_assert( std::is_same<t1, int>::value, "!" );
static_assert( std::is_same<t2, int const>::value, "!" );
static_assert( std::is_same<t3, int>::value, "!" );
static_assert( std::is_same<t4, int &>::value, "!" );
static_assert( std::is_same<t5, int const &>::value, "!" );  
}

Answer 3

在c++20中，您可以使用common_reference(在range v3库中有一个实现(，但如果这两种类型都不是引用的，则需要进行一些调整：

template<class T,class U>
using common_t = conditional_t<is_reference_v<T> || is_reference_v<U>
,common_reference_t<T,U>
,remove_reference_t<common_reference_t<T&,U&>>>;

Answer 4

这可以用decltype 破解

https://godbolt.org/z/7xEv7Z

#include <type_traits>
// Use it to display the actual generated type
template <typename T> struct F;
template <typename T0,typename T1> 
struct Common
{
typedef decltype(true ? ((T0)std::declval<T0>()) : ((T1)std::declval<T1>()) ) 
type;
};
// Perform tests
F<Common<int,int>::type> f0;
F<Common<int &,int>::type> f1;
F<Common<const int &, int &>::type> f2;
F<Common<const int &, int>::type> f3;

按照预期给出结果

aggregate 'F<int> f0' has incomplete type and cannot be defined
aggregate 'F<int> f1' has incomplete type and
aggregate 'F<const int&> f2' has incomplete
aggregate 'F<int> f3' has incomplete type and