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;
}

[Bob Hairgrove]

On Fri, 02 Dec 2005 05:31:13 -0500, Kai-Uwe Bux <jk********@gmx .net>
wrote:

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.

// test_uchar.cpp

#include <iostream>
#include <ostream>
#include <string>

int main()
{
const unsigned char msg[] = "Hello";
std::string s(msg);
std::cout << s << std::endl;
}

Does that compile on your system?

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

[Bob Hairgrove]

On Fri, 02 Dec 2005 11:04:26 GMT, al***@start.no (Alf P. Steinbach)
wrote:

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

That is incorrect.

// test_uchar.cpp

#include <iostream>
#include <ostream>
#include <string>

int main()
{
const unsigned char msg[] = "Hello";
std::string s(msg);
std::cout << msg << std::endl;
}

Does that compile on your system?

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

[Michiel.Salters]

Bob Hairgrove wrote:

On Fri, 02 Dec 2005 11:04:26 GMT, al***@start.no (Alf P. Steinbach)
wrote:

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

That is incorrect.

// test_uchar.cpp

#include <iostream>
#include <ostream>
#include <string>

int main()
{
const unsigned char msg[] = "Hello";
std::string s(msg);
std::cout << msg << std::endl;
}

Does that compile on your system?

Nope. However, this does:

#include <string>
const unsigned char msg[] = "Hello";
std::string s(msg,msg+sizeo f(msg));

The statement you're tyring to prove is: "
std::string has no constructor that takes one argument, of type
unsigned char*.
" That statement is of course true, but not really relevant.

HTH,
Michiel Salters

[Neil Cerutti]

On 2005-12-02, Bob Hairgrove <in*****@bigfoo t.com> wrote:

On Fri, 02 Dec 2005 11:04:26 GMT, al***@start.no (Alf P. Steinbach)
wrote:

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

That is incorrect.

// test_uchar.cpp

#include <iostream>
#include <ostream>
#include <string>

int main()
{
const unsigned char msg[] = "Hello";
std::string s(msg);
std::cout << msg << std::endl;
}

Does that compile on your system?

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

--
Neil Cerutti

[Kai-Uwe Bux]

Bob Hairgrove wrote:

On Fri, 02 Dec 2005 05:31:13 -0500, Kai-Uwe Bux <jk********@gmx .net>
wrote:

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.

// test_uchar.cpp

#include <iostream>
#include <ostream>
#include <string>

int main()
{
const unsigned char msg[] = "Hello";
std::string s(msg);
std::cout << s << std::endl;
}

Does that compile on your system?

Nope, but that is not the constructor I was talking about. The following
*does* compile:

// test_uchar.cpp

#include <iostream>
#include <ostream>
#include <string>

int main()
{
const unsigned char msg[] = "Hello";
std::string s( msg, msg+5 );
std::cout << s << std::endl;
}
Best

Kai-Uwe Bux

[Neil Cerutti]

On 2005-12-02, Neil Cerutti <le*******@emai l.com> wrote:

On 2005-12-02, Bob Hairgrove <in*****@bigfoo t.com> wrote:

On Fri, 02 Dec 2005 11:04:26 GMT, al***@start.no (Alf P.
Steinbach) wrote:

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

That is incorrect.

// test_uchar.cpp

#include <iostream>
#include <ostream>
#include <string>

int main()
{
const unsigned char msg[] = "Hello";
std::string s(msg);
std::cout << msg << std::endl;
}

Does that compile on your system?

Oops. Sorry for the all-quote null-response post. The slrn
configuration setting that allowed this mistake has been sacked.

I meant to say that it wouldn't compile on my system, but I could
make it work by using the templated constructor.

--
Neil Cerutti

[Ron Natalie]

Kai-Uwe Bux wrote:

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.

There is no coinstructor that takes ONLY an unsigned char* and an
integral value. He passed a unsigned char* and the integer 12.

[Ron Natalie]

Alf P. Steinbach wrote:

* 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.

It is correct.

[Alf P. Steinbach]

* Ron Natalie:

Alf P. Steinbach wrote:

* 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.

It is correct.

Nope.

--
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?

[roberts.noah]

Mi************* @tomtom.com wrote:

Bob Hairgrove wrote:

On Fri, 02 Dec 2005 11:04:26 GMT, al***@start.no (Alf P. Steinbach)
wrote:

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

That is incorrect.

// test_uchar.cpp

#include <iostream>
#include <ostream>
#include <string>

int main()
{
const unsigned char msg[] = "Hello";
std::string s(msg);
std::cout << msg << std::endl;
}

Does that compile on your system?

Nope. However, this does:

#include <string>
const unsigned char msg[] = "Hello";
std::string s(msg,msg+sizeo f(msg));

The statement you're tyring to prove is: "
std::string has no constructor that takes one argument, of type
unsigned char*.
" That statement is of course true, but not really relevant.

Actually it is pretty obvious that std::string has no constructor that
takes unsigned char* as an argument just by looking at its
constructors... none of them take an unsigned char* as an argument. The
fact that you can pass one as an argument to some of these constructors
is a consequence of a language feature, mainly that it will
automatically do some conversions for you. The very important
distinction here is that unsigned char* is being converted to something
else, which is then passed as an argument to the function being called;
in other words no matter how you slice it the constructor is never
actually given an unsigned char* as it wouldn't accept it.

Not that I'm not enjoying this "No it doesn't," "Does too," "Does
not...,"method of arguing. It can be quite entertaining until
eventually it becomes annoying.