Best way to create a string buffer for binary data

Question

When I try the following, I get an error:

unsigned char * data = "00000000"; //error: cannot convert const char to unsigned char

Is there a special way to do this which I'm missing?

Update

For the sake of brevity, I'll explain what I'm trying to achieve:

I'd like to create a StringBuffer in C++ which uses unsigned values for raw binary data. It seems that an unsigned char is the best way to accomplish this. If there is a better method?

Can your StringBuffer be achieved with a standard `std::string`? — Oliver Charlesworth, Dec 11 '11 at 21:47
It has to be raw binary data, though. That's the issue - I'd like something more 'type safe'. — zeboidlund, Dec 11 '11 at 21:48
@Holland - you COMPLETELY changed the question. If you've got a method that expects "unsigned char *", then you DON'T want to pass a pointer to a string literal (the point everybody was trying - and apparently failing - to make with "const char *"). And you CERTAINLY don't want "std::vector<>". At least not for a method requiring "unsigned char *" ;)! — paulsm4, Dec 12 '11 at 00:58
@paulsm4: Why can't he use a vector with a method requiring an unsigned char pointer? What's wrong with &data[0]? — Benjamin Lindley, Dec 12 '11 at 03:39
@BenjaminLindley would I have to use delete to free that pointer in the end, or should I use something else to take care of it? — zeboidlund, Dec 12 '11 at 03:40
@Holland: What pointer? The one obtained by `&data[0]`? No, that will be taken care of by vector's destructor. — Benjamin Lindley, Dec 12 '11 at 03:46
@BenjaminLindley. No, I mean the `unsigned char *` parameter in the function. — zeboidlund, Dec 12 '11 at 04:49

Oliver Charlesworth · Answer 1 · 2011-12-11T21:48:52.873

2

Yes, do this:

const char *data = "00000000";

A string literal is an array of char, not unsigned char.

If you need to pass this to a function that takes const unsigned char *, well, you'll need to cast it:

foo(static_cast<const unsigned char *>(data));

edited Dec 11 '11 at 21:48

answered Dec 11 '11 at 21:38

Oliver Charlesworth

267,707
33
569
680

I need to pass an unsigned char to a function, though. I've tried that, and it results in error. – zeboidlund Dec 11 '11 at 21:39
@Holland: The best thing to do would be to change your function to take a `const char *`. Failing that, you will have to perform a cast somewhere. – Oliver Charlesworth Dec 11 '11 at 21:45
1

The downvoter is probably himself, since he didn't like your answer – Shahbaz Dec 11 '11 at 21:45
@Shahbaz: Well, he should modify his question to make his constraints clear! (Ah, I see that he has done now.) – Oliver Charlesworth Dec 11 '11 at 21:46
He want's an `unsigned char *`. How does creating a `const char *` solve that problem? – sth Dec 11 '11 at 21:48
No, I didn't down vote you. It was someone else. EDIT: it's rare for me to downvote people who answer my questions, since I appreciate the time they take to contribute. – zeboidlund Dec 11 '11 at 21:49
@sth: The constraints weren't clear when I first answered the question. – Oliver Charlesworth Dec 11 '11 at 21:49
@Oli: The question title explicitly asked for "unsigned char", that seemed clear to me... (but maybe there were quick edits in the first minutes or such.) – sth Dec 11 '11 at 22:09
@sth: TBH, that could have been the original title; but I never really bother reading the title! – Oliver Charlesworth Dec 11 '11 at 22:16

AusCBloke · Answer 2 · 2011-12-11T21:58:41.497

2

unsigned char data[] = "00000000";

This will copy "00000000" into an unsigned char[] buffer, which also means that the buffer won't be read-only like a string literal.

The reason why the way you're doing it won't work is because your pointing data to a (signed) string literal (char[]), so data has to be of type char*. You can't do that without explicitly casting "00000000", such as: (unsigned char*)"00000000".

Note that string literals aren't explicitly of type constchar[], however if you don't treat them as such and try and modify them, you will cause undefined behaviour - a lot of the times being an access violation error.

edited Dec 11 '11 at 21:58

answered Dec 11 '11 at 21:42

AusCBloke

18,014
6
40
44

nitpick: The type of string literal is an array, not a pointer. – Benjamin Lindley Dec 11 '11 at 21:45
@BenjaminLindley: Yeah, let me reword the answer. – AusCBloke Dec 11 '11 at 21:48

Shahbaz · Answer 3 · 2011-12-11T21:50:26.600

You have many ways. One is to write:

const unsigned char *data = (const unsigned char *)"00000000";

Another, which is more recommended is to declare data as it should be:

const char *data = "00000000";

And when you pass it to your function:

myFunc((const unsigned char *)data);

Note that, in general a string of unsigned char is unusual. An array of unsigned chars is more common, but you wouldn't initialize it with a string ("00000000")

Response to your update

If you want raw binary data, first let me tell you that instead of unsigned char, you are better off using bigger containers, such as long int or long long. This is because when you perform operations on the binary literal (which is an array), your operations are cut by 4 or 8, which is a speed boost.

Second, if you want your class to represent binary values, don't initialize it with a string, but with individual values. In your case would be:

unsigned char data[] = {0x30, 0x30, 0x30, 0x30, /* etc */}

Note that I assume you are storing binary as binary! That is, you get 8 bits in an unsigned char. If you, on the other hand, mean binary as in string of 0s and 1s, which is not really a good idea, but either way, you don't really need unsigned char and just char is sufficient.

You shouldn't be declaring `data` as a pointer-to-non-`const`. — Oliver Charlesworth, Dec 11 '11 at 21:45
Oli Charlesworth is right. Even if the casts make it compile, it could still fail catastrophically at runtime (if you try to modify "00000000"). — paulsm4, Dec 11 '11 at 21:50
You should prefer `uint32_t` or `uint64_t` to `int` and `long`. — Oliver Charlesworth, Dec 11 '11 at 21:52
I edited my answer. The fact that a string defined like this should not be modified was not a concern of this question, so I left it out for simplicity (and focus on what was the answer) — Shahbaz, Dec 11 '11 at 21:54

Benjamin Lindley · Accepted Answer · 2011-12-12T03:34:51.577

2

std::vector<unsigned char> data(8, '0');

Or, if the data is not uniform:

auto & arr = "abcdefg";
std::vector<unsigned char> data(arr, arr + sizeof(arr) - 1);

Or, so you can assign directly from a literal:

std::basic_string<unsigned char> data = (const unsigned char *)"abcdefg";

edited Dec 12 '11 at 03:34

answered Dec 11 '11 at 21:52

Benjamin Lindley

101,917
9
204
274

@OliCharlesworth: For a buffer of unsigned chars holding binary data, yes, really. Why not? – Benjamin Lindley Dec 11 '11 at 21:54
I'm fine with using a vector. I don't understand why you wouldn't just write `std::vector v(8, '0');`, though. – Oliver Charlesworth Dec 11 '11 at 21:57
@OliCharlesworth: I was thinking about if you later wanted to change the string to non-uniform data without worrying about the length of the string. You might want to use sizeof, followed by a copy. – Benjamin Lindley Dec 11 '11 at 21:59
@OliCharlesworth: Not this specifically, but as I said above, you follow it with a copy, e.g. : `std::vector v(sizeof("abcdefg") - 1); std::copy_n("abcdefg", sizeof("abcdefg") - 1, v.begin());` -- Okay, I realize now that I've typed that, it's a little more verbose than I was thinking, especially since I had to type "abcdefg" 3 times. But you see what I was thinking now, right? (Fixed it) – Benjamin Lindley Dec 11 '11 at 22:06

score 1 · Answer 5 · answered Dec 11 '11 at 21:39

1

You're trying to assign string value to pointer to unsigned char. You cannot do that. If you have pointer, you can assign only memory address or NULL to that.

Use const char instead.

answered Dec 11 '11 at 21:39

Tomáš Plešek

1,482
2
12
21

score 1 · Answer 6 · answered Dec 11 '11 at 21:52

Your target variable is a pointer to an unsigned char. "00000000" is a string literal. It's type is const char[9]. You have two type mismatches here. One is that unsigned char and char are different types. The lack of a const qualifier is also a big problem.

You can do this:

unsigned char * data = (unsigned char *)"00000000";

But this is something you should not do. Ever. Casting away the constness of a string literal will get you in big trouble some day.

The following is a little better, but strictly speaking it is still unspecified behavior (maybe undefined behavior; I don't want to chase down which it is in the standard):

const unsigned char * data = (const unsigned char *)"00000000";

Here you are preserving the constness but you are changing the pointer type from char* to unsigned char*.

score 0 · Answer 7 · answered Dec 11 '11 at 21:47

@Holland -

unsigned char * data = "00000000";

One very important point I'm not sure we're making clear: the string "00000000\0" (9 bytes, including delimiter) might be in READ-ONLY MEMORY (depending on your platform).

In other words, if you defined your variable ("data") this way, and you passed it to a function that might try to CHANGE "data" ... then you could get an ACCESS VIOLATION.

The solution is:

1) declare as "const char *" (as the others have already said)

  ... and ...

2) TREAT it as "const char *" (do NOT modify its contents, or pass it to a function that might modify its contents).

Best way to create a string buffer for binary data

7 Answers7

Response to your update