Why can't I pass by pointer

Quote:

---

Pointer-to-pointer has multiple interpretations (2D-array for example), so it's not always obvious that it means that a value may be returned.

---

That is not right. Pointer-to-pointer is totally a different thing from a 2-D array or a pointer to a 2-D array. Try casting a pointer to a 2D array to a pointer-to-pointer. You CAN'T. Even in the case of 1D, you may cast a pointer to a 1D array to a pointer, it is still worth pointing out that pointer and 1D array are DIFFERENT things. Any one failing to see that should fail a job interview.

a[0] may or may not be valid depending how a is declared. If a is an array, then it is valid. If a is a pointer, a[0] may not be valid.

A pointer-to-pointer has only ONE possible interpretation:

Step1.Use this pointer-to-pointer, suppose it point to a valid address (The pointer-to-pointer is neither NULL nor point to invalid address), you may fetch (or store back) a pointer.

Step2.Use the pointer fetched in step1, suppose it is a valid pointer, (The pointer value is neither NULL nor point to invalid address) You can fetch (or store back) a value of the type. If there is a const modifier before the pointer-to-pointer declaration (const int ** mypp;), then you can noly fetch but not store back.

Nothing in the pointer-to-pointer implies any thing that may be an array. Actually to access elements in a 2D array you follow different steps:
1.take the x and y index of the element and use them to calculate an index. (index = y*X_DIMENTION + x)
2.Use the index to and treat the 2D array like 1-D array to fetch the value.

For example:

Code:

---

    int a[16][16];
    int b = a[1][2];

---

is actually implemented something like this 1D array:

Code:

---

    int a[16 * 16];
    int b = a[1*16 + 2];

---

Quote:

---

A better way would be to have it as the return value of the method using transfer-of-ownership with a smart pointer such as std::auto_ptr or boost::shared_ptr.

---

Very good point. Returning a pointer to, or reference to a generic
scoped automatic variable can be disastrous if the programmer
isn't familiar with the code structure.

Quote:

---

as well as removing the responsibility of deallocating the memory from both the caller and the allocater.

---

Another good point. We can get around scoping problems with
automatic variables by returning pointer to, or reference to
dynamically created variables. Although this leads the
forementioned problem: who is responsible for deallocating the
variable? Using smart pointers is clearly an improvement. The
notion of things like ownership and reference counting when
dealing with pointers is what makes our code much more robust
and less error prone.

Edit: Of course, returning variable by value is also safe.

regards, willchop

Quote:

---

Originally posted by AnthonyMai:
Any one failing to see that should fail a job interview.

---

Ask and ye shall receive.

--Paul

Quote:

---

Originally posted by AnthonyMai


That is not right. Pointer-to-pointer is totally a different thing from a 2-D array or a pointer to a 2-D array. Try casting a pointer to a 2D array to a pointer-to-pointer. You CAN'T. Even in the case of 1D, you may cast a pointer to a 1D array to a pointer, it is still worth pointing out that pointer and 1D array are DIFFERENT things. Any one failing to see that should fail a job interview.

---

You're arguing irrelevant semantics here; the main point Graham
was trying to make was:

Quote:

---

so it's not always obvious that it means that a value may be returned.

---

--Paul