C++ 使用可变模板的自定义容器安放

我正在实现一个简单的循环向量类。我想实现一个emplace成员函数，但是我得到了一个我不理解的错误。这可能是一个简单的修复我做错了什么，但由于我没有太多的经验，可变模板，我无法找出什么

我得到的错误是：

main.cpp: In function 'int main()':

main.cpp:104:50: error: no matching function for call to 'CircularVector<Item>::emplace(int, int, int, int, int, int, std::vector<int>, int)'
     v.emplace(1, 0, 1, 0, 1, 0, vector<int>(), -1);
                                                  ^

main.cpp:104:50: note: candidate is:

main.cpp:20:7: note: void CircularVector<T, Args>::emplace(const Args& ...) [with T = Item; Args = {}]
  void emplace(const Args &... args) {
       ^

main.cpp:20:7: note:   candidate expects 0 arguments, 8 provided

main.cpp:在函数“int main（）”中：
main.cpp:104:50:错误：调用“CircularVector:：emplace（int，int，int，int，int，std:：vector，int）”时没有匹配函数
v、 安放（1,0,1,0,1,0，向量（），-1）；
^
main.cpp:104:50：注：候选人为：
main.cpp:20:7:注意：void CircularVector:：emplace（const Args&…）[with T=Item；Args={}]
空洞侵位（常量参数和…参数）{
^
main.cpp:20:7:注意：候选者需要0个参数，提供8个参数

生成此错误的源代码（也位于此处）：

#包括
使用名称空间std；
#定义循环缓冲区默认大小5000
模板
类循环器{
公众：
循环向量（整数大小）{
_大小=大小；
_v、 储备（单位大小）；
}
循环器（）{
_大小=循环缓冲区默认大小；
_v、 储备（单位大小）；
}
空洞侵位（常量参数和…参数）{
++计数；
++_索引写入；
如果（_indexWrite>_size-1）_indexWrite=0；
_v、 安放（_indexWrite，args…）；
}
无效推送（常数T和项目）{
++计数；
++_索引写入；
如果（_indexWrite>_size-1）_indexWrite=0；
_v[_indexWrite]=项目；
}
无效pop（T和项目）{
项目=_v[_indexRead]；
++_指数读取；
如果（_indexRead>_size-1）_indexRead=0；
--计数；
}
T&back（）{
返回_v[（_indexRead+Count-1）%_size]；
}
无效擦除（整数numItems）{
_indexRead+=numItems；
如果（\u indexRead>\u size-1）\u indexRead-=\u size；
计数-=numItems；
}
无效擦除（整数索引）{
交换（_v[指数]，_v[（_indexRead+Count-1）%_size]）；
--计数；
--_索引写入；
如果（_indexWrite<0）{
_indexWrite=_size-1；
}
}
无效清除（）{
_indexRead=0；
_indexWrite=-1；
计数=0；
}
T&T运算符[]（标准：：大小\u T idx）{
int index=_indexRead+idx；
如果（索引>大小）索引=索引%\u大小；
返回v[索引]；
};
整数计数=0；
私人：
int _indexWrite=-1；
int _indexRead=0；
int _size=0；
std:：vector_v；
};
类项目{
公众：
双A；
int B；
INTC；
载体D；
INTE；
项目（双a、双b、双c、双d、双e）{
A=A；
B=B；
C=C；
D=D；
E=E；
}
};
int main（）{
循环向量v；
v、 安放（1,0,1,0,1,0，向量（），-1）；
}

Args

必须是

emplace

的模板参数，而不是

CircularVector

template <typename T>
class CircularVector {
public:

    /* ... */

    template<typename ...Args>
    void emplace(const Args &... args) {
        /* ... */
    }
};

模板
类循环器{
公众：
/* ... */
模板
空洞侵位（常量参数和…参数）{
/* ... */
}
};

---

也应考虑使用<代码> > ESPOT/<代码>的转发引用。<> >代码> ARGs<代码>必须是<代码> ESPOTE <代码>的模板参数，而不是<代码>循环向量< /代码> .<

template <typename T>
class CircularVector {
public:

    /* ... */

    template<typename ...Args>
    void emplace(const Args &... args) {
        /* ... */
    }
};

模板
类循环器{
公众：
/* ... */
模板
空洞侵位（常量参数和…参数）{
/* ... */
}
};

---

也应考虑使用<代码> > ESPOT/<代码>的转发引用。<> >代码> ARGs<代码>必须是<代码> ESPOTE <代码>的模板参数，而不是<代码>循环向量< /代码> .<

template <typename T>
class CircularVector {
public:

    /* ... */

    template<typename ...Args>
    void emplace(const Args &... args) {
        /* ... */
    }
};

模板
类循环器{
公众：
/* ... */
模板
空洞侵位（常量参数和…参数）{
/* ... */
}
};

---

也应考虑使用<代码> > ESPOT/<代码>的转发引用。<> >代码> ARGs<代码>必须是<代码> ESPOTE <代码>的模板参数，而不是<代码>循环向量< /代码> .<

template <typename T>
class CircularVector {
public:

    /* ... */

    template<typename ...Args>
    void emplace(const Args &... args) {
        /* ... */
    }
};

模板
类循环器{
公众：
/* ... */
模板
空洞侵位（常量参数和…参数）{
/* ... */
}
};

---

此外，您应该考虑使用<代码> > ESPOT/<代码>的转发引用。

< P>如果有人碰到同一个问题，这就是我如何实现的：

void emplace(Args&&... args) {
    ++Count;
    ++_indexWrite;
    if (_indexWrite > _size - 1) _indexWrite = 0;
    _v.emplace(_v.begin() + _indexWrite, std::forward<Args>(args)...);
}

void侵位（Args&&…Args）{
++计数；
++_索引写入；
如果（_indexWrite>_size-1）_indexWrite=0；
_v、 安放（_v.begin（）+_indexWrite，std:：forward（args）…）；
}

---

虽然我真正想要的是使用该索引中的保留内存构造一个元素，而不是在该特定位置插入新元素。

如果有人遇到相同的问题，我就是这样实现的：

void emplace(Args&&... args) {
    ++Count;
    ++_indexWrite;
    if (_indexWrite > _size - 1) _indexWrite = 0;
    _v.emplace(_v.begin() + _indexWrite, std::forward<Args>(args)...);
}

void侵位（Args&&…Args）{
++计数；
++_索引写入；
如果（_indexWrite>_size-1）_indexWrite=0；
_v、 安放（_v.begin（）+_indexWrite，std:：forward（args）…）；
}

---

虽然我真正想要的是使用该索引中的保留内存构造一个元素，而不是在该特定位置插入新元素。

如果有人遇到相同的问题，我就是这样实现的：

void emplace(Args&&... args) {
    ++Count;
    ++_indexWrite;
    if (_indexWrite > _size - 1) _indexWrite = 0;
    _v.emplace(_v.begin() + _indexWrite, std::forward<Args>(args)...);
}

void侵位（Args&&…Args）{
++计数；
++_索引写入；
如果（_indexWrite>_size-1）_indexWrite=0；
_v、 安放（_v.begin（）+_indexWrite，std:：forward（args）…）；
}

---

虽然我真正想要的是使用该索引中的保留内存构造一个元素，而不是在该特定位置插入新元素。

如果有人遇到相同的问题，我就是这样实现的：

void emplace(Args&&... args) {
    ++Count;
    ++_indexWrite;
    if (_indexWrite > _size - 1) _indexWrite = 0;
    _v.emplace(_v.begin() + _indexWrite, std::forward<Args>(args)...);
}

void侵位（Args&&…Args）{
++计数；
++_索引写入；
如果（_indexWrite>_size-1）_indexWrite=0；
_v、 安放（_v.begin（）+_indexWrite，std:：forward（args）…）；
}

虽然我真正想要的是使用