1

我正在尝试在对象中实现“安放”功能。它的结构如下。我有一个将 size_t 与模板类型配对的模板对象。我希望能够在标准库容器中构建它，例如向量。我没有使用 a std::pair，因为我的班级B将围绕数据提供其他功能。

我需要如何修改代码，以便可以像在 main 中一样调用 emplace？

#include <iostream>                                                                 
#include <vector>                                                                   
using namespace std;                                                                

class C {                                                                           
  public:                                                                           
    C(const string& _s) : s(_s) {}                                                  
    C(string&& _s) : s(_s) {}                                                       

  private:                                                                          
    string s;                                                                       
};                                                                                  

template<typename A>                                                                
class B {                                                                           
  public:                                                                           

    B(size_t _i, const A& _a) : i(_i), a(_a) {}                                     
    B(size_t _i, A&& _a) : i(_i), a(_a) {}                                                  

  private:                                                                          
    size_t i;                                                                       
    A a;                                                                            
};                                                                                  

int main() {                                                                        
  vector<B<C>> v;                                                                   
  v.emplace_back(5, "Hello");                                                       
}
4

2 回答 2

3

每个参数允许一个用户定义的转换序列，并且您有两个：

  1. const char*-->std::string
  2. std::string-->C

您可以做的是通过实现通用转发构造函数来减少隐式转换的数量：

template<typename A>                                                                
class B {                                                                           
  public:

    template<typename X>
    B(size_t _i, X&& _a) : i(_i), a(std::forward<X>(_a)) {}                                                  

  ...
};

这将生成一个完美B(size_t, const char*)匹配的构造函数emplace_back(5, "Hello")，只需一次转换即可构造afrom const char *。

于 2017-12-18T20:48:35.930 回答
3

这不起作用的原因不是因为您不能进行隐式转换。在以下代码中：

vector<B<C>> v;                                                                   
v.emplace_back(5, "Hello");

emplace_back完美转发到 包含的类型的构造函数v，即B<C>. 所以我们最终调用（它实际上是通过分配器发生的，但让我们忽略细节）：

B<C>(5, "Hello")

为什么这不起作用？你经常听到有人说调用模板时不能得到隐式转换；这大致上是真的。但是B<C>的构造函数不是模板；B是一个已经被模板化的模板类，B<C>一个普通的类也是如此，它的构造函数不是模板。因此允许隐式转换。

但是，C++ 中的隐式转换包括：

  1. 零个或一个标准转换序列；
  2. 零次或一次用户定义的转换；
  3. 零个或一个标准转换序列。

（http://en.cppreference.com/w/cpp/language/implicit_conversion）。

用户定义的转换基本上是一个定义隐式构造函数或转换运算符的类。string可能是标准库的一部分，但它只是一个普通的类，从const char*到的转换string已经算作用户转换。所以你不能从stringC得到第二个。

解决此问题的一种方法是将您的构造函数模板化为 C，但单参数隐式模板构造函数会使您面临各种其他问题。我可能只是定义了第二个构造函数，它需要一个const char*. 顺便说一句，在 cppcon 上有一个关于这个问题的完整讨论： https: //www.youtube.com/watch?v= PNRju6_yn3o 。

于 2017-12-18T23:28:16.927 回答