C++ 插入运算符重载 (<<)
C++ Insertion operator overload (<<)
我正在完成一项作业,在该作业中我必须重载插入运算符以获取 Node 对象。我在 class 定义之外但在 node.h 文件内创建了运算符重载函数。一切都编译得很好,但是没有调用重载运算符,而是我得到了简单的对象地址。
我被禁止修改调用代码,所以任何更改都必须是运算符重载。
我现在的代码:
/** OPERATOR << ***********************************/
template<class T>
inline std::ostream & operator << (std::ostream & out, const Node <T> *& pHead)
{
out << "INCOMPLETE";
return out;
}
现在,我只想确保重载的运算符被调用。一旦我知道我正在调用正确的操作员,我将修复输出代码。
调用代码:
// create
Node <char> * n = NULL;
// code modifying n
// display
cout << "\t{ " << n << " }\n";
问题是插入器接受了一个const Node<T>*
类型的参数,但它是用Node<T>*
类型的参数调用的;没有从 T*
到 const T*
的转换。所以 "fix" 是从流插入器中删除 const
。
但是,正如评论中所暗示的那样,拥有一个接受类型指针的插入器并不是一个好主意。它应该像世界上所有其他插入器一样需要 const Node<T>&
。我认为这是一项任务施加的约束;如果是这样,那就太愚蠢了。你被教坏了。
注意参数pHead
的类型是对非常量的引用,const Node<T>*
是指向const的非常量指针,参数n
的类型是Node<T>*
(即指向非常量的非常量指针)。它们的类型不匹配,Node<T>*
需要转换为 const Node<T>*
,这是一个临时的,不能绑定到对非常量的引用。
简而言之,您不能将对非常量的引用绑定到具有不同类型的对象。
但对 const 的引用可以绑定到临时的,因此您可以将参数类型更改为对 const 的引用:
template<class T>
inline std::ostream & operator << (std::ostream & out, const Node <T> * const & pHead)
// ~~~~~
或者改为按值传递,Node<T>*
作为参数传递时会隐式转换为const Node<T>*
。 (通过对 const 的引用传递指针没有多大意义。)
template<class T>
inline std::ostream & operator << (std::ostream & out, const Node <T> * pHead)
最后,用指针类型重载 operator<<
看起来很奇怪。具有用户定义类型的最常见形式是:
template<class T>
std::ostream & operator << (std::ostream & out, const Node <T> & pHead)
我正在完成一项作业,在该作业中我必须重载插入运算符以获取 Node 对象。我在 class 定义之外但在 node.h 文件内创建了运算符重载函数。一切都编译得很好,但是没有调用重载运算符,而是我得到了简单的对象地址。
我被禁止修改调用代码,所以任何更改都必须是运算符重载。
我现在的代码:
/** OPERATOR << ***********************************/
template<class T>
inline std::ostream & operator << (std::ostream & out, const Node <T> *& pHead)
{
out << "INCOMPLETE";
return out;
}
现在,我只想确保重载的运算符被调用。一旦我知道我正在调用正确的操作员,我将修复输出代码。
调用代码:
// create
Node <char> * n = NULL;
// code modifying n
// display
cout << "\t{ " << n << " }\n";
问题是插入器接受了一个const Node<T>*
类型的参数,但它是用Node<T>*
类型的参数调用的;没有从 T*
到 const T*
的转换。所以 "fix" 是从流插入器中删除 const
。
但是,正如评论中所暗示的那样,拥有一个接受类型指针的插入器并不是一个好主意。它应该像世界上所有其他插入器一样需要 const Node<T>&
。我认为这是一项任务施加的约束;如果是这样,那就太愚蠢了。你被教坏了。
注意参数pHead
的类型是对非常量的引用,const Node<T>*
是指向const的非常量指针,参数n
的类型是Node<T>*
(即指向非常量的非常量指针)。它们的类型不匹配,Node<T>*
需要转换为 const Node<T>*
,这是一个临时的,不能绑定到对非常量的引用。
简而言之,您不能将对非常量的引用绑定到具有不同类型的对象。
但对 const 的引用可以绑定到临时的,因此您可以将参数类型更改为对 const 的引用:
template<class T>
inline std::ostream & operator << (std::ostream & out, const Node <T> * const & pHead)
// ~~~~~
或者改为按值传递,Node<T>*
作为参数传递时会隐式转换为const Node<T>*
。 (通过对 const 的引用传递指针没有多大意义。)
template<class T>
inline std::ostream & operator << (std::ostream & out, const Node <T> * pHead)
最后,用指针类型重载 operator<<
看起来很奇怪。具有用户定义类型的最常见形式是:
template<class T>
std::ostream & operator << (std::ostream & out, const Node <T> & pHead)