shared_ptr and && operator
Hey guys, Just wondering what happens if I do this: boost::shared_ptr<Foo> foo; boost::shared_ptr<Bar> bar; if( foo && bar ) { // Do stuff if both pointers are valid... } I did not see an overloaded && operator in the interface of the class. When using normal pointer semantics, this code is valid through implicit conversion of a pointer value to a boolean type.
On Mon, Jun 8, 2009 at 2:01 PM, Robert Dailey<rcdailey@gmail.com> wrote:
Hey guys, Just wondering what happens if I do this: boost::shared_ptr<Foo> foo; boost::shared_ptr<Bar> bar; if( foo && bar ) { // Do stuff if both pointers are valid... } I did not see an overloaded && operator in the interface of the class. When using normal pointer semantics, this code is valid through implicit conversion of a pointer value to a boolean type.
Since boost::shared_ptr implements the safe_bool idiom, each shared pointer will use the safe_bool conversion, the result of which will implicitly convert to a bool. The normal short-circuiting logic should apply. --DD
AMDG Robert Dailey wrote:
Just wondering what happens if I do this:
boost::shared_ptr<Foo> foo; boost::shared_ptr<Bar> bar; if( foo && bar ) { // Do stuff if both pointers are valid... }
I did not see an overloaded && operator in the interface of the class. When using normal pointer semantics, this code is valid through implicit conversion of a pointer value to a boolean type.
The same applies to shared_ptr. http://www.boost.org/libs/smart_ptr/shared_ptr.htm#conversions In Christ, Steven Watanabe
On Mon, Jun 8, 2009 at 2:16 PM, Steven Watanabe <watanabesj@gmail.com>wrote:
AMDG
Robert Dailey wrote:
Just wondering what happens if I do this:
boost::shared_ptr<Foo> foo; boost::shared_ptr<Bar> bar; if( foo && bar ) { // Do stuff if both pointers are valid... }
I did not see an overloaded && operator in the interface of the class. When using normal pointer semantics, this code is valid through implicit conversion of a pointer value to a boolean type.
The same applies to shared_ptr. http://www.boost.org/libs/smart_ptr/shared_ptr.htm#conversions
Thanks. I figured this was the case but I guess I was just having trouble finding the header file in which this casting operator is implemented. I appreciate the answers to my embarrassingly obvious question.
Robert Dailey wrote:
On Mon, Jun 8, 2009 at 2:16 PM, Steven Watanabe <watanabesj@gmail.com <mailto:watanabesj@gmail.com>> wrote:
AMDG
Robert Dailey wrote:
Just wondering what happens if I do this:
boost::shared_ptr<Foo> foo; boost::shared_ptr<Bar> bar; if( foo && bar ) { // Do stuff if both pointers are valid... }
I did not see an overloaded && operator in the interface of the class. When using normal pointer semantics, this code is valid through implicit conversion of a pointer value to a boolean type.
The same applies to shared_ptr. http://www.boost.org/libs/smart_ptr/shared_ptr.htm#conversions
Thanks. I figured this was the case but I guess I was just having trouble finding the header file in which this casting operator is implemented. I appreciate the answers to my embarrassingly obvious question.
------------------------------------------------------------------------
_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users
Here's a short explanation why you won't find operators && or || overloaded very often: http://blog.emptycrate.com/node/363 For a more thorough explanation, see chapter 7 in More Effective C++.
On Mon, Jun 8, 2009 at 6:19 PM, Kenny Riddile <kfriddile@yahoo.com> wrote:
Robert Dailey wrote:
On Mon, Jun 8, 2009 at 2:16 PM, Steven Watanabe <watanabesj@gmail.com<mailto: watanabesj@gmail.com>> wrote:
AMDG
Robert Dailey wrote:
Just wondering what happens if I do this:
boost::shared_ptr<Foo> foo; boost::shared_ptr<Bar> bar; if( foo && bar ) { // Do stuff if both pointers are valid... }
I did not see an overloaded && operator in the interface of the class. When using normal pointer semantics, this code is valid through implicit conversion of a pointer value to a boolean type.
The same applies to shared_ptr. http://www.boost.org/libs/smart_ptr/shared_ptr.htm#conversions
Thanks. I figured this was the case but I guess I was just having trouble finding the header file in which this casting operator is implemented. I appreciate the answers to my embarrassingly obvious question.
------------------------------------------------------------------------
_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users
Here's a short explanation why you won't find operators && or || overloaded very often:
http://blog.emptycrate.com/node/363
For a more thorough explanation, see chapter 7 in More Effective C++.
Thanks Kenny, I'm already aware of this though. The reason why I ask is because I have to work on a code base that insists on overloading such operators, and I'm investigating ways of cleaning it up. The code in question has no regard for short circuiting since they are already using overloaded && and || semantics. I appreciate everyone's help.
participants (4)
-
Dominique Devienne -
Kenny Riddile -
Robert Dailey -
Steven Watanabe