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.

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.

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.

The standard way to do this kind of thing is to provide an insertion operator so that an object can be inserted into a stream -- which may be any kind of stream, such as a stringstream.

If you wish, you can also provide a method that converts to a string (useful for your insertion operator), and, if you find the conversion acceptable, you can provide a 'to string' operator.

Here's my standard 'point' class example:

template <typename T>
struct point
{
  T x;
  T y;
  point(): x(), y() { }
  point( T x, T y ): x(x), y(y) { }
};

template <typename T>
std::ostream& operator << ( std::ostream& outs, const point <T> & p )
{
  return outs << "(" << p.x << "," << p.y << ")";
}

I also tend to keep a handy function around to convert things to strings:

template <typename T>
std::string to_string( const T& value )
{
  std::ostringstream ss;
  ss << value;
  return ss.str();
}

Now I can use it easily:

int main()
{
  point p (2,-7);

  std::cout << "I have a point at " << p << ".\n";

  my_fn_which_takes_a_string( to_string(p) );

You'll find that the Boost Lexical Cast Library is also designed for this kind of thing.

Hope this helps.

You are returning a string that just says the phrase _name + _number + _date + _salary.

What you likely wanted to do is build a string using those fields. If you wanted them all mushed together Concat would work, but it would be highly un-readable

public override string ToString()
{
    return String.Concat(_name, _number, _date, _salary);
}

However what would be better is to use Format and include labels with the values

public override string ToString()
{
    return String.Format("Name:{0}, Number:{1}, Date:{2}, Salary:{3}",_name, _number, _date, _salary);
}

If you are using C# 6 or newer you can use the following cleaner format

public override string ToString()
{
    return $"Name:{_name}, Number:{_number}, Date:{_date}, Salary:{_salary}";
}

Which is the exact same logic as the previous String.Format version.