以不同的方式调度 r 值和 l 值，并使用 sfinae 禁用一个选项
Dispatching r-values and l-values differently and using sfinae to disable one option
我想实现一个函数drop_if。给定一个一元谓词和一个顺序容器，它返回一个相同类型的容器，仅包含原始容器中不满足谓词的元素。
如果输入容器是 r 值，则应就地工作，否则创建副本。这是通过调度到namespace internal中的相应版本来实现的。如果容器的value_type无法覆盖(例如std::pair<const int, int>)，即使容器是 r 值，也应禁用 r 值版本。
以下代码在 clang 和当前版本的 gcc (>=6.3) 上按预期工作。
#include <algorithm>
#include <iostream>
#include <iterator>
#include <type_traits>
#include <utility>
#include <vector>
namespace internal
{
template <typename Pred, typename Container,
typename = typename std::enable_if<
std::is_assignable<
typename Container::value_type&,
typename Container::value_type>::value>::type>
Container drop_if( Pred pred, Container&& xs )
{
std::cout << "r-value" << std::endl;
xs.erase( std::remove_if( std::begin( xs ), std::end( xs ), pred ), std::end( xs ) );
return std::move( xs );
}
template <typename Pred, typename Container>
Container drop_if( Pred pred, const Container& xs )
{
std::cout << "l-value" << std::endl;
Container result;
auto it = std::back_inserter( result );
std::remove_copy_if( std::begin( xs ), std::end( xs ), it, pred );
return result;
}
} // namespace internal
template <typename Pred, typename Container,
typename Out = typename std::remove_reference<Container>::type>
Out drop_if( Pred pred, Container&& xs )
{
return std::move( internal::drop_if( pred, std::forward<decltype(xs)>( xs ) ) );
}
typedef std::pair<int, int> pair_t;
typedef std::vector<pair_t> vec_t;
bool sum_is_even( pair_t p )
{
return (p.first + p.second) % 2 == 0;
}
typedef std::pair<const int, int> pair_c_t;
typedef std::vector<pair_c_t> vec_c_t;
bool sum_is_even_c( pair_c_t p)
{
return (p.first + p.second) % 2 == 0;
}
int main()
{
vec_c_t v_c;
drop_if( sum_is_even_c, v_c ); // l-value
drop_if( sum_is_even_c, vec_c_t() ); // l-value
vec_t v;
drop_if( sum_is_even, v ); // l-value
drop_if( sum_is_even, vec_t() ); // r-value
}
但是，它不会在MSVC++和GCC 6.2上编译，因为它们在std::is_assignable中行为不正确：
using T = std::pair<const int, int>;
const auto ok = std::is_assignable<T&, T>::value;
// ok == true on GCC 6.2 and MSVC++
请参阅此问题的答案和磁带库缺陷报告 2729。
我希望它适用于不同的容器和不同类型的对象，例如std::vector<double>、std::map<int, std::string>等std::map的情况(使用不同的机械臂)是我遇到std::pair<const T, U>value_types问题的情况。
您是否知道如何将调度/sfinae更改为也适用于MSVC++(在我的情况下为MSVC++ 2017 15.2 26430.6版本)和GCC 6.2以下版本？
问题似乎是MSVC的std::pair<const T, U>::operator=未禁用SFINAE。 即使实例化它不起作用，它也存在。
因此，当您检测到它是否存在时，它就存在。 如果执行它，则编译失败。
我们可以解决这个问题。 但这是一种解决方法。
namespace internal
{
template <typename Pred, typename Container>
Container drop_if( std::true_type reuse_container, Pred pred, Container&& xs )
{
std::cout << "r-value" << std::endl;
xs.erase( std::remove_if( std::begin( xs ), std::end( xs ), pred ), std::end( xs ) );
return std::forward<Container>( xs );
}
template <typename Pred, typename Container>
Container drop_if( std::false_type reuse_container, Pred pred, const Container& xs )
{
std::cout << "l-value" << std::endl;
Container result;
auto it = std::back_inserter( result );
std::remove_copy_if( std::begin( xs ), std::end( xs ), it, pred );
return result;
}
} // namespace internal
template<bool b>
using bool_k = std::integral_constant<bool, b>;
template<class T>
struct can_self_assign {
using type = std::is_assignable<T&, T>;
};
template<class T>
using can_self_assign_t = typename can_self_assign<T>::type;
template<class T0, class T1>
struct can_self_assign<std::pair<T0, T1>>
{
enum { t0 = can_self_assign_t<T0>::value, t1 = can_self_assign_t<T1>::value, x = t0&&t1 };
using type = bool_k< x >;
};
template<>
struct can_self_assign<std::tuple<>>
{
using type = bool_k< true >;
};
template<class T0, class...Ts>
struct can_self_assign<std::tuple<T0, Ts...>>
{
using type = bool_k< can_self_assign_t<T0>::value && can_self_assign_t<std::tuple<Ts...>>::value >;
};
template <typename Pred, typename Container,
typename Out = typename std::remove_reference<Container>::type>
Out drop_if( Pred pred, Container&& xs )
{
using dContainer = typename std::decay<Container>::type;
using can_assign = can_self_assign_t<typename dContainer::value_type>;
using cannot_reuse = std::is_lvalue_reference<Container>;
using reuse = std::integral_constant<bool, can_assign::value && !cannot_reuse::value >;
return internal::drop_if( reuse{}, pred, std::forward<Container>( xs ) );
}
现场示例和其他实时示例。
我还将您的 SFINAE 调度更改为基于标签的调度。
具有缺陷operator=禁用的其他类型也可能需要can_self_assign专业化。 值得注意的例子可能包括tuple<Ts...>和vector<T,A>以及类似的例子。
我不知道何时以及是否需要operator=编译器"不存在"，如果它不适用于std类型;我记得std::vector一度不需要它，但我也记得一个提案增加了这样的要求。
你没有说你正在使用哪个版本的Visual C++编译器，但你试过使用尾随返回语法吗？
换句话说，替换它：
template <typename Pred, typename Container,
typename Out = typename std::remove_reference<Container>::type>
Out drop_if( Pred pred, Container&& xs )
用这样的东西？
template <typename Pred,
typename Container>
auto drop_if(Pred pred, Container&& xs) -> std::remove_reference<Container>::type
Visual C++ 编译器已逐渐添加C++ 11/14/17 功能。 我一直在努力使模板 MPL 工作，并且不得不解决一些"应该"工作但不起作用的事情。
我承认这有点猜测，但你可以试一试。
如果您希望您的代码专门用于元组类对象的容器，您可以这样做(残酷但适用于旧版本的 gcc 和 MSVC)：
#include <algorithm>
#include <iostream>
#include <iterator>
#include <type_traits>
#include <utility>
#include <vector>
namespace internal
{
template <class... Ts>
int foo(Ts&&... ts);
template <typename Pred, typename Container, std::size_t... Is>
auto drop_if( Pred pred, Container&& xs, std::index_sequence<Is...>) -> decltype(foo(std::declval<typename std::tuple_element<Is, typename std::remove_reference<typename Container::value_type>::type>::type&>() = std::declval<typename std::tuple_element<Is, typename std::remove_reference<typename Container::value_type>::type>::type>()...), xs)
{
std::cout << "r-value" << std::endl;
xs.erase( std::remove_if( std::begin( xs ), std::end( xs ), pred ), std::end( xs ) );
return xs;
}
template <typename Pred, typename Container, class I>
Container drop_if( Pred pred, const Container& xs, I )
{
std::cout << "l-value" << std::endl;
Container result;
auto it = std::back_inserter( result );
std::remove_copy_if( std::begin( xs ), std::end( xs ), it, pred );
return result;
}
} // namespace internal
template <typename Pred, typename Container,
typename Out = typename std::remove_reference<Container>::type>
Out drop_if( Pred pred, Container&& xs )
{
return internal::drop_if( pred, std::forward<decltype(xs)>( xs ), std::make_index_sequence<std::tuple_size<typename Out::value_type>::value>{} );
}
typedef std::pair<int, int> pair_t;
typedef std::vector<pair_t> vec_t;
bool sum_is_even( pair_t p )
{
return (p.first + p.second) % 2 == 0;
}
typedef std::pair<const int, int> pair_c_t;
typedef std::vector<pair_c_t> vec_c_t;
bool sum_is_even_c( pair_c_t p)
{
return (p.first + p.second) % 2 == 0;
}
int main()
{
vec_c_t v_c;
drop_if( sum_is_even_c, v_c ); // l-value
drop_if( sum_is_even_c, vec_c_t() ); // l-value
vec_t v;
drop_if( sum_is_even, v ); // l-value
drop_if( sum_is_even, vec_t() ); // r-value
}
[现场演示]
很好的发现，在这些更改得到修复之前，我为这种极端情况提供了解决方案。
namespace internal {
template <typename T>
struct my_is_pair {
static constexpr bool value = false;
};
template <typename K, typename V>
struct my_is_pair<std::pair<K, V>> {
static constexpr bool value = true;
};
template <typename T, typename U, typename TIsPair = void>
struct my_is_assignable : std::is_assignable<T, U> {
using is_pair_type = std::false_type;
};
template <typename T, typename U>
struct my_is_assignable<T,
U,
typename std::
enable_if<my_is_pair<typename std::decay<T>::type>::value
&& my_is_pair<typename std::decay<U>::type>::value>::
type>
: std::integral_constant<bool,
std::is_assignable<
typename std::remove_reference<T>::type::first_type&,
const typename std::remove_reference<U>::type::first_type&>::
value
&& std::is_assignable<
typename std::remove_reference<T>::type::second_type&,
const typename std::remove_reference<U>::type::
second_type&>::value> {
using is_pair_type = std::true_type;
};
template <
typename Pred,
typename Container,
typename = typename std::
enable_if<my_is_assignable<
typename std::remove_reference<Container>::type::value_type,
typename std::remove_reference<Container>::type::value_type>::value
&& std::is_rvalue_reference<Container&&>::value>::type>
Container drop_if(Pred pred, Container&& xs) {
std::cout << "r-value" << std::endl;
xs.erase(std::remove_if(std::begin(xs), std::end(xs), pred), std::end(xs));
return xs;
}
template <typename Pred, typename Container>
Container drop_if(Pred pred, const Container& xs) {
std::cout << "l-value" << std::endl;
Container result;
auto it = std::back_inserter(result);
std::remove_copy_if(std::begin(xs), std::end(xs), it, pred);
return result;
}
} // namespace internal
template <typename Pred,
typename Container,
typename Out = typename std::remove_reference<Container>::type>
Out drop_if(Pred pred, Container&& xs) {
return internal::drop_if(pred, std::forward<decltype(xs)>(xs));
}
typedef std::pair<int, int> pair_t;
typedef std::vector<pair_t> vec_t;
bool sum_is_even(pair_t p) { return (p.first + p.second) % 2 == 0; }
typedef std::pair<const int, int> pair_c_t;
typedef std::vector<pair_c_t> vec_c_t;
bool sum_is_even_c(pair_c_t p) { return (p.first + p.second) % 2 == 0; }
int main() {
vec_c_t v_c;
drop_if(sum_is_even_c, v_c); // l-value
drop_if(sum_is_even_c, vec_c_t()); // r-value
vec_t v;
drop_if(sum_is_even, v); // l-value
drop_if(sum_is_even, vec_t()); // r-value
}
这只是为缺陷报告中建议的对类型引入了is_assignable专用化。我添加的另一件事是std::is_rvalue_reference防止是否调用左值引用(在您的解决方案中，它被Container::value_type中的失败替换禁用，当Containervector<...>&时失败。
相关文章：
- 如何在选项卡视图Qt中设置一个新项目，并保存以前的项目
- Win32编译器选项和内存分配
- 为什么使用SFINAE而不是函数重载
- 如何使用模板函数的函数签名进行SFINAE
- 数据成员SFINAE的C++17测试:gcc vs clang
- 使用在用于SFINAE的void_t中具有参数的方法
- C/C++预处理器是否可以检测一些编译器选项
- 是否有C++编译器选项允许激进地删除所有函数调用，并将参数传递给具有空体的函数
- 将--whole archive链接器选项与CMake和具有其他库依赖项的库一起使用
- 编译器如何在使用SFINAE的函数和标准函数之间确定两者是否可行
- 通过选项卡的文本设置QTabWidget顺序
- 通过ccmake在cmake中缓存依赖选项
- 提供与TMP和SFINAE的通用接口
- 如何传递多个 std::文件系统选项?
- 基于编译器选项的编译二进制路径
- "Inverse SFINAE"避免模棱两可的过载
- "perf_event_attr"结构的"read_format"属性的选项到底是什么？
- 如何应用 libcurl 的持久连接选项
- 以不同的方式调度 r 值和 l 值，并使用 sfinae 禁用一个选项
- 如何在C++11中使用SFINAE从多个选项中选择构造函数
