The boost::lexical_cast<> utility is a handy way of converting objects to and from strings, providing a mechanism that many scripting languages have built in. lexical_cast works with any C++ type that has ostream and istream operators defined for it, that is, any object that cout << object; or cin >> object; would work with. This boost facility also does intelligent things such as throwing a bad_cast exception if the operation causes an error flag on the stream to be set. I use boost::lexical_cast<> throughout my code at work for things like serialization of objects for human readable communications. It is also sprinkled liberally throughout my code for handling things like quick debug logging:

myLogger.log("Error occurred: " + boost::lexical_cast(getErrorNo()));

However, it doesn’t really make sense to pull boost into your project if you only need a handy tool for doing conversions to strings. It is simple to create your own version with a template:

template<typename T> 
std::string to_string(const T &t) {   
  std::stringstream ss;   
  ss << t;   
  return ss.str(); 

Example usage:

myLogger.log("Error occurred: " + to_string(getErrorNo()));

Not very many C++ programmers work like this, but I personally prefer to only use temporary variables if I really need to, and I want to make sure they are initialized on construction if at all possible. If you were to use the above technique with some legacy C code that was expecting a c-style string, you could perfectly legally do this:

logfunc( ("Error occurred: " + to_string(getErrorNo())).c_str() );

This is perfectly legal because the result of a string + operator is a new string object created on the stack and that object will persist until after the moment that the function call returns.