Return to Question

Based on this answer, I wrote a quick and dirty workaround:

Based on this answer, I wrote a quick and dirty workaround:

I have a lot of code where I need to format a string that looks something like this:

void Function (const std::string &strFile, const int n)
{
    std::string s1 ;
    std::string s2 ;
    
    // Do stuff with s1 and s2...
    
    if (condition == false) {
        std::stringstream ss ;
        ss << "Condition was false." "File: " << strFile << ", N = " << n << "." ;
        Function2 (s1, s2, ss.str ()) ;
    }
    
    // ...
}

The part I don't like is the:

std::stringstream ss ;
ss << "Condition was false." "File: " << strFile << ", N = " << n << "." ;

I would like to do something like:

void ReportError (const std::string strError) ;

// In some function:
int last_error = //...
ReportError ((std::stringstream () << "Error Number: " << last_error).str ()) ;

But that doesn't work for std::stringstream (at least it doesn't work on my compiler (Visual Studio 2008)).

Based on this answer, I wrote a quick and dirty workaround:

#include <string>
#include <sstream>

template <typename StringStreamT = std::stringstream, typename StringT = std::string>
class QuickStringStream
{
public:
    typedef StringStreamT stringstream_type ;
    typedef StringT string_type ;
 
    QuickStringStream () {}
    QuickStringStream (const string_type strData) {
        ss_ << strData ;
    }

    template <typename T>
    QuickStringStream& operator<< (const T &tVal) {
        ss_ << tVal ;
        return *this ;
    }

    string_type str () const
    {
        return ss_.str () ;
    }
 
private:
    stringstream_type ss_ ;
};

Now, I can do stuff like this:

#include <iostream>

void println (std::string &s)
{
    std::cout << s << "\n" ;
}

int main (void)
{
    std::string s = (
        QuickStringStream <> () << "Hello, " << 5 << " + " << 5 << " = " << 10 << "."
    ).str () ;

    std::string strPath = "C:\\Stuff\\info.txt" ;

    println ((
        QuickStringStream <> () << "The path " << strPath << " is invalid. "
    ).str ()) ;
    
    println ((
        QuickStringStream <> ("Error number: ") << 53 << "."
    ).str ()) ;

    return 0 ;
}

This does what I want, but I can't get rid of the feeling I have that this is a horrible idea.

For this project, I do not have access to Boost or C++11.

Note: I updated the question's description to clarify what I am doing. I have not changed the code though, so no answer has been invalidated.

I have to deal with functions that return error codes.
When one of these functions fails in exceptional cases, I would like to construct an error message and throw a custom exception. Constructing an error message is rather cumbersome though because different functions in different contexts have varying information that would be useful to pass.

An example would be:

Let's say I'm trying to read data from an XML file and this is my interface:

// In header file

struct FooData
{
    std::string strName ;
    std::vector <int> vecScores ;
};

struct FooDataException : public std::runtime_error
{
    FooDataException (const std::string &strWhat) : std::runtime_error (strWhat) {} 
}

class FooDataLoader
{
public:
    FooDataLoader () ;
    ~FooDataLoader () ;

    std::vector <FooData> LoadFooData (const std::string &strPath) const ;
};

In my implementation file, I have two functions that help construct error messages to throw:

static void ThrowFunctionFailure (
    const std::string &strWhere,  
    const std::string &strFunction, 
    const std::string &strMessage)
{
    std::stringstream ss ;
     
    ss << "In " << strWhere  
        << ", " << strFunction << "failed. "
        << strMessage ;
         
    throw FooDataException (ss.str ()) ;
}

static void ThrowError (const std::string &strWhere, const std::string &strMessage)
{
    std::stringstream ss ;
    ss << "In " << strWhere << ", an error occurred. " << strMessage ;
    throw FooDataException (ss.str ()) ;
}

Now, these functions remove a lot of code duplication, but I still have to construct an error message at the site:

FooDataLoader::FooDataLoader ()
{
    const HRESULT hr = ::CoInitialize (NULL) ;

    if (FAILED (hr)) {
        std::stringstream ss ;
        ss << "HRESULT: " << hr << "." ;
        throw ThrowFunctionFailure (
            "FooDataLoader::FooDataLoader ()",  
            "::CoInitialize ()",
            ss.str ()
        ) ;
    }
}

FooDataLoader::~FooDataLoader ()
{
    ::CoUninitialize () ;
}

std::vector <FooData> FooDataLoader::LoadFooData (const std::string &strPath) const
{
    if (FileExist (strPath) == false) {
        std::stringstream ss ;
        ss << "The file, " << strPath << ", does not exist." ;
        ThrowError ("FooDataLoader::LoadFooData ()", ss.str ()) ;
    }
    
    // Some xml library I have to use.
    XmlReader xml ;
    if (xml.read (strPath.data ()) == -1) {
        std::stringstream ss ;
        ss << "File: " << strPath << "." ;
        ThrowFunctionFailure (
            "FooDataLoader::LoadFooData ()", 
            "XmlReader::read ()", 
            ss.str ()
        ) ;  
    }
    
    // More stuff...
}

I would like to do something like:

ThrowFunctionFailure (
    "FooDataLoader::LoadFooData ()", 
    "XmlReader::read ()", 
    (std::stringstream () << "File: " << strPath << ".").str ()
) ;

But that doesn't work for std::stringstream (at least it doesn't work on my compiler (Visual Studio 2008)).

Based on this answer, I wrote a quick and dirty workaround:

#include <string>
#include <sstream>

template <typename StringStreamT = std::stringstream, typename StringT = std::string>
class QuickStringStream
{
public:
    typedef StringStreamT stringstream_type ;
    typedef StringT string_type ;

    QuickStringStream () {}
    QuickStringStream (const string_type strData) {
        ss_ << strData ;
    }

    template <typename T>
    QuickStringStream& operator<< (const T &tVal) {
        ss_ << tVal ;
        return *this ;
    }

    string_type str () const
    {
        return ss_.str () ;
    }

private:
    stringstream_type ss_ ;
};

This does what I want, but I can't get rid of the feeling that this is a horrible idea.

But that doesn't work for std::stringstream (at least it doesn't work on my compiler (visual studio 2008)).

But that doesn't work for std::stringstream (at least it doesn't work on my compiler (Visual Studio 2008)).