C++ 如何使用模板类型的向量？

我想要两个模板结构，用于将任何变量类型转换为

std:：strings

当第一个编译时，第二个不会编译，在

vector:：iterator语句中。编者说：

错误：应为“；”表达式之后

vector:：迭代器i=data.begin（）

知道我做错了什么吗？有没有更好的方法来实现我在这里的目标

template <typename Variant>
struct to_string
{
private:
    Variant data;

public:
    to_string(Variant &d) : data(d) {}
    operator std::string() const
    {
        try
        {
            return boost::lexical_cast<std::string>(data);
        }
        catch (const boost::bad_lexical_cast &)
        {
            return std::string();
        }
    }

};

template <typename Variant>
struct to_string_vector
{
private:
    vector<Variant> data;
public:
    to_string_vector(vector<Variant> &d) : data(d) {}
    operator vector<std::string> () const
    {
        vector<string> ret;
        vector<Variant>::iterator i = data.begin();
        to_string t_s<Variant> s = to_string<Variant>(*i);
        ret.push_back((string)s);
        return ret;
    }
};

模板
结构到字符串
{
私人：
变量数据；
公众：
to_字符串（Variant&d）：数据（d）{
运算符std:：string（）常量
{
尝试
{
返回boost：：词法转换（数据）；
}
catch（const boost:：bad_lexical_cast&）
{
返回std:：string（）；
}
}
};
样板
结构到字符串向量
{
私人：
矢量数据；
公众：
to_string_vector（vector&d）：数据（d）{
运算符向量（）常数
{
向量ret；
向量：：迭代器i=data.begin（）；
to_字符串t_s=to_字符串（*i）；
重新推后（（字符串）s）；
返回ret；
}
};
您需要

typename vector<Variant>::iterator

typename向量：：迭代器

当访问在模板化类型范围内定义的子类或typedef时，编译器会感到困惑，需要帮助将它们标识为类型

编辑：（我的完整程序，修复了一些常量…注释掉了boost部分，因为我现在没有boost可访问性…并添加了代码来实例化模板）

#包括
#包括
#包括
使用名称空间std；
样板
结构到字符串
{
私人：
变量数据；
公众：
to_字符串（const Variant&d）：数据（d）{
运算符std:：string（）常量
{
//试一试
//{
//返回boost：：词法转换（数据）；
//}
//catch（const boost:：bad_lexical_cast&）
//{
返回std:：string（）；
//}
}
};
样板
结构到字符串向量
{
私人：
矢量数据；
公众：
to_string_vector（const vector&d）：数据（d）{
运算符向量（）常数
{
向量ret；
typename向量：：const_迭代器i=data.begin（）；
to_字符串s=to_字符串（*i）；
重新推后（（字符串）s）；
返回ret；
}
};
int main（int argc，字符**argv）{
至字符串a（10）；
字符串sa=（字符串）a；
向量v；
到字符串向量b（v）；
向量sb=（向量）b；
}
您需要

typename vector<Variant>::iterator

typename向量：：迭代器

当访问在模板化类型范围内定义的子类或typedef时，编译器会感到困惑，需要帮助将它们标识为类型

编辑：（我的完整程序，修复了一些常量…注释掉了boost部分，因为我现在没有boost可访问性…并添加了代码来实例化模板）

#包括
#包括
#包括
使用名称空间std；
样板
结构到字符串
{
私人：
变量数据；
公众：
to_字符串（const Variant&d）：数据（d）{
运算符std:：string（）常量
{
//试一试
//{
//返回boost：：词法转换（数据）；
//}
//catch（const boost:：bad_lexical_cast&）
//{
返回std:：string（）；
//}
}
};
样板
结构到字符串向量
{
私人：
矢量数据；
公众：
to_string_vector（const vector&d）：数据（d）{
运算符向量（）常数
{
向量ret；
typename向量：：const_迭代器i=data.begin（）；
to_字符串s=to_字符串（*i）；
重新推后（（字符串）s）；
返回ret；
}
};
int main（int argc，字符**argv）{
至字符串a（10）；
字符串sa=（字符串）a；
向量v；
到字符串向量b（v）；
向量sb=（向量）b；
}

而第一个是编译

我对此不太确定。只要您的其他代码使用模板生成的代码，它就会被遵守

在这两种结构中，您都是从常量声明函数访问非常量变量成员。要么从函数中删除const关键字，要么需要将mutable关键字添加到变量中

而第一个是编译

我对此不太确定。只要您的其他代码使用模板生成的代码，它就会被遵守

在这两种结构中，您都是从常量声明函数访问非常量变量成员。要么从函数中删除const关键字，要么需要将可变关键字添加到变量中。
Change vector:：iterator i=data.begin（）；到

typename向量：：迭代器i=data.begin（）

请看一下Change vector:：iterator i=data.begin（）；到

typename向量：：迭代器i=data.begin（）

请看一下
在这方面的扩展；如果没有
typename
，编译器会假定
vector:：iterator
是一个变量名，因此会显示错误消息。毕竟，您可以使用
vector
的专门化调用此模板，其中有一个名为
iterator
的变量。这些规则的设计使得编译器可以对模板进行一些检查，甚至可能是部分编译，而不知道模板将使用哪些类型进行实例化。非常感谢您的回复和修复！：-）如果你有一个更优雅或通用的方法来做同样的事情，请张贴：）在此扩展；如果没有
typename
，编译器会假定
vector:：iterator
是一个变量名，因此会显示错误消息。毕竟，您可以使用
vector
的专门化调用此模板，其中有一个名为
iterator
的变量。这些规则的设计使得编译器可以对模板进行一些检查，甚至可能是部分编译，而不知道模板将使用哪些类型进行实例化。非常感谢您的回复和修复！：-）如果你有一个更优雅或通用的方法来做同样的事情，请张贴：）只是孤立地看“第一个”，而常量