Pointers to pointers question

Hi, I would like to know if passing a pointer to a pointer is faster than passing a pointer by value... To make it clearer, let's take a look at these prototypes:

Code:

---

void abc(int a);
void abc(int& a);
void abc(int*a);
void abc(int** a);

---

So I just want to know, between these differences, what would it change to pass an int** when you could just use an int*? In other words, we know that the first line will have to make a copy of the variable and thus needing some more space in the program. But with the 2nd or 3rd lines, we pass an address so it doesn't have to take more memory copying the initial value... But a pointer too takes memory in the computer, (I believe) and so we can place a pointer to this pointer, but does that changes a thing? (int* -> int**)

Passing a pointer is still a pass by value. It behaves exactly like the first function. The only difference being that the variable copied will be a pointer to int, instead of an int.

Only C++ has pass by reference. Which is what you did on your second function.

There may be uses for pointer to pointers. One of the most common ones is if you have a pointer to a container of pointers. Regardless, passing a pointer to a pointer is one way of simulating a pass by reference of a.

But about memory usage/speed, in this case there is no difference?

And I got some other question: how do you pass an array of member-functions pointers by
reference? I think I'd know how to tell it should become a pointer expression, but in the parameters
I don't know how to write it:

Code:

---

void        (*Func_Ptrs[10])(void*);

//would something like this work?
void* Name(**??)(void*);
Name = Func_Ptrs;

---

Quote:

---

Originally Posted by mikahell

But about memory usage/speed, in this case there is no difference?

---

Memory usage or speed should really not be your concern when deciding what type of parameters you are going to provide your function with. What should be in your mind is what you want the function to do...

. You want it to return an lvalue? Your function should return a reference or pointer.
. You want one of the parameters to have its value changed and that change to stick to the variable after the function ends? You should accept a reference or pointer.
... etc ...

Of course, some objects are better passed by reference or pointer, no matter what. You surely don't want to pass by value a container with 10,000 doubles, or a string with 10 pages of a book. But your concern is what you want your function to do. Reason and common sense will dictate the rest.

Quote:

---

void (*Func_Ptrs[10])(void*);
//would something like this work?

---

I don't know and I don't even care :)
As long as I don't need pointers to functions to do my programming, I plan to stay away from them as much as I can.

All arguments are passed by value in C++.

No they are not.

Maybe you mean in C

Well, if you don't care, does anyone else care?

Well, everyone should care if suddenly all arguments in C++ could only be passed by value.

>I would like to know if passing a pointer to a pointer is faster than passing a pointer by value...
Unlikely. Either way you're passing a pointer, so the difference in space and time costs should be negligable.

>how do you pass an array of member-functions pointers by reference?
Making sure to keep your sanity in check, you would do it like this:

Code:

---

class class_type {
public:
  void m_foo();
};

typedef void (class_type::*mf)();

void foo ( mf (&array)[10] )
{
  // Blah blah
}

int main()
{
  mf array[10];

  foo ( array );
}

---

Whatever you do, don't ask for the same code without the typedef. It's extremely nasty, and no reasonable programmer would be caught dead writing it. ;)

Hmm, all these foos got me mixed up.... But I'll try to understand your code

A reference holds the address of an object, but behaves syntactically like an object.
It is often more efficient to pass references, rather than large objects, to functions. This allows the compiler to pass the address of the object (by value) while maintaining the syntax that would have been used to access the object.