c ++可变参数模板构造函数和常用构造函数 [英] c++ variadic template constructor and common constructors

问题描述

代码如（c ++ 14）：

Code like (c++14):

struct S { int a; int b; };

class C
{
  public:
    C(char const*, size_t) {} // 1
    C(S const&) {} // 2
    C(S const*) {} // 3
    template<typename ...T> C(T&& ...) {} // 4

 // C(S) {} // 5
 // C(S*) {} // 6
};

S s { 1, 2 };
C c1 { s }; // calls 4 and not 2
C c2 { "abc", 3 }; // calls 4 and not 1
C c3 { (char const*)"abc", (size_t)3 }; // calls 1 - ok
C c4 { s }; // calls 5 if uncommented
C c5 { &s }; // calls 6 if uncommented
S const s2 {};
C c6 { &s2 }; // calls 3

如果简单构造函数具有与传递的参数完全相同的签名，
有一些技巧像通常一样使用可变参数模板构造函数，而不复制类，作为参数传递和重载构造函数，如：

Simple constructor is called if it has exact the same signature as the passed parameter. Is there some trick to use common constructors as usual with a variadic template constructor, without copying classes, passed as parameters, and overloading constructors like:

C(S const*) {}
C(S*) {}

在构造函数中没有其他标签

And without additional tags in constructors

推荐答案

创建两层构造函数。

template<template<class...>class Z, class T>
struct is_template:std::false_type{};
template<template<class...>class Z, class...Ts>
struct is_template<Z, Z<Ts...>>:std::true_type{};

struct foo {
private:
  template<class T> struct tag{ explicit tag(int) {} };
public:
  foo( tag<std::true_type>, const char*, size_t );
  template<class...Ts>
  foo( tag<std::false_type>, Ts&&...ts );

public:
  foo() = default; // or whatever
  template<class T0, class...Ts,
    std::enable_if_t<!is_template<tag, std::decay_t<T0>>{},int> =0>
  foo(T0&&t0, Ts&&...ts):
    foo( tag<typename std::is_constructible< foo, tag<std::true_type>, T0&&, Ts&&... >::type>{0}, std::forward<T0>(t0), std::forward<Ts>(ts)... )
  {}
};

首选ctors前缀为 std :: true_type ，less preferredctors前缀为 std :: false_type 。

The "preferred" ctors are prefixed with std::true_type, the "less preferred" ctors are prefixed with std::false_type.

通常的完美转发缺陷。如果你使用初始化列表，你将需要另一个publicctor，例如明确的。和函数名参数魔法重载将不工作。 NULL 是一个 int 。 etc。

This has the usual imperfections of perfect forwarding. If you take initializer lists, you'll want to have another "public" ctor that takes that explicitly, for example. And function name argument magical overloading won't work. NULL is an int. Etc.

你可以想象一个版本，而不是有两层，有一个任意数字。 is_constructible< ...> 在公共面对ctor中的子句被替换为一些魔法，找到最高的N，使得标签< N>，blah ... 可以构造对象（或最低 N ，无论哪种方式）。然后它返回类型标签< N> ，然后分派到该层。

You can imagine a version that, instead of having two tiers, has an arbitrary number. The is_constructible< ... > clause in the public facing ctor instead is replaced with some magic that finds the highest N such that tag<N>, blah... can construct the object (or, lowest N, whichever way you want to do it). Then it returns the type tag<N>, which then dispatches to that tier.

：

template <typename... T,
      typename = std::enable_if_t<!std::is_constructible<C, T&&...>::value>
       >
C(T&&... ) { }

=http://stackoverflow.com/a/33040916/1774667>一个严重的问题，因为我们在上下文中实例化了 is_constructible 它得到的答案错误。在实践中，编译器缓存模板实例化的结果，所以现在 is_constructible 的结果是编译器依赖（OBR违反我怀疑）。

runs into a serious problem down the road, as we have instantiated is_constructible in a context where it gets the answer wrong. And in practice, compilers cache the results of template instantiations, so now the result of is_constructible is compiler order dependent (ODR violation I suspect).

这篇关于c ++可变参数模板构造函数和常用构造函数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！