我知道Java或C#似乎太多了。但是,将我自己的类作为函数std::to_string
的输入有效是否可行/好/明智?
例如:
class my_class{
public:
std::string give_me_a_string_of_you() const{
return "I am " + std::to_string(i);
}
int i;
};
void main(){
my_class my_object;
std::cout<< std::to_string(my_object);
}
如果没有这样的东西(我认为那样),最好的办法是什么?
答案 0 :(得分:20)
最好的&#39;是什么?方式是一个悬而未决的问题。
有几种方法。
首先要说的是,为自定义类型重载std::to_string
不允许。对于自定义类型,我们可能只在std
命名空间中专门化模板函数和类,而std::to_string
不是模板函数。
尽管如此,处理to_string
的好方法很像是swap
的运算符或实现。即允许参数依赖查找来完成工作。
因此,当我们想要将某些内容转换为字符串时,我们可以写:
using std::to_string;
auto s = to_string(x) + " : " + to_string(i);
假设x是名称空间Y中的类型X的对象,而我是一个int,我们可以定义:
namespace Y {
std::string to_string(const X& x);
}
现在意味着:
调用to_string(x)
实际上会选择Y::to_string(const Y::X&)
和
调用to_string(i)
选择std::to_string(int)
更进一步,可能是你希望to_string与operator&lt;&lt;相同,所以可以用另一个来编写:
namespace Y {
inline std::ostream& operator<<(std::ostream& os, const X& x) { /* implement here */; return os; }
inline std::string to_string(const X& x) {
std::ostringstream ss;
ss << x;
return ss.str();
}
}
答案 1 :(得分:18)
首先,一些ADL帮助:
namespace notstd {
namespace adl_helper {
using std::to_string;
template<class T>
std::string as_string( T&& t ) {
return to_string( std::forward<T>(t) );
}
}
template<class T>
std::string to_string( T&& t ) {
return adl_helper::as_string(std::forward<T>(t));
}
}
notstd::to_string(blah)
将在to_string(blah)
范围内对std::to_string
进行ADL查找。
然后我们修改你的课程:
class my_class{
public:
friend std::string to_string(my_class const& self) const{
return "I am " + notstd::to_string(self.i);
}
int i;
};
现在notstd::to_string(my_object)
找到了正确的to_string
,notstd::to_string(7)
也是如此。
通过更多工作,我们甚至可以支持.tostring()
种类型的方法,以便自动检测和使用。
答案 2 :(得分:1)
您可以在自己的命名空间中定义自己的to_string
(例如foo
)。
namespace foo {
std::string to_string(my_class const &obj) {
return obj.string give_me_a_string_of_you();
}
}
并将其用作:
int main(){
my_class my_object;
std::cout<< foo::to_string(my_object);
}
不幸的是,你无法在命名空间to_string
中定义自己的std
版本,因为它符合标准 17.6.4.2.1命名空间std [namespace.std] (强调我的):
如果C ++程序添加了声明,则它的行为是未定义的 命名空间std或命名空间std中的命名空间的定义 除非另有说明。程序可以添加模板 专门用于任何标准库模板到命名空间std 如果声明取决于用户定义的类型和 专业化符合标准库的要求 原始模板并未明确禁止。
答案 3 :(得分:1)
这是另一种解决方案。没有必要更优雅或太花哨,但它是一种替代方法。它假定您打算调用to_string的所有类都有一个ToString()函数。
这是一个函数模板,它只适用于类类型的对象,并调用ToString()函数。
template<typename T, typename = std::enable_if_t<std::is_class<T>::value>>
std::string to_string(const T& t) {
return t.ToString();
}
也许我们希望它也能与std :: string一起使用。
template<>
std::string to_string(const std::string& t) {
return t;
}
以下是使用中的代码示例。注意虚拟命名空间to_s。我想如果你在main函数中使用std :: to_string,它会触发我们的模板函数名,所以我们必须像这样间接引入这个名字。如果有人知道这样做的正确方法,我将不胜感激。
#include <cstring>
#include <iostream>
#include <string>
#include <type_traits>
union U {
double d;
const char* cp;
};
struct A {
enum State { kString, kDouble };
State state;
U u;
void Set(const char* cp) {
u.cp = cp;
state = kString;
}
std::string ToString() const {
switch (state) {
case A::kString : return std::string(u.cp); break;
case A::kDouble : return std::to_string(u.d); break;
default : return "Invalid State";
}
}
};
namespace to_s { using std::to_string; };
int main() {
using namespace to_s;
std::string str = "a nice string";
double d = 1.1;
A a { A::kDouble, {1.2} };
std::cout << "str: " << to_string(str) << ", d: " << to_string(d) << std::endl;
std::cout << "a: " << to_string(a) << std::endl;
a.Set(str.c_str());
std::cout << "a: " << to_string(a) << std::endl;
std::memset(&a, 'i', sizeof(a));
std::cout << "a: " << to_string(a) << std::endl;
}
这是我得到的:
str:一个很好的字符串,d:1.100000
a:1.200000
a:一个很好的字符串
a:无效状态
答案 4 :(得分:1)
这已经有了不错的答案,但是我想提出一个替代方案,欢迎反馈。
如果您对to_string函数名称的设置没有固定要求,则可以实现自己的ToString自由函数模板,其中包含对to_string支持的类型的专门化:
template<class T>
std::string ToString(const T& t)
{
std::ostringstream stream;
const uint8_t* pointer = &t;
for(size_t i=0;i<sizeof(T);++i)
{
stream << "0x" << std::hex << pointer[i];
}
return stream.str();
}
template<> std::string ToString(const int& t) { return std::to_string(t); }
template<> std::string ToString(const long& t) { return std::to_string(t); }
template<> std::string ToString(const long long& t) { return std::to_string(t); }
template<> std::string ToString(const unsigned& t) { return std::to_string(t); }
template<> std::string ToString(const unsigned long& t) { return std::to_string(t); }
template<> std::string ToString(const unsigned long long& t) { return std::to_string(t); }
template<> std::string ToString(const float& t) { return std::to_string(t); }
template<> std::string ToString(const double& t) { return std::to_string(t); }
此处的默认实现返回一个十六进制值的字符串,该字符串的值在存储空间中用于传递的类引用的值,而专业化调用std :: to_string,这将使任何类“可字符串化”。
然后,您只需要为您的课程实现自己的专业化即可:
template<> std::string ToString(const my_class& t) { return "I am " + std::to_string(t.i); }
答案 5 :(得分:0)
您可能只想重载operator<<()
之类的内容:
std::ostream& operator << ( std::ostream& os, const my_class& rhs ) {
os << "I am " << rhs.i;
return os;
}
可替换地:
std::ostream& operator << ( std::ostream& os, const my_class& rhs ) {
os << rhs.print_a_string();
return os;
}
然后你就可以做到:
int main() {
my_class my_object;
std::cout << my_object;
return 0;
}
答案 6 :(得分:0)
您无法将to_string
的新重载添加到std
命名空间中,但您可以在命名空间中执行此操作:
namespace my {
using std::to_string;
std::string to_string(const my_class& o) {
return o.give_me_a_string_of_you();
}
}
然后您可以对所有类型使用my::to_string
。
int main()
{
my_class my_object;
std::cout << my::to_string(my_object);
std::cout << my::to_string(5);
}