reinterpret_cast <int *> （字符*）

Question

When dynamically allocating a buffer of type char * and when you want to cast it to a particular type, should you use:

reinterpret_cast<int *>(char *)

or:

static_cast<int *>(static_cast<void *>(char *))

and why?

Answer 1

This *pk = new int(2); should be pk instead of *pk

After you've declared a pointer int * pointer , all references to point refer to an address and all references to *pointer refer to what's contained at the address. By default, pointers don't point to valid memory locations, you have to assign a valid address or make a call to new . This is why when you write pk = &k , there is no segmentation faults - because pk now contains the address of k , which points to a valid memory location.

The syntax for pointers can be a little confusing, mainly because * can have multiple meanings, depending on how you use it. Here's a quick explanation:

• In declarations, * means you are declaring a pointer (ie int * pk ).
• In between to numerical data types, * is the symbol for multiplication (ie 4 * num ).
• Written next to a variable, it returns the value at the address that the pointer contains (ie *myPointer or (*mypointer) ).

Since new returns an address, you are assigning an address to pk instead of a value pointed by pk .

If you wish to initialize a pointer, declare it with a new statement. Like this:

int * pk = new int;

But there is no compile time feature that declares a self-contained pointer and value. The closest you'll come to that is by declaring separate variable, as you have done, and initialize the pointer with the address of that variable. Like this:

int num = 43;
int * p = # 

Answer 2

• Can you explain me what's going on here?

You use unitialized variable: http://en.wikipedia.org/wiki/Uninitialized_variable

int* pk;  // declare variable `pk` of type `int*` but do not initialize it
*pk = 2;  // use unitialized variable. `*` is dereference operator. Seg fault
int k;    // declare variable `k` of type `int`, not initialized
pk = &k;  // initialize variable `pk` with address of variable `k`
*pk = 3;  // use initialized variable. Ok now

Dereference operator: http://en.wikipedia.org/wiki/Dereference_operator

Answer 3

int* pk = nullptr;

Here you are declaring that pk is a pointer to an int .

*pk = new int(2);

The type of *pk is int and the return type of new int(2) is int* .

Answer 4

pk is the pointer while *pk is the value to which it points.

So change your code to,

int* pk = new int;

pk = reinterpret_cast<int*>(2);

When assigning to pk the right-hand side must be a pointer, for *pk it must be an integer.

Answer 5

How can I initialize a pointer with a value?

You don't. That's the point of having a pointer. You don't initialize it with value. You initialize it with variable address .

Let's analyze it step by step:

int* pk;

You have a pointer, and it's uninitialized, so now it's worse than useless.

int* pk = nullptr;

Much better, at least you can check with an if statement if it points to anything.

if(pk)
{
    //do operations on pointed value *pk
}
else
{
    //Houston, we have a problem
}

For now, these operations make no sense

*pk = 2; //you haven't pointed with pk to anything
*pk = reinterpret_cast<int*>(2); //????? *pk is int, and right-hand side is int*. What do you expect to do with it?

This code works

int k;
pk = &k;
*pk = 3;

because you actually pointed pk to something meaningful.