考慮到以下代碼：
template<typename T, typename U>
constexpr auto divide（T rhs, U lhs） { return rhs / static_cast< T>(lhs); }
這里divide默認為rhs型別（這也是我們從編譯器中得到的默認行為。
但是如果我們想讓 divide 更加智能，使其在編譯時推斷出回傳的最佳型別（即不會導致任何引數縮小的型別）呢。
因此 divide(2, 3.0) 的結果是 0.6666......divide(2.0, 3) 也是如此，但 divide(2, 3) 的結果仍然是 0。
類似于
的情況template<typename T, typename U>
constexpr auto divide2（T rhs, U lhs）{
if constexpr (is_same<U, double> :value)
return static_cast<double>（rhs） / lhs。
else?
return rhs / static_cast<T>（lhs）。
}
但更多的是通用的--我可以去看每個可能的型別，但是否有更好的方法？
是否有一些聰明的使用概念或元編程的方法來找出哪個是更廣泛的型別并選擇它作為投射型別？ 類似于max_type(T, U)？
uj5u.com熱心網友回復：
我想你正在尋找std::common_type：
#include <type_traits>
#include <iostream>
template<typename T>
constexpr T divide_impl（T rhs, T lhs） { return rhs /lhs; }
template<typename T, typename U>
constexpr auto divide（T rhs, U lhs） { return divide_impl< std: :common_type_t<T,U>>（rhs,lhs）; }
int main （）
{
std::cout << std:: is_same_v<int, decltype( divide(2,2) )> << "
"。
std::cout << std::is_same_v<double, decltype( divide(2。 0,2))> << "
"。
輸出是
1
1
因為divide(2,2)回傳一個int，而divide(2.0,2)回傳一個double。
然而，....
這里 divide 默認為 rhs 型別（這與我們從編譯器中得到的默認行為相同。
這是不對的。關于算術轉換，請看這里。https://en.cppreference.com/w/c/language/conversion。而且正如評論中提到的，實際上不需要投幣。以上只是在更普遍的情況下有用，但你不會對rhs / lhs做這樣的事情。
uj5u.com熱心網友回復：
使用common_type_t，以及constexpr。
#include <type_traits>
template< typename type1_t, typename type2_t >
constexpr auto divide(const type1_t&。value1, const type2_t& value2)
{
using type_t = std::common_type_t<type1_t, type2_t> 。
return static_cast<type_t> (value1) / static_cast<type_t>（value2）。
}
int main（）
{
static_assert(0.5 == divide(1.0, 2) )。
static_assert(3ul == divide(10, 3ul) ）。)
static_assert(0.5f == divide(1.0, 2.0f) ）。)
轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/316107.html
標籤：
上一篇：在replace()中使用正則運算式來連接文本中的拆分詞
下一篇：IE11中的JS否定回顧