When to return a pointer, pass a pointer as a parameter or not use them at all?

I am currently experimenting with C, and I am having a really hard time understanding how to use pointers in functions. I understand what is happening when I initialize a pointer then dereferencing it, however, I get a little confused when I have to use them in functions as follows:

I have three functions here, but I do not know exactly when to use which. I am still relatively new to C.

int returnSomething(int a, int b)
int returnSomething(int *ptrA, int *ptrB)
int* returnS开发者_StackOverflow中文版omething(int *ptrA, int *ptrB);

edit:

Is there a major difference between the three?

You need to adapt your usage to every situation.

The first case, you take two ints by value as parameters and return an int. Because your parameters are by value, any changes applied to them will only have function scope.

For example:

int returnSomething(int a, int b)
{
    a = 0;
    b = 0;
    return 0;
}

//....

int x = 3;
int y = 4;
returnSomething(a,b);
// x will still be 3, y will still be 4

In the second case, because you pass parameters as pointers, you will be able to change the values.

int returnSomething(int* a, int* b)
{
    *a = 0;
    *b = 0;
    return 0;
}

//....

int x = 3;
int y = 4;
returnSomething(&a,&b);
// x and y will be 0 here

The third case, besides passing parameters by their pointer, you return a pointer to an int. This means inside the function you have to allocate memory and free it when you are done. I don't recommend using this, there usually are workarounds to doing it.

int* returnSomething(int* a, int* b)
{
   int* x = malloc(sizeof(int));
   *x = 1;
   return x;
}

//....

int x = 3;
int y = 4;
int* z = returnSomething(&a,&b);
free(z);

The answer is, it depends on what you want to do. If you need to change the parameters value in the method, pass by reference or by pointer. I wouldn't recommend using the last method.

Also, this applies because you're dealing with POD types. If you have your own struct, it will be more efficient passing it by pointer or returning a pointer, since a new copy won't have to be made.

Let's explain passing by reference to you first; it's a lot less complicated to deal with.

Say you have:

int increment(int &a)
{
    a = a + 1;
    return a;
}

increment(foo); // foo = foo + 1;

(NOTE: To make it easier to understand, I've sacrificed some 'correctness'.)

This does two things:

• The third line increments a by 1. But notice - we put &a in the function declaration. This means that the value passed to increment() "by reference" is also incremented by 1. In other words, foo increases by 1, just like a.
• The fourth line returns the value of a - a number, such as 1, 2, 42, -21, etc.

One more thing: Passing by reference is C++; you can't use it in C, but it's a good concept to learn before you start messing with pointers.

Passing a pointer is basically just passing by value... except you're passing the location in memory (0x12345678), as opposed to the actual foo.

int pincrement(int *p)
{
    *p = *p + 1;
    return *p;
}

pincrement(&foo); // foo = foo + 1;

This does the same thing as our first program - it increments the value of foo.

• The &foo tells you the address of foo in memory. This information is passed to p. So:

  p = &foo;
  

• On the third line, the value pointed to by *p is incremented. In other words, foo is incremented by 1.

• The fourth line returns the value of foo - a number, such as 1, 2, 42, -21, etc.

For returning pointers, you could use them to return strings:

char *HelloWorld()
{
    return "Hello, World!";
}

The answer to your question has more to do with memory considerations and good code design i.e. whether you'd like to conserve resources and if you are aware of what's going on in your code at any one instance in time. 1) when you pass by value ( int returnSomething(int a, int b) ) every parameter is a copy and any changes made to them doesn't affect the original variable outside of the function (The parameters have function scope), and the function returns a value which you can then use to initialise a variable.

2) When you pass by pointer, you're passing an address to a location in memory so remember that as a matter of good code design you have to insulate that location against modification by another external (lock semantics) process. This especially applies to your provided examples:

int returnSomething(int *ptrA, int *ptrB)
int* returnSomething(int *ptrA, int *ptrB);

wherein changes made to *ptrA and *ptrB within the function persists after the function exits. The only difference between the two is that one of the functions return a value which you can then use to initialise a variable ( int returnSomething(int *ptrA, int *ptrB) ), the other returns another address to a location in memory that maybe subject to change and/or garbage headaches depending on your program design (you create memory inside the function for the return type and assign that address to a pointer variable, the pointer variable itself can be arbitrarily changed to point to another location in memory, e.t.c.). I'll expand on Luchian's last example by adding: imagine some somewhere else in your code you pass the *z variable to another function which then tries to use the memory pointed to by that address, you now have a pointer variable pointing to nothing which you then try to use.

It all boils down to good code design. If you understand the pros and cons of pointers and use them appropriately then you'll have no issues.

Luchian Grigore has written some good description above. I would like to give you a small thought to further simplify your thinking.

When ever you pass a argument to a function in C, try to think what exactly goes on to the stack ( in case 1, actual integer variables gets pushed onto stack and in case 2 & 3 adresses of those integer variables gets pushed ), now to this combine that fact that changes made to variables on stack vanish as soon as the control returns from funciton and stack unwindes.

So in simple terms if you plan to change the varibales being passed inside the function and expect to use those changes later then consider passing the address of those varibles, else simply pass variables.

For int, always pass by value unless it is not possible to do so. i.e int returnSomething(int a, int b).

When you are passing some custom big struct, pass it and return it as a pointer unless it is not possible to do so.