C++ 使用模板读取向量

我试图从文件中读取向量，但我可能有不同的数据类型，并且我使用模板

template <class T>
vector<T> readd(int n)
{
    vector<T> V;
    for(int i=0;i<n;i++)
    {
        T k;
        fin>>k;
        V.push_back(k);
    }
    return V;
}

int main()
{
    vector<int> V;
    int n;
    fin>>n;
    V = readd(n);
}

模板
矢量读取（整数n）
{
向量V；
对于（int i=0；i>k；
V.推回（k）；
}
返回V；
}
int main（）
{
向量V；
int n；
fin>>n；
V=读数d（n）；
}

但我有编译错误

错误：调用

readd（int&）

---

有人能帮我吗…

您正在尝试返回

V

，它只不过是

vector

这样做：

template <class T>
vector<T> readd(int n)
{
    vector<T> V;
    for(int i=0;i<n;i++)
    {
        T k;
        fin>>k;
        V.push_back(k);
    }
    return V;
}

int main()
{
    vector<int> V;
    int n;
    fin>>n;
    //you need to tell the compiler the actual type of T since it is not auto deducible!
    V = readd<int>(n); 
}

模板
矢量读取（整数n）
{
向量V；
对于（int i=0；i>k；
V.推回（k）；
}
返回V；
}
int main（）
{
向量V；
int n；
fin>>n；
//您需要告诉编译器T的实际类型，因为它不是自动推断的！
V=读数d（n）；
}

您正试图返回

V

，它只不过是

向量

这样做：

template <class T>
vector<T> readd(int n)
{
    vector<T> V;
    for(int i=0;i<n;i++)
    {
        T k;
        fin>>k;
        V.push_back(k);
    }
    return V;
}

int main()
{
    vector<int> V;
    int n;
    fin>>n;
    //you need to tell the compiler the actual type of T since it is not auto deducible!
    V = readd<int>(n); 
}

模板
矢量读取（整数n）
{
向量V；
对于（int i=0；i>k；
V.推回（k）；
}
返回V；
}
int main（）
{
向量V；
int n；
fin>>n；
//您需要告诉编译器T的实际类型，因为它不是自动推断的！
V=读数d（n）；
}

您正试图返回

V

，它只不过是

向量

这样做：

template <class T>
vector<T> readd(int n)
{
    vector<T> V;
    for(int i=0;i<n;i++)
    {
        T k;
        fin>>k;
        V.push_back(k);
    }
    return V;
}

int main()
{
    vector<int> V;
    int n;
    fin>>n;
    //you need to tell the compiler the actual type of T since it is not auto deducible!
    V = readd<int>(n); 
}

模板
矢量读取（整数n）
{
向量V；
对于（int i=0；i>k；
V.推回（k）；
}
返回V；
}
int main（）
{
向量V；
int n；
fin>>n；
//您需要告诉编译器T的实际类型，因为它不是自动推断的！
V=读数d（n）；
}

您正试图返回

V

，它只不过是

向量

这样做：

template <class T>
vector<T> readd(int n)
{
    vector<T> V;
    for(int i=0;i<n;i++)
    {
        T k;
        fin>>k;
        V.push_back(k);
    }
    return V;
}

int main()
{
    vector<int> V;
    int n;
    fin>>n;
    //you need to tell the compiler the actual type of T since it is not auto deducible!
    V = readd<int>(n); 
}

模板
矢量读取（整数n）
{
向量V；
对于（int i=0；i>k；
V.推回（k）；
}
返回V；
}
int main（）
{
向量V；
int n；
fin>>n；
//您需要告诉编译器T的实际类型，因为它不是自动推断的！
V=读数d（n）；
}

您正在尝试使用模板参数推断，但为了使其正常工作，编译器需要能够从传递给函数的参数类型中推断出每个模板参数。U不出现在参数列表中，因此编译器无法推断其类型

也就是说，将向量按值传递给此函数没有任何意义，因为您会立即清除它

template <class T>
std::vector<T> readd(int n)
{
    std::vector<T> v;
    v.reserve(k); // prevent unnecessary reallocation
    for (int i = 0; i < n; ++i)
    {
        T k;
        fin >> k;
        v.push_back(k);
    }
    return v;
}

模板
标准：：向量读取（整数n）
{
std：：向量v；
v、 保留（k）；//防止不必要的重新分配
对于（int i=0；i>k；
v、 推回（k）；
}
返回v；
}

然后像这样称呼它

std::vector<int> v = readd<int>(10);

std:：vector v=readd（10）；

您需要指定模板参数，因为编译器无法推导该参数

---

另外，如果fin是一个全局变量，最好将其设置为非全局变量并将其传递给read函数。

您正在尝试使用模板参数推断，但为了实现这一点，编译器需要能够根据传递给函数的参数类型推断出每个模板参数。U不显示在y中我们的参数列表，因此编译器无法推断其类型

也就是说，将向量按值传递给此函数没有任何意义，因为您会立即清除它

template <class T>
std::vector<T> readd(int n)
{
    std::vector<T> v;
    v.reserve(k); // prevent unnecessary reallocation
    for (int i = 0; i < n; ++i)
    {
        T k;
        fin >> k;
        v.push_back(k);
    }
    return v;
}

模板
标准：：向量读取（整数n）
{
std：：向量v；
v、 保留（k）；//防止不必要的重新分配
对于（int i=0；i>k；
v、 推回（k）；
}
返回v；
}

然后像这样称呼它

std::vector<int> v = readd<int>(10);

std:：vector v=readd（10）；

您需要指定模板参数，因为编译器无法推导该参数

---

另外，如果fin是一个全局变量，最好将其设置为非全局变量并将其传递给read函数。

您正在尝试使用模板参数推断，但为了实现这一点，编译器需要能够根据传递给函数的参数类型推断出每个模板参数。U不显示在y中我们的参数列表，因此编译器无法推断其类型

也就是说，将向量按值传递给此函数没有任何意义，因为您会立即清除它

template <class T>
std::vector<T> readd(int n)
{
    std::vector<T> v;
    v.reserve(k); // prevent unnecessary reallocation
    for (int i = 0; i < n; ++i)
    {
        T k;
        fin >> k;
        v.push_back(k);
    }
    return v;
}

模板
标准：：向量读取（整数n）
{
std：：向量v；
v、 保留（k）；//防止不必要的重新分配
对于（int i=0；i>k；
v、 推回（k）；
}
返回v；
}

然后像这样称呼它

std::vector<int> v = readd<int>(10);

std:：vector v=readd（10）；

您需要指定模板参数，因为编译器无法推导该参数

---

另外，如果fin是一个全局变量，最好将其设置为非全局变量并将其传递给read函数。

您正在尝试使用模板参数推断，但为了实现这一点，编译器需要能够根据传递给函数的参数类型推断出每个模板参数。U不显示在y中我们的参数列表，因此编译器无法推断其类型

也就是说，将向量按值传递给此函数没有任何意义，因为您会立即清除它

template <class T>
std::vector<T> readd(int n)
{
    std::vector<T> v;
    v.reserve(k); // prevent unnecessary reallocation
    for (int i = 0; i < n; ++i)
    {
        T k;
        fin >> k;
        v.push_back(k);
    }
    return v;
}

模板
标准：：向量读取（整数n）
{
std：：向量v；
v、 保留（k）；//防止不必要的重新分配
对于（int i=0；i>k；
v、 推回（k）；
}
返回v；
}

然后像这样称呼它

std::vector<int> v = readd<int>(10);

std:：vector v=readd（10）；

您需要指定模板参数，因为编译器无法推导该参数

另外，如果fin是一个全局变量，最好将其设置为非全局变量，并将其传递给read函数。

我需要返回语句