除可变模板参数外，输入参数也无法编译

Question

我努力一步一步地编写示例，使其清晰易懂。

此处显示的object BaseCreator公开了一个create函数，该函数使用一个内部类NewObject来分配一个t类型的新对象。new object类的默认方法是使用new运算符的常用方法，但是可以使用专门化来更改它，以使用不同的进程。我们稍后会看到它。

template <typename F>
class BaseCreator
{
public:
    BaseCreator() = default;
    virtual ~BaseCreator() = default;

    // create function 
    template <typename T, typename... Args>
    std::shared_ptr<T> create(Args&&... parameters)
    {
        return std::shared_ptr<T>(NewObject<T, Args...>().get(std::forward<Args>(parameters)...));
    }

private:
    // creator object with default functionality to create a new object
    template <typename T, typename... Args>
    struct NewObject
    {
        T* get(Args&&... parameters)
        {
            return new T(std::forward<Args>(parameters)...);
        }
    };
};

这很好，例如，假设我们有以下对象类型：

struct A
{
    A(int i_i, const std::string& i_s) : i(i_i), s(i_s) {}
    void addVal(int i_i) { i+=i_i; }
    int i = 0;
    std::string s;
};

struct B
{
    B(const std::vector<float>& i_v) : v(i_v) {}
    void addVal(int i_i) { v.push_back((float)i_i); }
    std::vector<float> v;
};

我们可以很容易地创建它们，例如：

// declare type for a creator identity 
struct Group111 {};

// creator object
BaseCreator<Group111> cCreator111;

// creating A and B
std::shared_ptr<A> spA = cCreator111.create<A>(5, "Hello");
std::shared_ptr<B> spB = cCreator111.create<B>(std::vector<float>({ 0.5f,0.1f,0.7f,0.9f }));

我们还可以为特定对象和特定类型的创建者声明特定的创建方法。这里举例说明使用组222的创建者创建对象A的专门化:

// declare type for a creator identity 
struct Group222 {};

// specialize NewObject for BaseCreator<Group222> for creating A
template<> 
template< typename... Args> 
struct BaseCreator<Group222>::NewObject<A, Args...>
{
    A* get(int i_factor, int i_i, const std::string& i_s)
    {
        A* p = new A(i_i, i_s);
        p->i *= i_factor;
        return p;
    }
};

并且使用Group222类型的创建者创建对象A将具有与默认方法不同的方法。

// creator object
BaseCreator<Group222> cCreator222;

// creating A with creator of Group222 needs now additional input argument 
std::shared_ptr<A> spA = cCreator222.create<A>(3, 5, "Hello");

// creating A with creator of Group222 is the same as creating using creator cCreator111
std::shared_ptr<B> spB = cCreator222.create<B>(std::vector<float>({ 0.5f,0.1f,0.7f,0.9f }));

现在是问题：）

现在，我想派生一个新的BaseCreator来拥有下面的一个，如您所见，它具有代理创建函数，并使用包中的额外整数调用其基类1：

class Creator333 : public BaseCreator<Creator333>
{
public:
    Creator333() = default;
    virtual ~Creator333() = default;

    // creator
    template <typename T, typename... Args>
    std::shared_ptr<T> create(Args&&... parameters)
    {
        int adder = 5; // just for the example
        return std::shared_ptr<T>(BaseCreator<Creator333>::create<T>(adder, std::forward<Args>(parameters)...));
    }

};

它配备了专门的BaseCreator。

template<> 
template<typename T, typename... Args> 
struct BaseCreator<Creator333>::NewObject<T, Args...>
{
    T* get(int i_adder, Args&&... parameters)
    {
        T* p = new T(std::forward<Args>(parameters)...);
        p->addVal(i_adder);
        return p;
    }
};

如果我尝试创建一个对象，让我们使用这个Creator333说B：

Creator333 cCreator333;

// creation of B using Creator333 
std::shared_ptr<B> spB3 = cCreator333.create<B>(std::vector<float>({ 0.1f,0.2f}));

我将得到一个编译器错误：

error C2660: 'BaseCreator<Creator333>::NewObject<T,int &,_Ty>::get': function does not take 2 arguments
1>        with
1>        [
1>            T=B,
1>            _Ty=std::vector<float,std::allocator<float>>
1>        ]

但这很奇怪，因为该函数确实应该得到两个参数，如下所示：

>

Create333：：create - 获取一个包含一个元素的包 std：：vector（{ 0.1f，0.2f}）

它调用其基本计算器＜code＞BaseCreator

BaseCreator

那么问题是什么，怎么解决呢？

谢谢




Answer 1

以下是一个解决方案，但不是答案，这意味着代码有效，但我不明白为什么这个工作，而问题中的那个不起作用。因此，如果有人可以描述原因，我相信这将有助于许多人更深入地了解这个主题。

感谢@Kuba comment，我根据他建议的单词进行了搜索，并在这个stackoverflow问题中找到了一个代码，启发了我以下解决方案：

我为Creator333添加了一个Helper，如下所示。它有助于将输入包拆分为所需的两部分：附加整数和来自应用程序代码的原始包。但我还必须将特殊的创建代码移入其中。

class Creator333 : public BaseCreator<Creator333>
{
public:
    Creator333() = default;
    virtual ~Creator333() = default;

    // creator
    template <typename T, typename... Args>
    std::shared_ptr<T> create(Args&&... parameters)
    {
        int adder = 5; // just for the example
        return std::shared_ptr<T>(BaseCreator<Creator333>::create<T>(adder, std::forward<Args>(parameters)...));
    }

    // helper class for splitting given pack into  desired two parts: 
    // the additional integer and the original pack came from the application code
    template<typename T, typename FirstTypeT, typename... Args>
    struct Helper
    {
        T* get(FirstTypeT i_adder, Args&&... parameters)
        {
            T* p = new T(std::forward<Args>(parameters)...);
            p->addVal(i_adder);
            return p;
        }
    };
};

专门化< code>BaseCreator

template<> 
template<typename T, typename... Args>
struct BaseCreator<Creator333>::NewObject<T, Args...>
{
    T* get(Args&&... parameters)
    {
        return Creator333::Helper<T,Args... >().get(std::forward<Args>(parameters)...);
    }
};