return string from c++ to c

[Michael Rasmussen]

Hi all,

Not sure if this is OT?

I have a function in a library written in C++ which returns a
strdup(s.c_str( )) to an application written i C. Running Valgrind on my
C-application shows this results in memory leaks due to the c_str is never
freed.

Example:

Foo.h

#ifdef __cplusplus

class Foo {
public:
std::string getString() { return s; }

private:
std::string s;
};

#else

typedef struct Foo Foo;

#endif

#ifdef __cplusplus

extern "C" {

#endif

extern char *cplusplus_getS tring(Foo *); // C++ call-back
extern char *get_string(Foo *); // C function

#ifdef __cplusplus

}

#endif

Foo.cc

char *cplusplus_getS tring(Foo *foo)
{
std::string s;

s = foo->getString();
return strdup(s.c_str( )) // this is coursing memory leaks.
}

main.c

char *get_string(str uct Foo *foo)
{
return cplusplus_getSt ring(foo);
}

int main()
{
struct Foo *foo;

printf("%s\n", get_string());
return 0;
}

--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917

[Jim Langston]

"Michael Rasmussen" <mi*@miras.or g> wrote in message
news:pa******** *************** *****@miras.org ...

Hi all,

Not sure if this is OT?

I have a function in a library written in C++ which returns a
strdup(s.c_str( )) to an application written i C. Running Valgrind on my
C-application shows this results in memory leaks due to the c_str is never
freed.

Example:

Foo.h

#ifdef __cplusplus

class Foo {
public:
std::string getString() { return s; }

private:
std::string s;
};

#else

typedef struct Foo Foo;

#endif

#ifdef __cplusplus

extern "C" {

#endif

extern char *cplusplus_getS tring(Foo *); // C++ call-back
extern char *get_string(Foo *); // C function

#ifdef __cplusplus

}

#endif

Foo.cc

char *cplusplus_getS tring(Foo *foo)
{
std::string s;

s = foo->getString();
return strdup(s.c_str( )) // this is coursing memory leaks.
}
Have you tried a simple
return s.c_str();

This will return a const char* to a buffer inside of s that remains until
changes are made to s. As long as your main.c doesn't try to change the
contents, everything should (read probably) work.

main.c

char *get_string(str uct Foo *foo)
{
return cplusplus_getSt ring(foo);
}

int main()
{
struct Foo *foo;

printf("%s\n", get_string());
return 0;
}

--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917

[Michael Rasmussen]

On Thu, 09 Feb 2006 16:11:23 -0800, Jim Langston wrote:

Have you tried a simple
return s.c_str();

This will return a const char* to a buffer inside of s that remains until
changes are made to s. As long as your main.c doesn't try to change the
contents, everything should (read probably) work.

Yes. It produces this output from Valgrind:
==7412== Invalid read of size 2
==7412== at 0x40BBA1A: mempcpy (in /lib/tls/i686/cmov/libc-2.3.5.so)
==7412== by 0x408D28B: vfprintf (in /lib/tls/i686/cmov/libc-2.3.5.so)
==7412== by 0x4092B02: printf (in /lib/tls/i686/cmov/libc-2.3.5.so)
==7412== by 0x804881C: main (main.c:56)
==7412== Address 0x429DB4C is 12 bytes inside a block of size 109 free'd
==7412== at 0x401C304: operator delete(void*) (vg_replace_mal loc.c:246)
==7412== by 0x421733C: std::string::_R ep::_M_destroy( std::allocator< char> const&) (in /usr/lib/libstdc++.so.6. 0.7)
==7412== by 0x42184E7: std::string::~s tring() (in
/usr/lib/libstdc++.so.6. 0.7)

return s.c_str() and return strdup(s.c_str( )) is coursing memory leaks.
Any other way to return a string as a C-string? Would returning a char
buffer not give me the same problems?

--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917

[red floyd]

Michael Rasmussen wrote:

Hi all,

Not sure if this is OT?

I have a function in a library written in C++ which returns a
strdup(s.c_str( )) to an application written i C. Running Valgrind on my
C-application shows this results in memory leaks due to the c_str is never
freed.

Actually, the leak is due to the memory allocated by strdup() never
being freed.

[Jim Langston]

"red floyd" <no*****@here.d ude> wrote in message
news:Xf******** ***********@new ssvr13.news.pro digy.com...

Michael Rasmussen wrote:

Hi all,

Not sure if this is OT?

I have a function in a library written in C++ which returns a
strdup(s.c_str( )) to an application written i C. Running Valgrind on my
C-application shows this results in memory leaks due to the c_str is
never
freed.

Actually, the leak is due to the memory allocated by strdup() never being
freed.

Well, I guess you'll have to do it the ugly C style way then.

Pass a char* from C to the C++ function with preallocated space and strcpy
into that.

[Victor Bazarov]

Jim Langston wrote:

"Michael Rasmussen" <mi*@miras.or g> wrote in message
news:pa******** *************** *****@miras.org ...

Hi all,

Not sure if this is OT?

I have a function in a library written in C++ which returns a
strdup(s.c_str( )) to an application written i C. Running Valgrind on
my C-application shows this results in memory leaks due to the c_str
is never freed.

Example:

Foo.h

#ifdef __cplusplus

class Foo {
public:
std::string getString() { return s; }

private:
std::string s;
};

#else

typedef struct Foo Foo;

#endif

#ifdef __cplusplus

extern "C" {

#endif

extern char *cplusplus_getS tring(Foo *); // C++ call-back
extern char *get_string(Foo *); // C function

#ifdef __cplusplus

}

#endif

Foo.cc

char *cplusplus_getS tring(Foo *foo)
{
std::string s;

s = foo->getString();
return strdup(s.c_str( )) // this is coursing memory leaks.
}
Have you tried a simple
return s.c_str();

How is that going to help? You're returning a pointer to something
that comes out of a local object. You're essentially returning the
local object. This is called "a dangling pointer".
This will return a const char* to a buffer inside of s that remains
until changes are made to s. As long as your main.c doesn't try to
change the contents, everything should (read probably) work.
What are you talking about? As soon as the closing curly brace is
reached, the 's' is _destroyed_.

AFAIK, 'strdup' is not a standard function, but using 'strdup' is
probably the only way to preserve that string. You can, of course,
do 'malloc' and 'strcpy', which probably what 'strdup' does under
the covers anyway.
[..]

V
--
Please remove capital As from my address when replying by mail

[Victor Bazarov]

Jim Langston wrote:

"red floyd" <no*****@here.d ude> wrote in message
news:Xf******** ***********@new ssvr13.news.pro digy.com...

Michael Rasmussen wrote:

Hi all,

Not sure if this is OT?

I have a function in a library written in C++ which returns a
strdup(s.c_str( )) to an application written i C. Running Valgrind
on my C-application shows this results in memory leaks due to the
c_str is never
freed.

Actually, the leak is due to the memory allocated by strdup() never
being freed.

Well, I guess you'll have to do it the ugly C style way then.

Pass a char* from C to the C++ function with preallocated space and
strcpy into that.

I suppose it might be a simpler solution. Of course, the C program
could always simply call 'free' for that pointer after it's done with
it, no? I guess, "man strdup" is in order...

V
--
Please remove capital As from my address when replying by mail

[Jim Langston]

"Victor Bazarov" <v.********@com Acast.net> wrote in message
news:u9******** ************@co mcast.com...

Jim Langston wrote:

"red floyd" <no*****@here.d ude> wrote in message
news:Xf******** ***********@new ssvr13.news.pro digy.com...

Michael Rasmussen wrote:
Hi all,

Not sure if this is OT?

I have a function in a library written in C++ which returns a
strdup(s.c_str( )) to an application written i C. Running Valgrind
on my C-application shows this results in memory leaks due to the
c_str is never
freed.
Actually, the leak is due to the memory allocated by strdup() never
being freed.

Well, I guess you'll have to do it the ugly C style way then.

Pass a char* from C to the C++ function with preallocated space and
strcpy into that.

I suppose it might be a simpler solution. Of course, the C program
could always simply call 'free' for that pointer after it's done with
it, no? I guess, "man strdup" is in order...

V
--
Please remove capital As from my address when replying by mail

Best I could come up with is this:
const char* f(const char* text)
{
static char returnthis[1000];
std::string tempstring(text );
strcpy( returnthis, tempstring.c_st r() );
return returnthis;
}

[Victor Bazarov]

Jim Langston wrote:

"Victor Bazarov" <v.********@com Acast.net> wrote in message
news:u9******** ************@co mcast.com...

Jim Langston wrote:

"red floyd" <no*****@here.d ude> wrote in message
news:Xf******** ***********@new ssvr13.news.pro digy.com...
Michael Rasmussen wrote:
> Hi all,
>
> Not sure if this is OT?
>
> I have a function in a library written in C++ which returns a
> strdup(s.c_str( )) to an application written i C. Running Valgrind
> on my C-application shows this results in memory leaks due to the
> c_str is never
> freed.
>

Actually, the leak is due to the memory allocated by strdup() never
being freed.

Well, I guess you'll have to do it the ugly C style way then.

Pass a char* from C to the C++ function with preallocated space and
strcpy into that.

I suppose it might be a simpler solution. Of course, the C program
could always simply call 'free' for that pointer after it's done with
it, no? I guess, "man strdup" is in order...

V
--
Please remove capital As from my address when replying by mail

Best I could come up with is this:
const char* f(const char* text)
{
static char returnthis[1000];
std::string tempstring(text );
strcpy( returnthis, tempstring.c_st r() );
return returnthis;
}

Uh... What exactly is the point of all this? If you pass a char const*
in and you expect a char const* out, why do you need all this dancing
around with a static array, with an automatic std::string? It seems that
the intention here is

const char* useless_functio n(const char* text)
{
return text;
}

Of course, the OP had a C++ object with a _member_ of type 'std::string'
and needed to extract the contents somewhere... You must have simplified
the original intention just a tad too much.

V
--
Please remove capital As from my address when replying by mail

[Michael Rasmussen]

On Thu, 09 Feb 2006 18:18:49 -0800, Jim Langston wrote:

Best I could come up with is this:
const char* f(const char* text)
{
static char returnthis[1000];
std::string tempstring(text );
strcpy( returnthis, tempstring.c_st r() ); return returnthis;
}
}

I was given a more "clean" solution on a Linux list. The solution is to
create a string as a member of the class and then use this string as a
temporary storage. From this member you are allowed to return s.c_str()
since this string will be alive as long as the instance of the class. This
is also, in my opinion, a bether solution since it keeps encapsulation -
You will have to call the class if you need any change. More correct OOP
style.

Correct example:

Foo.h

#ifdef __cplusplus

class Foo {
public:
std::string cstring;
std::string getString() { return s; }

private:
std::string s;
};

#else

typedef struct Foo Foo;

#endif

#ifdef __cplusplus

extern "C" {

#endif

extern const char *cplusplus_getS tring(Foo *); // C++ call-back extern
const char *get_string(Foo *); // C function

#ifdef __cplusplus
}
#endif

Foo.cc

const char *cplusplus_getS tring(Foo *foo)
{
cstring = foo->getString();
return cstring.c_str() // no memory leak since it is destroyed from
the class' destructor.
}

main.c

const char *get_string(str uct Foo *foo)
{
return cplusplus_getSt ring(foo);
}

int main()
{
struct Foo *foo;

printf("%s\n", get_string());
return 0;
}

--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917