Function that prints something to std::ostream and returns std::ostream?
Solution 1
You can't fix the function. Nothing in the spec requires a compiler to evaluate a function call in an expression in any particular order with respect to some unrelated operator in the same expression. So without changing the calling code, you can't make MyPrint()
evaluate after std::cout << "Value: "
Left-to-right order is mandated for expressions consisting of multiple consecutive << operators, so that will work. The point of operator<< returning the stream is that when operators are chained, the LHS of each one is supplied by the evaluation of the operator to its left.
You can't achieve the same thing with free function calls because they don't have a LHS. MyPrint()
returns an object equal to std::cout
, and so does std::cout << "Value: "
, so you're effectively doing std::cout << std::cout
, which is printing that hex value.
Since the desired output is:
Value: 12
the "right" thing to do is indeed to override operator<<. This frequently means you need to either make it a friend, or do this:
class WhateverItIsYouReallyWantToPrint {
public:
void print(ostream &out) const {
// do whatever
}
};
ostream &operator<<(ostream &out, const WhateverItIsYouReallyWantToPrint &obj) {
obj.print(out);
}
If overriding operator<<
for your class isn't appropriate, for example because there are multiple formats that you might want to print, and you want to write a different function for each one, then you should either give up on the idea of operator chaining and just call the function, or else write multiple classes that take your object as a constructor parameter, each with different operator overloads.
Solution 2
You want to make MyPrint a class with friend operator<<:
class MyPrint
{
public:
MyPrint(int val) : val_(val) {}
friend std::ostream& operator<<(std::ostream& os, const MyPrint& mp)
{
os << mp.val_;
return os;
}
private:
int val_;
};
int main(int argc, char** argv)
{
std::cout << "Value: " << MyPrint(12) << std::endl;
return 0;
}
This method requires you to insert the MyPrint object into the stream of your choice. If you REALLY need the ability to change which stream is active, you can do this:
class MyPrint
{
public:
MyPrint(int val, std::ostream& os) : val_(val), os_(os) {}
friend std::ostream& operator<<(std::ostream& dummy, const MyPrint& mp)
{
mp.os_ << mp.val_;
return os_;
}
private:
int val_;
std::ostream& os_
};
int main(int argc, char** argv)
{
std::cout << "Value: " << MyPrint(12, std::cout) << std::endl;
return 0;
}
Solution 3
You have two options. The first, using what you already have is:
std::cout << "Value: ";
MyPrint(12, &std::cout);
std::cout << std::endl;
The other, which is more C++-like, is to replace MyPrint()
with the appropriate std::ostream& operator<<
. There's already one for int
, so I'll do one just a tad more complex:
#include <iostream>
struct X {
int y;
};
// I'm not bothering passing X as a reference, because it's a
// small object
std::ostream& operator<<(std::ostream& os, const X x)
{
return os << x.y;
}
int main()
{
X x;
x.y = 5;
std::cout << x << std::endl;
}
Solution 4
There's no way to do what you're expecting there because of the order the functions are evaluated in.
Is there any particular reason you need to write directly to the ostream like that? If not, just have MyPrint return a string. If you want to use a stream inside MyPrint to generate the output, just use a strstream and return the result.
Frank
Updated on April 08, 2020Comments
-
Frank over 3 years
I want to write a function that outputs something to a
ostream
that's passed in, and return the stream, like this:std::ostream& MyPrint(int val, std::ostream* out) { *out << val; return *out; } int main(int argc, char** argv){ std::cout << "Value: " << MyPrint(12, &std::cout) << std::endl; return 0; }
It would be convenient to print the value like this and embed the function call in the output operator chain, like I did in
main()
.It doesn't work, however, and prints this:
$ ./a.out 12Value: 0x6013a8
The desired output would be this:
Value: 12
How can I fix this? Do I have to define an
operator<<
instead?UPDATE: Clarified what the desired output would be.
UPDATE2: Some people didn't understand why I would print a number like that, using a function instead of printing it directly. This is a simplified example, and in reality the function prints a complex object rather than an
int
.-
Admin over 14 yearsWhy are you passing the stream via a pointer rather than via areference?
-
Steve Jessop over 14 yearsMaybe he's read the Google style guide, and bought into this "don't use non-const reference parameters" fashion that's going around.
-
Frank over 14 years@Neil and @onebyone: Yes, I started using the google style conventions.
-
Frank over 14 years@litb: Just printing '12' was just a toy example. In reality, I don't pass an int, but a more complicated data structure that has to be printed to the stream.
-
Seth Johnson over 14 yearsRe: UPDATE2 -- To print this complex object of yours, why not just define a new overloaded std::operator<< for that type, just like every other normal class uses?
-
-
Admin over 14 yearsExcept that this does not do what was asked for.
-
Admin over 14 yearsWell, to start with, it doesn't compile.
-
Steve Jessop over 14 years"there is no reason not to pass in the ostream by reference". Some folks don't like non-const reference parameters. I disagree with them, but I wouldn't say there is "no reason" for their preference.
-
Drew Delano over 14 yearsI don't see how a non-const pointer would be preferable to a non-const reference in any sane coding standard.
-
rlbond over 14 yearsOops. Bad copy/paste. Thanks for catching.
-
Steve Jessop over 14 yearsGoogle says "References can be confusing, as they have value syntax but pointer semantics" (google-styleguide.googlecode.com/svn/trunk/…). I think they mean that pass-by-value and pass-by-reference look the same at the call site, so they think code is more readable if readers can assume that anything which looks like a pass-by-value, leaves the value unmodified. And as the saying goes, Google is insane like a fox. It does have some slightly old-fashioned attitudes to C++, but I think not irrational.
-
Max Lybbert over 14 yearsIt doesn't have to be a friend; it only uses public methods of the std::ostream.
-
Troubadour over 14 yearsI know I always find it easier to break streams down into traditional function calls when I can't get my head around something so I thought I'd add this for the OP in case it helps them too. Hope you don't mind. I think I'm right in saying the std::cout line basically boils down to cout.operator<<( "Value: " ).operator<<( MyPrint(12, &std::cout ) ).operator<<( std::endl ); which might be an easier way of visualising what this answer says.
-
Seth Johnson over 14 yearsThe standard
operator<<
notation takes thestd::ostream
by reference as an input; since this guy is attempting to emulate ostream's functionality, it would be better to match the syntax rather than passing a reference. Plus, he's returning a reference to the dereferenced pointer! If you used a pointer, you would have to call something likeMyPrint(12, &(std::cout << "Value:") );
which is just awkward. You're passing a pointer to a temporary object. -
Martin York over 14 yearsMake it a template class and add a template function to create it and its perfect.
-
Steve Jessop over 14 years"The standard operator<< notation takes the std::ostream by reference as an input". Yes, Google notes "necessary for some applications" as a "Con" of their "no non-const reference" rule. This is among the reasons I disagree with the rule: it's a pretty killer "Con" :-)
-
Admin over 14 yearsUnlike many people round here, I don't have the happy facility of understanding the "obvious" unasked question - I like to have things spelled out.
-
Frank over 14 yearsI updated the question; it says now that the desired output would be Value: 12.
-
Frank over 14 years@Max Lybbert: It does access a private member variable?
-
iain over 14 yearsThis is exactly how I would have answered this question
-
Max Lybbert over 14 yearsSorry, "it only uses public methods of the std::ostream, so it doesn't need to be a friend of the std::ostream; since it's a method of MyPrint it already has access to private methods and variables of MyPrint and doesn't need to be a friend of MyPrint either (plus a class can't be a friend of itself)."
-
Johannes Schaub - litb over 14 years@Max Lybbert. 1) What do you mean by "method"? 2) The function
operator<<
in his code is not a member of the class. Removing the friend keyword would make it a member, but would make the code invalid, because a memberoperator<<
must have one parameter only. It's called a "friend definition". -
Johannes Schaub - litb over 14 yearsI've put some explanation here: stackoverflow.com/questions/991518/…
-
Max Lybbert over 14 yearsThanks for the correction. As you can see from my answer, I've generally defined these as non-member functions.
-
Admin over 14 yearsIf you can find me one, I'll happily use it.
-
Dmitry Volosnykh over 5 years@SteveJessop You've probably forgotten to put
return
statement at the end ofoperator<<
implementation:return out;
.