具有可变模板的自定义容器模板

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

我得到的错误是：

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

生成此错误的源代码位于http://coliru.stacked-crooked.com/a/37d50d6f23363357)：

#include <vector>
using namespace std;
#define CIRCULAR_BUFFER_DEFAULT_SIZE 5000
template <typename T, typename ...Args>
class CircularVector {
public:
    CircularVector(int size) {
        _size = size;
        _v.reserve(_size);
    }
    CircularVector() {
        _size = CIRCULAR_BUFFER_DEFAULT_SIZE;
        _v.reserve(_size);
    }
    void emplace(const Args &... args) {
        ++Count;
        ++_indexWrite;
        if (_indexWrite > _size - 1) _indexWrite = 0;
        _v.emplace(_indexWrite, args...);
    }
    void push(const T& item) {
        ++Count;
        ++_indexWrite;
        if (_indexWrite > _size - 1) _indexWrite = 0;
        _v[_indexWrite] = item;
    }
    void pop(T& item) {
        item = _v[_indexRead];
        ++_indexRead;
        if (_indexRead > _size - 1) _indexRead = 0;
        --Count;
    }
    T& back() {
        return _v[(_indexRead + Count - 1) % _size];
    }

    void erase(int numItems) {
        _indexRead += numItems;
        if (_indexRead > _size - 1) _indexRead -= _size;
        Count -= numItems;
    }
    void eraseAt(int index) {
        swap(_v[index], _v[(_indexRead + Count - 1) % _size]);
        --Count;
        --_indexWrite;
        if (_indexWrite < 0) {
            _indexWrite = _size - 1;
        }
    }
    void clear() {
        _indexRead = 0;
        _indexWrite = -1;
        Count = 0;
    }

    T& operator[](std::size_t idx) {
        int index = _indexRead + idx;
        if (index > _size) index = index % _size;
        return _v[index];
    };
    int Count = 0;
private:
    int _indexWrite = -1;
    int _indexRead = 0;
    int _size = 0;
    std::vector<T> _v;
};

class Item {
public:
    double A;
    int B;
    int C;
    vector<int> D;
    int E;
    Item(double a, int b, int c, vector<int> &d, int e) {
        A = a;
        B = b;
        C = c;
        D = d;
        E = e;
    }
};
int main() {
    CircularVector<Item> v;
    v.emplace(1, 0, 1, 0, 1, 0, vector<int>(), -1);
}