how to avoid reinterpret_cas t in this snippet?

[KK]

Hello all,
I have a unsigned char buffer 'buffer[1024]' and I need to convert the
first 12 bytes of it into a string. Below is a code that should work,
however, how can I avoid reinterpret_cas t operator?
Or Is there a simple way to get around this?
Thanks.
-KK
/* not tested yet */
typedef unsigned char BYTE
std::string GetStringFromBy teBuffer(const BYTE* const buffer, int pos )
{
const char *chAry = reinterpret_cas t <const char *> (buffer + pos);
std::string tmp(chAry,12);
return chAry;
}

[Ron Natalie]

KK wrote:

Hello all,
I have a unsigned char buffer 'buffer[1024]' and I need to convert the
first 12 bytes of it into a string. Below is a code that should work,
however, how can I avoid reinterpret_cas t operator?
Or Is there a simple way to get around this?
Thanks.
-KK
/* not tested yet */
typedef unsigned char BYTE
std::string GetStringFromBy teBuffer(const BYTE* const buffer, int pos )
{
const char *chAry = reinterpret_cas t <const char *> (buffer + pos);
std::string tmp(chAry,12);
return chAry;
}

You can't. unsigned char* and char* are not convertible. Even on
systems where char is inherently unsigned it's a distinct type. The
cast however should be safe.

[Alf P. Steinbach]

* KK:

Hello all,
I have a unsigned char buffer 'buffer[1024]' and I need to convert the
first 12 bytes of it into a string. Below is a code that should work,
however, how can I avoid reinterpret_cas t operator?
Or Is there a simple way to get around this?
Thanks.
-KK
/* not tested yet */
typedef unsigned char BYTE
std::string GetStringFromBy teBuffer(const BYTE* const buffer, int pos )
{
const char *chAry = reinterpret_cas t <const char *> (buffer + pos);
std::string tmp(chAry,12);
return chAry;
}

How about

std::string string12From( const BYTE buffer[], int pos )
{
return std::string( buffer+pos, buffer+pos+12 );
}

Btw., it's not a good idea to bury magic numbers like 12 in the code.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[ben]

KK wrote:

Hello all,
I have a unsigned char buffer 'buffer[1024]' and I need to convert the
first 12 bytes of it into a string. Below is a code that should work,
however, how can I avoid reinterpret_cas t operator?
Or Is there a simple way to get around this?
Thanks.
-KK
/* not tested yet */
typedef unsigned char BYTE
std::string GetStringFromBy teBuffer(const BYTE* const buffer, int pos )
{
const char *chAry = reinterpret_cas t <const char *> (buffer + pos);
std::string tmp(chAry,12);
return chAry;
}

In addition to Alf's suggestion, here is another choice:

void GetStringFromBy teBuffer(const BYTE* const buffer,
std::string& s)
{
std::copy(buffe r, buffer+12, s.begin());
}

BYTE buff[19];
int pos = 6;
std::string str;

GetStringFromBy teBuffer(
buff + pos,
str);

Ben

[Alf P. Steinbach]

* ben:

KK wrote:

Hello all,
I have a unsigned char buffer 'buffer[1024]' and I need to convert the
first 12 bytes of it into a string. Below is a code that should work,
however, how can I avoid reinterpret_cas t operator?
Or Is there a simple way to get around this?
Thanks.
-KK
/* not tested yet */
typedef unsigned char BYTE
std::string GetStringFromBy teBuffer(const BYTE* const buffer, int pos )
{
const char *chAry = reinterpret_cas t <const char *> (buffer + pos);
std::string tmp(chAry,12);
return chAry;
}
In addition to Alf's suggestion, here is another choice:

void GetStringFromBy teBuffer(const BYTE* const buffer,
std::string& s)
{
std::copy(buffe r, buffer+12, s.begin());

Nitpick: that assumes the string s passed as actual argument has size
12.

I'd write

s.assign( buffer, buffer+12 );
}

BYTE buff[19];
int pos = 6;
std::string str;
Oops... ;-)

GetStringFromBy teBuffer(
buff + pos,
str);

I think there's too much apparent magic in the standard library, so it's
too easy to think a standard algorithm can do no wrong...

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Bob Hairgrove]

On 1 Dec 2005 14:47:10 -0800, "KK" <ke*******@yaho o.com> wrote:

Hello all,
I have a unsigned char buffer 'buffer[1024]' and I need to convert the
first 12 bytes of it into a string. Below is a code that should work,
however, how can I avoid reinterpret_cas t operator?
Or Is there a simple way to get around this?
Thanks.
-KK
/* not tested yet */
typedef unsigned char BYTE
std::string GetStringFromBy teBuffer(const BYTE* const buffer, int pos )
{
const char *chAry = reinterpret_cas t <const char *> (buffer + pos);
std::string tmp(chAry,12);
return chAry;
}

Since char and unsigned char are different types, you must use either
a C-style cast or reinterpret_cas t, as you have done. There is really
no way to avoid it if you must pass unsigned char to this function.

--
Bob Hairgrove
No**********@Ho me.com

[Alf P. Steinbach]

* Bob Hairgrove:

On 1 Dec 2005 14:47:10 -0800, "KK" <ke*******@yaho o.com> wrote:

Hello all,
I have a unsigned char buffer 'buffer[1024]' and I need to convert the
first 12 bytes of it into a string. Below is a code that should work,
however, how can I avoid reinterpret_cas t operator?
Or Is there a simple way to get around this?
Thanks.
-KK
/* not tested yet */
typedef unsigned char BYTE
std::string GetStringFromBy teBuffer(const BYTE* const buffer, int pos )
{
const char *chAry = reinterpret_cas t <const char *> (buffer + pos);
std::string tmp(chAry,12);
return chAry;
}

Since char and unsigned char are different types, you must use either
a C-style cast or reinterpret_cas t, as you have done. There is really
no way to avoid it if you must pass unsigned char to this function.

You're the second person to state that so I'm interesting in the
reeasoning.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Bob Hairgrove]

On Fri, 02 Dec 2005 09:58:35 GMT, al***@start.no (Alf P. Steinbach)
wrote:

Since char and unsigned char are different types, you must use either
a C-style cast or reinterpret_cas t, as you have done. There is really
no way to avoid it if you must pass unsigned char to this function.

You're the second person to state that so I'm interesting in the
reeasoning.

The reason? Because std::string has no constructor that takes unsigned
char* as an argument.

(And I believe that there are more than two others by now... ;)

--
Bob Hairgrove
No**********@Ho me.com

[Kai-Uwe Bux]

Bob Hairgrove wrote:

On Fri, 02 Dec 2005 09:58:35 GMT, al***@start.no (Alf P. Steinbach)
wrote:

Since char and unsigned char are different types, you must use either
a C-style cast or reinterpret_cas t, as you have done. There is really
no way to avoid it if you must pass unsigned char to this function.

You're the second person to state that so I'm interesting in the
reeasoning.

The reason? Because std::string has no constructor that takes unsigned
char* as an argument.

Hm, std::string has a templated constructor:
template<class InputIterator>
basic_string(In putIterator begin, InputIterator end,
const Allocator& a = Allocator());
Since unsigned char is convertible to char, this constructor should match.
Best

Kai-Uwe Bux

[Alf P. Steinbach]

* Bob Hairgrove:

On Fri, 02 Dec 2005 09:58:35 GMT, al***@start.no (Alf P. Steinbach)
wrote:

Since char and unsigned char are different types, you must use either
a C-style cast or reinterpret_cas t, as you have done. There is really
no way to avoid it if you must pass unsigned char to this function.
You're the second person to state that so I'm interesting in the
reeasoning.

The reason? Because std::string has no constructor that takes unsigned
char* as an argument.

That is incorrect.
(And I believe that there are more than two others by now... ;)

That is also incorrect.

Cheers,

- Alf

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?