converting to const char*

[sadegh]

I wrote a function to convert any type to string:

template <typename T>
std::string toStr(const T &thing) {
std:stringstream outStr;
outStr << thing;
return outStr.str();
}

the above function works properly. I also wrote another function to
convert any type to const char* but it doesent work properly

template <typename T>
const char* toCStr(const T &thing) {
std:stringstream outStr;
outStr << thing;
std::string Str=outStr.str();
return Str.c_str();
}

Does any body know what is its problem?

Thanks

 

[Alf P. Steinbach]

* sadegh:

template <typename T>
const char* toCStr(const T &thing) {
std:stringstream outStr;
outStr << thing;
std::string Str=outStr.str();
return Str.c_str();
}

Does any body know what is its problem?

You're returning a pointer to a an object that no longer exists after
returning; this is known as a "dangling" pointer (or reference).

 

[sadegh]

So what shoud I do to convert any type to const char*?

 

[Gianni Mariani]

So what shoud I do to convert any type to const char*?

Does the caller expect to have to delete the memory on the returned string ?

 

[sadegh]

Does the caller expect to have to delete the memory on the returned string ?

I dont know. but for example I want to call the toCStr() function like
these:

AfxMessageBox(toCStr(8)); // showing the number "8"

or

m_EditBox.SetWindowText(toCStr(8)); // insert the number "8" into an
edit box

Tanks.

 

[aiooua]

template <typename T>
const char* toCStr(const T &thing) {
std:stringstream outStr;
outStr << thing;
std::string Str=outStr.str();
return Str.c_str();

}
Does any body know what is its problem?

you need to ensure the converted string lives outside the scope of
this function. one simple way is to do that is:
--
template <typename T>
const char* toCStr(const T &thing) {
static std:stringstream outStr;
outStr.str("");
outStr << thing;
return outStr.str().c_str();
}
--
note that there's only one covnersion buffer, all users of toCStr
would need to make deep copies of the result and not rely on its
contents.

thanks,

 

[Gianni Mariani]

I dont know. but for example I want to call the toCStr() function like
these:

AfxMessageBox(toCStr(8)); // showing the number "8"

or

m_EditBox.SetWindowText(toCStr(8)); // insert the number "8" into an
edit box

What you want is an object that extends the life of the string until the
function call returns. The catch with this is that the lifetime of the
string is very short, although longer than a dead return value. Once
the expression is evaluated, the memory of the string is no longer
valid. Hence, don't be caught holding on to a pointer from the toCStr
below otherwise you will run into nasty probs.

// toCStr header

#include <sstream>
#include <string>

template <typename T>
std::string ToString( const T & val )
{
std:stringstream l_out;
l_out << val;
return l_out.str();
}

struct toCStr
{
const std::string m_value;

template <typename T>
toCStr( const T & ival )
: m_value( ToString( ival ) )
{
}

operator const char * () const
{
return m_value.c_str();
}
};

/// example code

#include <iostream>

void foo( const char * str )
{
std::cout << str << "\n";
}

int main()
{
foo( toCStr( 8 ) );
}

 

[sadegh]

What you want is an object that extends the life of the string until the
function call returns. The catch with this is that the lifetime of the
string is very short, although longer than a dead return value. Once
the expression is evaluated, the memory of the string is no longer
valid. Hence, don't be caught holding on to a pointer from the toCStr
below otherwise you will run into nasty probs.

// toCStr header

#include <sstream>
#include <string>

template <typename T>
std::string ToString( const T & val )
{
std:stringstream l_out;
l_out << val;
return l_out.str();

}

struct toCStr
{
const std::string m_value;

template <typename T>
toCStr( const T & ival )
: m_value( ToString( ival ) )
{
}

operator const char * () const
{
return m_value.c_str();
}

};

/// example code

#include <iostream>

void foo( const char * str )
{
std::cout << str << "\n";

}

int main()
{
foo( toCStr( 8 ) );



}- Hide quoted text -

- Show quoted text -- Hide quoted text -

- Show quoted text -

What a nice answer and a nicer example. THANK YOU VERY MUCH Gianni.

 

[johan13]

I wrote a function to convert any type to string:

template <typename T>
std::string toStr(const T &thing) {
std:stringstream outStr;
outStr << thing;
return outStr.str();

}

You're reinventing the wheel there. Have a look at
boost::lexical_cast. It is very similar to your code. http://www.boost.org/

- Johan Levin

 

[Ron Natalie]

template <typename T>
const char* toCStr(const T &thing) {
static std:stringstream outStr;
outStr.str("");
outStr << thing;
return outStr.str().c_str();
}
--
note that there's only one covnersion buffer, all users of toCStr
would need to make deep copies of the result and not rely on its
contents.

thanks,

Here's one place where a macro has a tiny bit of use.

template <typename T> std::string toStr(const T& thing) {
std:stringstream outStr;
outStr << thing;
reutrn outStr.str();
}

#define toCStr(t) (toStr(t).c_str())

The temporary string returned by toStr() (and the c_str() from it)
will last until the end of thefull expression.

 

[sadegh]

Here's one place where a macro has a tiny bit of use.

template <typename T> std::string toStr(const T& thing) {
std:stringstream outStr;
outStr << thing;
reutrn outStr.str();

}

#define toCStr(t) (toStr(t).c_str())

The temporary string returned by toStr() (and the c_str() from it)
will last until the end of thefull expression.

An Excellent Answer!!!!!!!!!!!! you are very smart Ron.

 

[James Kanze]

So what shoud I do to convert any type to const char*?

You shouldn't. Any more than you should try to generically
convert any type to string---it just doesn't make sense.