Using string where a char* required

[Angus]

I am working with a C API which often requires a char* or char buffer. If a
C function returns a char* I can't use string? Or can I? I realise I can
pass a char* using c_str() but what about receiving a char buffer into a
string?

Reason I ask is otherwise I have to guess at what size buffer to create?
And then copy buffer to a string. Doesn't seem ideal.

[osmium]

"Angus" writes:

>I am working with a C API which often requires a char* or char buffer. If
a
C function returns a char* I can't use string? Or can I? I realise I can
pass a char* using c_str() but what about receiving a char buffer into a
string?

Reason I ask is otherwise I have to guess at what size buffer to create?
And then copy buffer to a string. Doesn't seem ideal.

One of the constructors for std::string will, in effect, accept a char* as
an parameter.

Thus:

char* foo { /*stuff*/ }

std::string s;
s= foo();

Or at least something similar to that.

[Angus]

"osmium" <r1********@com cast.netwrote in message
news:5h******** *****@mid.indiv idual.net...

"Angus" writes:

I am working with a C API which often requires a char* or char buffer.

If

a
C function returns a char* I can't use string? Or can I? I realise I

can

pass a char* using c_str() but what about receiving a char buffer into a
string?

Reason I ask is otherwise I have to guess at what size buffer to create?
And then copy buffer to a string. Doesn't seem ideal.

One of the constructors for std::string will, in effect, accept a char* as
an parameter.

Thus:

char* foo { /*stuff*/ }

std::string s;
s= foo();

Or at least something similar to that.

For example in Windows there is a GetUserName function like this:
BOOL WINAPI GetUserName ( LPWSTR lpBuffer, LPDWORD nSize )

if you do this:
std::string str;

DWORD bufsize = 256;

GetUserName(str , &bufsize);

you get compile error:

error C2664: 'GetUserNameA' : cannot convert parameter 1 from 'class
std::basic_stri ng<char,struct std::char_trait s<char>,class
std::allocator< char' to 'char *'
No user-defined-conversion operator available that can perform this
conversion, or the operator cannot be called
I suppose I could cast? But wondering what best way to tackle is.

[Victor Bazarov]

Angus wrote:

"osmium" <r1********@com cast.netwrote in message
news:5h******** *****@mid.indiv idual.net...

>"Angus" writes:

>>I am working with a C API which often requires a char* or char
buffer. If a
C function returns a char* I can't use string? Or can I? I
realise I can pass a char* using c_str() but what about receiving a
char buffer into a string?

Reason I ask is otherwise I have to guess at what size buffer to
create? And then copy buffer to a string. Doesn't seem ideal.

One of the constructors for std::string will, in effect, accept a
char* as an parameter.

Thus:

char* foo { /*stuff*/ }

std::string s;
s= foo();

Or at least something similar to that.

For example in Windows there is a GetUserName function like this:
BOOL WINAPI GetUserName ( LPWSTR lpBuffer, LPDWORD nSize )

if you do this:
std::string str;

DWORD bufsize = 256;

GetUserName(str , &bufsize);

you get compile error:

error C2664: 'GetUserNameA' : cannot convert parameter 1 from 'class
std::basic_stri ng<char,struct std::char_trait s<char>,class
std::allocator< char' to 'char *'
No user-defined-conversion operator available that can perform
this conversion, or the operator cannot be called
I suppose I could cast? But wondering what best way to tackle is.

The best way is to allocate a temporary (local) array of TCHAR (or
whatever type is LPWSTR points to) and then _after_ you call the
function that would fill in that array, create a string from it.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[osmium]

"Angus" writes:

"osmium" <r1********@com cast.netwrote in message
news:5h******** *****@mid.indiv idual.net...

>"Angus" writes:

>I am working with a C API which often requires a char* or char buffer.

If

>a
C function returns a char* I can't use string? Or can I? I realise I

can

pass a char* using c_str() but what about receiving a char buffer into
a
string?

Reason I ask is otherwise I have to guess at what size buffer to
create?
And then copy buffer to a string. Doesn't seem ideal.

One of the constructors for std::string will, in effect, accept a char*
as
an parameter.

Thus:

char* foo { /*stuff*/ }

std::string s;
s= foo();

Or at least something similar to that.

For example in Windows there is a GetUserName function like this:
BOOL WINAPI GetUserName ( LPWSTR lpBuffer, LPDWORD nSize )

if you do this:
std::string str;

DWORD bufsize = 256;

GetUserName(str , &bufsize);

you get compile error:

error C2664: 'GetUserNameA' : cannot convert parameter 1 from 'class
std::basic_stri ng<char,struct std::char_trait s<char>,class
std::allocator< char' to 'char *'
No user-defined-conversion operator available that can perform this
conversion, or the operator cannot be called
I suppose I could cast? But wondering what best way to tackle is.

I wonder if LPWSTR is, by chance, Microsoft gobbledygook for wide string?

Your question asked about a char* and char pointer points at a *byte*. So
all bets are off.

I get a headache just thinking about that crappy Microsoft stuff. If my
guess is right about the 'W', I guess the *right* way to proceed is to
fiddle with locales or facets or traits or some of that other high faultin'
stuff. But that's not the way I would proceed. I would find out what that
damn acronym represented in the real world and convert/cast/whatever to make
the thing work.

[Angus]

"osmium" <r1********@com cast.netwrote in message
news:5h******** *****@mid.indiv idual.net...

"Angus" writes:

"osmium" <r1********@com cast.netwrote in message
news:5h******** *****@mid.indiv idual.net...

"Angus" writes:

I am working with a C API which often requires a char* or char buffer.

If

a
C function returns a char* I can't use string? Or can I? I realise

I

can

pass a char* using c_str() but what about receiving a char buffer

into

a
string?

Reason I ask is otherwise I have to guess at what size buffer to
create?
And then copy buffer to a string. Doesn't seem ideal.

One of the constructors for std::string will, in effect, accept a char*
as
an parameter.

Thus:

char* foo { /*stuff*/ }

std::string s;
s= foo();

Or at least something similar to that.

For example in Windows there is a GetUserName function like this:
BOOL WINAPI GetUserName ( LPWSTR lpBuffer, LPDWORD nSize )

if you do this:
std::string str;

DWORD bufsize = 256;

GetUserName(str , &bufsize);

you get compile error:

error C2664: 'GetUserNameA' : cannot convert parameter 1 from 'class
std::basic_stri ng<char,struct std::char_trait s<char>,class
std::allocator< char' to 'char *'
No user-defined-conversion operator available that can perform

this

conversion, or the operator cannot be called
I suppose I could cast? But wondering what best way to tackle is.

I wonder if LPWSTR is, by chance, Microsoft gobbledygook for wide string?

Your question asked about a char* and char pointer points at a *byte*. So
all bets are off.

I get a headache just thinking about that crappy Microsoft stuff. If my
guess is right about the 'W', I guess the *right* way to proceed is to
fiddle with locales or facets or traits or some of that other high

faultin'

stuff. But that's not the way I would proceed. I would find out what that
damn acronym represented in the real world and convert/cast/whatever to

make

the thing work.

No I copied it wrong - should have been
BOOL WINAPI GetUserName ( LPSTR lpBuffer, LPDWORD nSize )

[osmium]

"Angus" writes:

No I copied it wrong - should have been
BOOL WINAPI GetUserName ( LPSTR lpBuffer, LPDWORD nSize )

Well, this works. I don't know what else to say. This is exactly what I
thought you meant when I read your first post.

----------------
#include <iostream>

#define STOP while(1) cin.get();

using namespace std;

char* foo()
{
return "hello";
}
//============
int main()
{
string s;
s = foo();
cout << s << endl;

STOP;
}

[BobR]

Angus <no****@gmail.c omwrote in message...

>
No I copied it wrong - should have been
BOOL WINAPI GetUserName ( LPSTR lpBuffer, LPDWORD nSize )

// includes here; <iostream>, <vector>, <cctype>, "windows.h" , etc.
{ // main() or ?
std::vector<cha rBuff( 100, '\0' );
DWORD DSize( static_cast<DWO RD>( Buff.size()-1 ) );
std::string User1;
if( GetUserName( &Buff.at(0), &DSize ) ){
std::cout<<"Get UserName()=";
for( std::size_t a(0); a < Buff.size(); ++a ){
if( not std::isprint( Buff.at(a) ) ){ break;} // <cctype>
std::cout<<Buff .at(a);
User1.push_back ( Buff.at(a) );
} // for(a)
} // if(Get)
else{
std::cout<<"Get UserName() FAILED"<<std::e ndl;
}
std::cout<<'\n' <<User1<<std::e ndl;
}

Clunky? Yup!!

If it doesn't work for you, post back with first 3 errors.

--
Bob R
POVrookie

[sss.zhou]

On Jul 29, 2:18 am, "Angus" <nos...@gmail.c omwrote:

"osmium" <r124c4u...@com cast.netwrote in message

news:5h******** *****@mid.indiv idual.net...

"Angus" writes:

"osmium" <r124c4u...@com cast.netwrote in message
>news:5h******* ******@mid.indi vidual.net...
>"Angus" writes:

>I am working with a C API which often requires a char* or char buffer.
If
>a
C function returns a char* I can't use string? Or can I? I realise

I

can
pass a char* using c_str() but what about receiving a char buffer

into

a
string?

Reason I ask is otherwise I have to guess at what size buffer to
create?
And then copy buffer to a string. Doesn't seem ideal.

>One of the constructors for std::string will, in effect, accept a char*
>as
>an parameter.

>Thus:

>char* foo { /*stuff*/ }

>std::string s;
>s= foo();

>Or at least something similar to that.

For example in Windows there is a GetUserName function like this:
BOOL WINAPI GetUserName ( LPWSTR lpBuffer, LPDWORD nSize )

if you do this:
std::string str;

DWORD bufsize = 256;

GetUserName(str , &bufsize);

you get compile error:

error C2664: 'GetUserNameA' : cannot convert parameter 1 from 'class
std::basic_stri ng<char,struct std::char_trait s<char>,class
std::allocator< char' to 'char *'
No user-defined-conversion operator available that can perform

this

conversion, or the operator cannot be called

I suppose I could cast? But wondering what best way to tackle is.

I wonder if LPWSTR is, by chance, Microsoft gobbledygook for wide string?

Your question asked about a char* and char pointer points at a *byte*. So
all bets are off.

I get a headache just thinking about that crappy Microsoft stuff. If my
guess is right about the 'W', I guess the *right* way to proceed is to
fiddle with locales or facets or traits or some of that other high

faultin'

stuff. But that's not the way I would proceed. I would find out what that
damn acronym represented in the real world and convert/cast/whatever to

make

the thing work.

No I copied it wrong - should have been
BOOL WINAPI GetUserName ( LPSTR lpBuffer, LPDWORD nSize )

Even you can write this:

DWORD dwLen = 256;
std::string strUsername(dwL en '\0');
char* pData = const_cast<char *>(strUsername. c_str());
if (GetUserName(pD ata, &dwLen)
{
std::cout << "Get User name success." << strUsername;
}
else
{
std::cout << "Get user name failed"
}

This may work OK when strUsername is just a temporary variant, but
when copy a std::string to another std::string, it just increase it
reference counts and really did copy on changed.

When you wanted to call Windows API, just using CHAR and TCHAR, or
CString(if you application supports MFC), IMO, std didn't fill any
cases.

DWORD dwLen = 256;
CHAR* szUserName = new CHAR[dwLen]; //if GetUserName parameter is
LPWSTR, using TCHAR.
if (GetUserName(sz UserName, &dwLen) {
...
} else {
...
}

[tragomaskhalos]

On 29 Jul, 13:57, "sss.z...@gmail .com" <sss.z...@gmail .comwrote:

Even you can write this:

DWORD dwLen = 256;
std::string strUsername(dwL en '\0');
char* pData = const_cast<char *>(strUsername. c_str());
if (GetUserName(pD ata, &dwLen)
:
This may work OK when strUsername is just a temporary variant, but
when copy a std::string to another std::string, it just increase it
reference counts and really did copy on changed.

No mays or buts, this is wrong. You can't go scribbling over
the value returned from c_str(). Even if it happens to work on your
compiler and standard library implementation today it may not
tomorrow.

When you wanted to call Windows API, just using CHAR and TCHAR, or
CString(if you application supports MFC), IMO, std didn't fill any
cases.

DWORD dwLen = 256;
CHAR* szUserName = new CHAR[dwLen]; //if GetUserName parameter is
LPWSTR, using TCHAR.
if (GetUserName(sz UserName, &dwLen) {
...

This is better, but if you're using a constant dwLen then
there's no point in dynamically allocating the buffer.
Note that according to MSDN the dwLen parameter is in/out,
so there's no risk of a buffer overflow here.