Am I reading this right? such as an array of pointers, or an a pointer to 300pointer

Hello everyone!

I was just curious if i'm reading this right? My C++ professor, said, create a function to accept an array of pointers, now if i had

void (int *x);
and inside the function i wrote,

x = new int[300]; I understand that this creates 300 memory locations on the heap, so really its creating an array, and x is pointing to the first element of the array right?
because x is really &x[0];

now if i would have wrote:
void (int*x[]); is this what he really wanted? I thought this would be a pointer to a pointer, becuase isn't like that like
void (int **x); or am i confusing myself?
I remember I came across this nice tutorial that tells you how to approach such problems, but I lost it! :(

Thanks for listening!


Also he said, make a class cubes, then make an array of 300 cube objects, are these equivlent other then one being on the heap and one being on the stack?

Cube * cubes[300]; //an array of 300 pointer objects
Cube * cubes = new Cube[300]; //a pointer pointing to 300 cube objects

Pointers are confusing but heres how you would do it.

Declare a function of type int which accepts an argument of type pointer to int.

int func (int * x);
int func (int x[]);

N.B. X can be an address of a single variable or it can be the address on an int inside an array.

Declare a function of type int which accepts an argument of type pointer to an array of int's:

int func (int (* x)[]);
int func (int **x);

N.B Again X can be a single pointer which points to an int or it can be a pointer array of type type int.

Declare a function of type int which takes an argument of type array of pointers to int (* thats an array containing pointers to integer *)

int func (int * x[]);
int func (int * x);

Notice how the second is identical to the first example.

Hope this helps.

Quote:

---

I understand that this creates 300 memory locations on the heap, so really its creating an array, and x is pointing to the first element of the array right?

---

In essence right, but it actually creates one memory location large enough for 300 ints and returns the start address of this location. Of course, due to this it is also the address of the first element.

Quote:

---

because x is really &x[0];

---

No, x is equivalent to &x[0] and has the same value, but x is x.

Quote:

---

void (int*x[]); is this what he really wanted? I thought this would be a pointer to a pointer, becuase isn't like that like
void (int **x); or am i confusing myself?

---

You are confusing yourself. Myself, I really don't like the [] syntax for parameters.
Your professor wants the function to take an array of pointers. An arrays is passed as a pointer, so you end up with a pointer to pointers. int ** is quite the correct type, but there should always be a length argument to go along with the pointer.

Quote:

---

Cube * cubes[300]; //an array of 300 pointer objects

---

That's an array of 300 Cube pointers. It is not equivalent to the second, which is a pointer to a memory location that contains 300 Cube objects.

visualAd: I hope that in your third example

Quote:

---

int func (int * x[]);
int func (int * x);

---

the missing second asterisks in the second line is a typo. Because otherwise the two are not equivalent.

THanks for the explanation guys it helped!
But from that explanation, I arrived at another query. If I had:

Code:

---

int func (int * x);

---

What all could be passed to the function? For instance, would this be allowed?
int *ar = {10,20,30};
func(ar);

int *ar = new ar[100];
func(ar);

and If I had
int **ar = {{10,20,30},{40,50,60},{70,80,90}};
func(ar); This would be illegal right? Because its a pointer to a pointer, and the parameter only accepts a pointer to an int?

and on the other hand,

Code:

---

int func (int **x);
//or
int func (int *x[]);

//legal right?
int **ar = {{10,20,30},{40,50,60},{70,80,90}};
func(ar);

//illegal right?
int *ar = {10,20,30};
func(ar);

//legal?
int *ar = new int[8][8];
func(ar)

---

Thanks!
:wave:

I'm not sure about the legality of the pointer initializations, the calls are legal.

To be more specific:
int func (int * x);
int *ar;
func(ar);
is legal. Definitly. The question is, are
int *ar = {10,20,30};
int *ar = new ar[100];
int **ar = {{10,20,30},{40,50,60},{70,80,90}};
legal? The second definitly is, but I'm not sure about the other two.

Same for the second:
int func (int **x);
int **ar = {{10,20,30},{40,50,60},{70,80,90}};
func(ar);
The func call is definitly legal. But is the initialization?
And
//legal?
int *ar = new int[8][8];
func(ar)
is completly illegal. For one, ar doesn't match the parameter type, for another, new int[8][8] is illegal.


But the easiest way to find out is to put it into a cpp file and compile it.