No need to reinvent the wheel. Use Json.Net

string s = JsonConvert.SerializeObject(yourObject);

That is all.

You can also use JavaScriptSerializer

string s = new JavaScriptSerializer().Serialize(yourObject);

The crux of the problem is the to_string method uses the operator<< overload for clock_time. Unfortunately, The operator<< overload uses the to_string method. Obviously this can't work because it's going to go around in circles forever.

So how do we fix it up so that it can work?

We uncouple to_string and operator<< so that they don't call each other.

First off, let's define a bogus example clock_time because it's missing and we can't do jack all without it.

class clock_time
{
    int hour;
    int minute;
    int second;

public:
    friend std::ostream& operator<<(std::ostream &out, clock_time c);
}

Note the declaration of operator<< as a friend function of clock_times. This allows operator<< to break encapsulation and use the private members of clock_time. This might not be necessary depending on how clock_time has been defined, but for this example, it's pretty much the key to the whole shebang.

Next we implement operator<<

ostream& operator<<(ostream &out, clock_time c)
{
    out << c.hour << ":" << c.minute << ":" << c.second;
    return out;
}

I've chosen this output format because it's what I expect to see on a digital clock. The Law of Least Surprise says give people what they expect and you'll have fewer bugs and bad feelings. Confuse people and... Well remember what happened with when Microsoft pulled the start menu from Windows 8? Or when Coke changed their formula?

I'm doing operator<< first because of personal preference. I'd rather do the grunt work here because it's easier on my brain than doing it in to_string for some reason.

Now we're ready to implement the to_string function.

string to_string(clock_time c)
{
    ostringstream ss;
    ss << c;
    return ss.str();
}

Surprise! It's exactly the same as OP originally implemented it. Because to_string and operator<< have been uncoupled, operator<< is available for use in to_string. You could do it the other way around, so long as one of the functions does the heavy lifting for the other. Both could also do all of the work, but why? Twice as many places to screw things up.

The two are intended for different purposes. The ToString method of any object is supposed to return a string representation of that object. Casting is quite different, and the 'as' key word performs a conditional cast, as has been said. The 'as' key word basically says "get me a reference of this type to that object if that object is this type" while ToString says "get me a string representation of that object". The result may be the same in some cases but the two should never be considered interchangeable because, as I said, they exist for different purposes. If your intention is to cast then you should always use a cast, NOT ToString.

from http://www.codeguru.com/forum/showthread.php?t=443873

see also http://bytes.com/groups/net-c/225365-tostring-string-cast

Rust's approach: Display and Debug traits

Rust uses the trait system, through the Display and Debug traits, to model types that may be converted to strings, with two possible and well-known uses (user-facing and developer-facing, respectively).

However, it statically ensures that values of a type that doesn't implement the Display trait may not be used to construct a string representation; the same for Debug. Hence, Rust doesn't have a default string representation for user-defined types.

Even though there is not a default string representation, the language offers a macro to derive the Debug implementation using a sensible default that follows the type's definition. However, the Display trait may not be derived, which forces the developer to implement the user-facing string conversion explicitly.

Haskell has a similar mechanism via the Show type class, which may be derived.

s(message) actually calls the constructor of std::string, which constructs a new object of this type from the given character array pointed to by message. s is just an arbitary name given to the string object. std::string is C++'s idiomatic object for working with strings, it is usually preferred over raw C strings.

Consider this simple sample:

// Declare a fresh class
class A {

   public:

      // a (default) constructor that takes no parameters and sets storedValue to 0.
      A() {storedValue=0;}

      // and a constructor taking an integer
      A(int someValue) {storedValue=someValue;}

   // and a public integer member
   public:
      int storedValue;
};

// now create instances of this class:
A a(5);

// or
A a = A(5);

// or even
A a = 5;

// in all cases, the constructor A::A(int) is called.
// in all three cases, a.storedValue would be 5

// now, the default constructor (with no arguments) is called, thus
// a.storedValue is 0.
A a;

// same here
A a = A();

std::string declares various constructors, including one that accepts a const char* for initialization - the compiler automatically chooses the right constructor depending on the type and number of the arguments, so in your case string::string(const char*) is choosen.