Proper Way To Initialize Unsigned Char*

W开发者_StackOverflow社区hat is the proper way to initialize unsigned char*? I am currently doing this:

unsigned char* tempBuffer;
tempBuffer = "";

Or should I be using memset(tempBuffer, 0, sizeof(tempBuffer)); ?

To "properly" initialize a pointer (unsigned char * as in your example), you need to do just a simple

unsigned char *tempBuffer = NULL;

If you want to initialize an array of unsigned chars, you can do either of following things:

unsigned char *tempBuffer = new unsigned char[1024]();
// and do not forget to delete it later
delete[] tempBuffer;

or

unsigned char tempBuffer[1024] = {};

I would also recommend to take a look at std::vector<unsigned char>, which you can initialize like this:

std::vector<unsigned char> tempBuffer(1024, 0);

The second method will leave you with a null pointer. Note that you aren't declaring any space for a buffer here, you're declaring a pointer to a buffer that must be created elsewhere. If you initialize it to "", that will make the pointer point to a static buffer with exactly one byte—the null terminator. If you want a buffer you can write characters into later, use Fred's array suggestion or something like malloc.

As it's a pointer, you either want to initialize it to NULL first like this:

unsigned char* tempBuffer = NULL;
unsigned char* tempBuffer = 0;

or assign an address of a variable, like so:

unsigned char c = 'c';

unsigned char* tempBuffer = &c;

EDIT: If you wish to assign a string, this can be done as follows:

unsigned char myString [] = "This is my string";
unsigned char* tmpBuffer = &myString[0];

If you know the size of the buffer at compile time:

unsigned char buffer[SIZE] = {0};

For dynamically allocated buffers (buffers allocated during run-time or on the heap):

1.Prefer the new operator:

unsigned char * buffer = 0;  // Pointer to a buffer, buffer not allocated.
buffer = new unsigned char [runtime_size];

2.Many solutions to "initialize" or fill with a simple value:

std::fill(buffer, buffer + runtime_size, 0); // Prefer to use STL
memset(buffer, 0, runtime_size);
for (i = 0; i < runtime_size; ++i) *buffer++ = 0;  // Using a loop

3.The C language side provides allocation and initialization with one call.
However, the function does not call the object's constructors:

buffer = calloc(runtime_size, sizeof(unsigned char))

Note that this also sets all bits in the buffer to zero; you don't get a choice in the initial value.

It depends on what you want to achieve (e.g. do you ever want to modify the string). See e.g. http://c-faq.com/charstring/index.html for more details.

Note that if you declare a pointer to a string literal, it should be const, i.e.:

const unsigned char *tempBuffer = "";

If the plan is for it to be a buffer and you want to move it later to point to something, then initialise it to NULL until it really points somewhere to which you want to write, not an empty string.

unsigned char * tempBuffer = NULL;
std::vector< unsigned char > realBuffer( 1024 );
tempBuffer = &realBuffer[0]; // now it really points to writable memory
memcpy( tempBuffer, someStuff, someSizeThatFits );

The answer depends on what you inted to use the unsigned char for. A char is nothing else but a small integer, which is of size 8 bits on 99% of all implementations.

C happens to have some string support that fits well with char, but that doesn't limit the usage of char to strings.

The proper way to initialize a pointer depends on 1) its scope and 2) its intended use.

If the pointer is declared static, and/or declared at file scope, then ISO C/C++ guarantees that it is initialized to NULL. Programming style purists would still set it to NULL to keep their style consistent with local scope variables, but theoretically it is pointless to do so.

As for what to initialize it to... set it to NULL. Don't set it to point at "", because that will allocate a static dummy byte containing a null termination, which will become a tiny little static memory leak as soon as the pointer is assigned to something else.

One may question why you need to initialize it to anything at all in the first place. Just set it to something valid before using it. If you worry about using a pointer before giving it a valid value, you should get a proper static analyzer to find such simple bugs. Even most compilers will catch that bug and give you a warning.