Thread: string to character conversion

itoa isn't a standard function. Since you're using C++ strings, the stringstream class would be a better option because it's standard and far more flexible:

Code:

#include <iostream>
#include <sstream>
#include <string>

using namespace std;

template <typename T>
string
makestr(T thingie)
{
  ostringstream sout;

  sout<< thingie;

  return sout.str();
}

class test {
  int a, b;
public:
  test(int a_, int b_)
    : a(a_)
    , b(b_)
  {}
  friend ostream&
  operator<<(ostream& out, const test& t)
  {
    return out<< t.a <<'/'<< t.b;
  }
};

int
main()
{
  string s;

  s = makestr(10);
  cout<< s <<endl;
  s = makestr(123.456);
  cout<< s <<endl;
  test t(4, 5);
  s = makestr(t);
  cout<< s <<endl;
}

>that would be better because no extra copy would be made, right?
No copy would be made, yes. But it would be very bad because the stringstream object is destroyed when the function returns. Returning a reference to local data is a very Bad Thing. Making the return string const also limits the function in that the caller is unable to modify the string. For such a fundamental operation, it would be unwise IMO to assume that the result would never be modified.

>2)<snip>
Because ostream is a base class for ostringstream. By using ostream you can print test using any stream that derives from ostream. If you used ostringstream then you would be limited to ostringstreams only.

>b) why when i remove the reference it doesn't compile??
Because the reference is required.

Make sure that extensions are enabled and strict ANSI compliance is disabled. If it still doesn't compile you may need to reinstall the compiler.

>2) ok, but we don't want to modify any data mambers of the dirived class?
Why would you want to modify an object with an output function?

>By theway, only the ostream object "cout" is connected to the screen, right?
C++ doesn't require a screen, cout is simply connected to the standard output. But to answer your question, yes. At program startup, the only ostream object connected to standard output is cout.

>Huh? why?
Because the standard says so.

>when do these copy objects give their memory back to the system?
When the scope in which they were created is exited:

Code:

object foo();

int
main()
{
  object a = foo();

  for (int i = 0; i < 10; i++) {
    object b = foo();
    cout<< b <<endl;
  } // b is destroyed here
} // a is destroted here

>somnething gets modified in obj. Right?
Yes. Sorry, I was thinking that you were talking about the object being written, not the stream being written to.

>What i meant is, if some data members of "o" that do not exist in a ostream object wil get modified by this
That won't happen. Because o is passed as a reference in operator<<, polymorphism takes effect and the correct member functions are called, modifying the correct members, even if they don't exist in the base class.

>but why does it say so?
See my above explanation for one reason.

>you didn't get the question
No, you didn't get the answer. A copy is a unique object; it's created when the copy is made and destroyed (releasing the memory that it used) when the scope in which it was created is exited. The temporary values OTOH have rules that are rather hairy. IIRC, the lifetime of a temporary object extends until the end of the containing expression. So your example might work like this:

b is created and given the value 24 in the function main.
An unnamed temporary initialized to b's value is made in the call to f.
a is created and assigned the unnamed temporary value (24).
The unnamed temporary is destroyed.
A copy of the value of the return expression is saved as an unnamed temporary.
a is destroyed.
The unnamed temporary's value is assigned to b.
The unnamed temporary is destroyed.
b is destroyed.

>What's the data member that the ostringstream has
I don't know. It depends heavily on internal knowledge of a specific implementation.