让我们考虑以下隐式类型转换的工作原理和不工作的示例:
#include <iostream>
#include <vector>
struct Thingy
{
void write()
{
std::cout << "x" << std::endl;
}
};
struct Node
{
Thingy a;
int data;
operator Thingy&(){return a;}
};
void f(Thingy thingy)
{
thingy.write();
}
template <typename TIterator>
void f (TIterator begin, TIterator end)
{
for (TIterator it = begin; it != end; ++it)
it->write();
}
int main()
{
std::vector<Node> vector(10);
f(vector.begin(), vector.end()); // Doesn't compile
f(vector[3]); // compiles
vector[3].write(); // Doesn't compile
return 0;
}
为什么会这样?该
void Node::write();
不应该从根本上区别于:
void write(Node* this);
有没有办法让我的示例代码编译并运行?
编辑:
我理解为什么它不起作用的机制,我想理解这个哲学.为什么C标准委员会认为这是一个坏主意?
最佳答案 它不起作用,因为你在做的时候从不要求编译器进行转换:
it->write();
我想它应该与static_cast一起使用:
static_cast<Thingy&>(*it).write();
但我几乎不确定你应该使用:
it->get_a().write();
或者更好,正如其他人所说,在Node中声明一个方法写入.
隐含的转换可能是邪恶的.
因为你不能改变f函数,你应该只包装迭代器,这样它就可以取消引用Thingy而不是Node,如果你可以使用Boost:
#include <iostream>
#include <vector>
#include <boost/iterator/transform_iterator.hpp>
struct Thingy
{
void write()
{
std::cout << "x" << std::endl;
}
};
struct Node
{
Thingy a;
int data;
operator Thingy&(){return a;}
};
void f(Thingy thingy)
{
thingy.write();
}
template <typename TIterator>
void f (TIterator begin, TIterator end)
{
for (TIterator it = begin; it != end; ++it)
it->write();
}
struct Node2Thingy
{
typedef Thingy& result_type;
Thingy& operator()(Node& n) const { return n.a; }
};
int main()
{
std::vector<Node> vector(10);
f(boost::make_transform_iterator(vector.begin(), Node2Thingy()),
boost::make_transform_iterator(vector.end(), Node2Thingy()));
f(vector[3]); // compiles
return 0;
}
在g 4.8.1上工作(但肯定也在旧版本上).
您试图通过添加“隐式”间接来解决您的问题,但在这种情况下,它无法工作.您可以通过添加显式间接来解决它.
为了回答你的问题,现场背后没有哲学.它纯粹是机械的,在编译时解析的C使用类型因此在执行时间之前所有类型都有它的类型.您希望编译器如何猜测必须在Node上调用转换运算符.