General question: What to pass as pointer in C/C++?

Hey there, I wonder if it's worth passing primitive single values like int, float, double or char by pointer? Probably it's not worth!? But if you would simply pass everything by pointer, is this making the program slower? Should you always just pass 开发者_运维百科arrays as pointer? Thanks!

I wonder if it's worth passing primitive single values like int, float, double or char by pointer?

What are you trying to accomplish? Do you want to be able to write to the passed in value? Or do you just need to use it? If you want to write to it, the idiomatic way is to pass by reference. If you don't need to write to it, you're best avoiding any risk that you'll write to it accidentally and pass by value. Pass by value will make a copy of the variable for local use. (as an aside, if you don't want to make a copy AND want some level of safety, you can pass by const reference)

But if you would simply pass everything by pointer, is this making the program slower?

Difficult to say. Depends on a lot of things. In both pass by value and pass by reference (or pointer) your making a new primitive type. In pass by value, you're making a copy. In pass by reference/pointer you're passing an address to the original. In the latter case, however, you're requiring an extra fetch of memory that may or may not be cached. Its very difficult to say 100% without measuring it.

That all being said, I doubt the difference is even noticeable. The compiler may be able to optimize out the copy in many pass-by-value cases, as indicated in this article. (thanks Space C0wb0y).

Should you always just pass arrays as pointer?

From this.

In C++ it is not possible to pass a complete block of memory by value as a parameter to a function, but we are allowed to pass its address.

To pass an array:

 int foo(int bar[], unsigned int length)
 {
       // do stuff with bar but don't go past length
 }

I'd recommended avoiding arrays and using std::vector which has more easily understood copy semantics.

It's probably not worth passing primitive values by pointer if your concern is speed -- you then have the overhead of the "indirection" to access the value.

However, pointers often are the "width of the bus", meaning the processor can send the whole value at once, and not "shift" values to send-down-the-bus. So, it is possible pointers are transferred on the bus faster than smaller types (like char). That's why the old Cray computers used to make their char values 32 bits (the width of the bus at that time).

When dealing with large objects (such as classes or arrays) passing pointer is faster than copying the whole object onto the stack. This applies to OOP for example

Look in your favorite C++ textbook for a discussion of "output parameters".

Some advantages of using a pointer for output parameters instead of a reference are:

• No surprising behavior, no action at a distance, the semantics are clear at the call site as well as the caller.

• Compatibility with C (which your question title suggests is important)

• Usable by other languages, functions exported from a shared library or DLL should not use C++-only features such as references.

You should rarely have to pass anything by pointer. If you need to modify the value of the parameter, or want to prevent a copy, pass by reference, otherwise pass by value.

Note that preventing a copy can also be done by copy-elision, so you have to be very careful not to fall into the trap of premature optimization. This can actually make your code slower.

There's is no real answer to your question except few rules that I tend to bare in mind: char is 8 bytes and a pointer is 4 bytes so never pass a single char as a pointer. after things like int and float are the same size as a pointer but a pointer has to be referenced so that technically takes more time

if we go to the pentium i386 assembler:

loading the value in a register of a parameter "a" in C which is an int:

movl 8(%ebp),%eax  

the same thing but passed as a pointer:

movl 8(%ebp),%eax
movl (%eax),%eax

Having to dereference the pointer takes another memory operation so theorically (not sure it is in real life) passing pointers is longer... After there's the memory issue. If you want to code effectively everything composed type (class,structure,arrays...) has to be passed by pointer. Just imagine doing a recursive function with a type of 16bytes that is passed by copy for 1000 calls that makes 16000 bytes in the stack (you don't really want that do you ? :) )

So to make it short and clear: Look at the size of your type if it's bigger than a pointer pass it by pointer else pass it by copy...

Pass primitive types by value and objects as const references. Avoid pointers as much as you can. Dereferencing pointers have some overhead and it clutters code. Compare the two versions of the factorial function below:

// which version of factorial is shorter and easy to use?

int factorial_1 (int* number)
{
  if ((*number) <= 1)
    return 1;
  int tmp = (*number) - 1;
  return (*number) * factorial_1 (&tmp);
}

// Usage:
int r = 10;
factorial_1 (&r); // => 3628800


int factorial_2 (int number)
{
  return (number <= 1) ? 1 : (number * factorial_2 (number - 1));
}

// Usage:
// No need for the temporary variable to hold the argument.
factorial_1 (10); // => 3628800

Debugging becomes hard, as you cannot say when and where the value of an object could change:

int a = 10;
// f cound modify a, you cannot guarantee g that a is still 10.
f (&a); 
g (&a);

Prefer the vector class over arrays. It can grow and shrink as needed and keeps track of its size. The way vector elements are accessed is compatible with arrays:

int add_all (const std::vector<int>& vec)
{
    size_t sz = vec.size ();
    int sum = 0;
    for (size_t i = 0; i < sz; ++i)
        sum += vec[i]; 
}

NO, the only time you'd pass a non-const reference is if the function requires an output parameter.