Confusing with * for pointer or array in C++?

lwinaung · #1 (**permalink**) 07-18-2008, 02:27 AM

I always confuse the usage of * in C++. I think sometime it uses as pointer and sometime it uses as array. I get trouble with these usage.

For Example:

void tokenize(char** name,int& num,char* buffer);

In this sentence char** name is for pointer or double array? I would like to know clearly the usage of pointer, reference(&) and array clearly.Thanks for every body who reply me.

LA

MrPickle · #2 (**permalink**) 07-18-2008, 11:29 AM

A pointer is used to point to a memory cell instead of creating a new variable at a new memory cell. This means that the pointer is always the value of whatever the memory cell's value is.

Now, each memory cell of our computer has it's own address, like your street or an estate for example. Now when you use & it gets the address of the variable instead of the value.

Try doing this for example:

Code:

foo = 5;
std::cout << &foo << std::endl;
std::cout << foo << std::endl;

You'll see that the first result is a series of numbers and letters, whereas the second result is 5.

Now for the array bit. When you pass an array to a function it doesn't take the value of the array, but points to the addresses of the memory cells that the array's data is stored in. So to answer your first question. char** name is pointing to a multidimensional array (double array as you called it), so it's a pointer.

Hope this helped

I'm no Bench, but I tried my best

lwinaung · #3 (**permalink**) 07-19-2008, 01:41 AM

Thank You so much for your help. I know about pointer clearly now. But I still confuse in some sentences of ** in program while I am studying. I will write down these later to ask you.

LA

Bench · #4 (**permalink**) 07-19-2008, 04:39 AM

the * symbol, when used in conjunction with a data type is always a pointer, and never an array. This rule goes without exception.

Unfortunately, C and C++ allow pointer syntax and array syntax to be mixed freely, allowing a programmer to create rather deceptive code which, on the face of it, creates a blurry distinction between arrays and pointers.

Often, a pointer variable is used to store the address of the first element in an array (Which can be used to calculate subsequent elements). Here is an example where pointer syntax and array syntax can be used interchangably, yet, on the face of it, you could be forgiven for thinking that the two are completely different

Code:

#include <iostream>
int main()
{
    int my_array[] = { 1, 2, 5, 10, 20, 50, 100, 200, 500 };
    int* my_pointer;
    my_pointer = my_array;
    
    std::cout << my_pointer[0] << std::endl;
    std::cout << *my_pointer << std::endl;
}

the above program should output

Quote:

1
1

Whenever you see anyone mention anything to do with "equivalence" between pointers and arrays, this is what they are talking about. More precisely, they should say that the syntax is equivalent. Arrays and pointers themselves are completely different.

Just to prove that i'm not making this up, here's the same scenario involving the 4th element in the array

Code:

#include <iostream>
int main()
{
    int my_array[] = { 1, 2, 5, 10, 20, 50, 100, 200, 500 };
    int* my_pointer;
    my_pointer = my_array;
    
    std::cout << my_pointer[3] << std::endl;
    std::cout << *(my_pointer+3) << std::endl;
}

The last line of the program may look a little unusual if you're uneasy with pointers - though it has the same effect as my_pointer[3], just using pointer arithmetic, rather than array subscript notation

- Pointer arithmetic is a facility which C/C++ provides in order to take any address in memory, and step over a certain number of bytes in order to reach some other address. The smallest number of bytes which you may step over in any single calculation is exactly equal to the sizeof the pointed-to object.
- for int* the "step size" in bytes is sizeof(int)
- for char* the "step size" in bytes is sizeof(char)
etc

So, remembering that my_pointer merely stores an address in memory - the program's code shows that my_pointer has type int*. When adding 3 to the address stored in my_pointer, the final address value will be the value of my_pointer plus 3 lots of sizeof(int)

if my_pointer happened to be an address value of 02000 (decimal), and sizeof(int) happened to be 4, the final address value would be 02012 decimal
(Although its extremely rare to actually need to know, or care, what the absolute address values are, since memory is allocated at runtime)

- Back on topic as to how this fits in with arrays; The most important feature of an array is that arrays are contiguous memory blocks. This is important, because, if you know the size of the individual elements, and you know the address of the first element, then pointer arithmetic empowers you to calculate the addresses of all other elements within your array.
This is essentially how your CPU 'knows' where each element of an array is - But, luckily, C and C++ don't require the programmer to get involved, because subscript notation does it all for you!

Thread Tools
Show Printable Version Email this Page
Display Modes
Linear Mode Switch to Hybrid Mode Switch to Threaded Mode

The Following User Says Thank You to MrPickle For This Useful Post:
lwinaung (07-19-2008)