0

I would like std::ostringstream to modify the string I pass it:

#include <string> #include <iostream> #include <sstream> void My_Function(std::string& error_message) { std::ostringstream error_stream(error_message); // For Nipun Talukdar: /* Perform some operations */ if (/* operation failed */) { error_stream << "Failure at line: " << __LINE__ << ", in source file: " << __FILE__ << "\n"; } return; } int main(void) { std::string error_message; My_Function(error_message); std::cout << "Error is: \"" << error_message << "\"\n"; return 0; }

With the above code, the output of error_message is empty.

This is because, according to cppreference.com, the constructor of std::basic_ostream that takes a std::stream takes a const reference to a std::string. This means that std::basic_ostringstream does not modify the string passed to it. The cited reference even says that std::ostringstream makes a copy of the string passed to it.

To get around this, I changed my function: 

void My_Second_Function(std::string& error_message) { std::ostringstream error_stream; error_stream << "Failure at line: " << __LINE__ << "\n"; error_message = error_stream.str(); // This is not efficient, making a copy! return; }

Is there a more efficient method to perform formatted output to a string, such as a direct write (i.e. without have to copy from the stream)?

I'm using Visual Studio 2010, which does not support C++11. Due to shop considerations, the justification of upgrading to 2013 did not pass. So I can't use C++11 or C++14 features.

Improve this question
10
  • Use a stream buffer and set put pointers accordingly. Commented Mar 12, 2015 at 18:11
  • 2
    Not related to the question, but won't it print the same line number always? Commented Mar 12, 2015 at 18:12
  • @NipunTalukdar: The __LINE__ macro returns the line number in the source code. The line number may change if code is inserted or removed before location of the __LINE__ macro. Commented Mar 12, 2015 at 18:14
  • 1
    @0x499602D2: Please provide an answer containing an example of your comment. Thanks. Commented Mar 12, 2015 at 18:15
  • 1
    @ThomasMatthews Yes. But it will always print the same line number in My_Function. So, each call to My_Function will output the same line number. Commented Mar 12, 2015 at 18:30

1 Answer 1

Reset to default
1

Use a stream buffer and set the put pointers to the string's internal data:

struct nocopy : std::streambuf { nocopy(std::string& str) { this->setp(&str[0], &str[0] + str.size()); } }; struct nocopy_stream : virtual private nocopy, std::ostream { nocopy_stream(std::string& str) : nocopy(str) , std::ostream(this) { } }; void My_Function(std::string& error_message) { nocopy_stream error_stream(error_message); error_stream << "Failure at line: " << __LINE__ << "\n"; } int main(void) { std::string error_message; error_message.resize(1000); My_Function(error_message); std::cout << "Error is: \"" << error_message << "\"\n"; }

For this example error_message has to be set to a large enough size as we do not override overflow() and the base class version does nothing. You can override it to do the correct resizing however.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

There's a lot more to it than that. Your streambuf doesn't change the size of string it's given; if you output more, then there will just be an output error, and if you output less, there will be a lot of junk at the end. (Of course, the whole question is specious. Any way you do it, there's bound to be some copying; on the other hand, the cost of copying should be negligible, compared to everything else.)
@JamesKanze Of course it's more work than this. Maybe you can give a sufficient answer?
@JamesKanze, @0x499602D2: So, why does ostringstream make a copy of the string you pass it?
@ThomasMatthews: That's actually a really good question. R.Sahu suggests it's for appending, but I think it's mere oversight.
@ThomasMatthews Because that's what it is defined to do. The underlying reason is that std::stringbuf doesn't know whether it is to be used for input or output; if for input, it reads from the string you gave it. A more logical solution might have been to not have an std::stringstream class at all, and to have two different string buffers, one for input and one for output. The philosophy of the IO streams, however, has always been to support bidirectional streams, Even if we now know that they are of limited use.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.