Thread: Pointer for Beginner

Why don't you test? For example, you could print the value of variable after calling function2, and see if it is changed with the use of a pointer, and then without the use of a pointer.

By the way, we would more typically use a reference instead of a pointer parameter here.

Originally Posted by Greek_89

I tested it and it gives me the expected output but why use pointers or references? we could simply use regular variables.

Ah, that means that your expectations are not the same as ours. Let's make the example more explicit:

Code:

#include <iostream>

void foo(int& var)
{
    var = 10;
}

int main()
{
    int variable = 5;
    foo(variable);
    std::cout << variable << std::endl;
}

I expect the above program to print 10 when run, and it does. Since you claim that "we could simply use regular variables", change var to be an int instead of an int&, then compile and run. Do you still get 10 printed?

Originally Posted by Greek_89

we pass INTO the function "5", the parameter is "&var" so it shows the value "5"

Not quite: the parameter is named var, of type int& (i.e., reference to int). Since this is pass by reference, not pass by value, you do not pass 5, i.e., the value of variable as the argument: you pass the variable variable as the argument.

Originally Posted by Greek_89

but then "var" gets the value "10" so the output will be "10"

Since var is a reference, it is an alias of the argument, i.e., it is an alias for variable. Changing the value of var changes the value of variable.

Originally Posted by Greek_89

but WHY if i take off the "&" my output is "5"?

Removing the "&" makes var into a value parameter. Hence it is not an alias of the argument, and indeed it stores a copy of the argument's value. As such, changing var has no effect on variable.

You can repeat this reasoning for the use of a pointer, except that this time it would be *var that is an alias for variable.

there are two ways that you pass things to functions: pass by value, and by reference. You need to understand what these mean, right? Here is an example:

Code:

struct tes{
      int x, y, z;
};
void foocopy(tes var){
    // do something here, bla bla
}
void foorefer(tes& var){
 // do something here, bla bla
}

When you call foocopy(tes var) a brand new copy of the struct tes is made when the function is called, so if you did this:

tes v;
v.x=v.y=v.z=6;
foocopy(v);

no matter what you do to the variable inside foo, v will never change!, Why? Because you passed it by value, which means a NEW COPY is made when the function is called and that is what the function works with.... a copy!

BUT, if you do this :

tes v;
v.x=v.y=v.z=6;
foorefer(v);

A new copy is NOT made and anything you do inside the function foorefer ACTUALLY modifies v.


This is very usefull because sometimes you do not want to MODIFY the variable passed to a function, and sometimes you do. There is also SPEED considerations here. Each time a variable is COPIED, there is extra work. Passing something by reference is the fastest, because no copies are made or anything.

You need to know what POINTERS actually are first!

ANY pointer, of any type, i.e. int*, float*, tes* ANY pointer!!!! is really a memory address, or more Precisely, A NUMBER.

when you typed this in your code.............

function2(&variable);


the &variable will Get the Memory Address of variable and pass that to function2. pointers are memory addresses, mmkay?

so, when function2 runs, it receives the memory address ( also known as a pointer), called var. SINCE you did not pass by reference, A COPY IS MADE of the pointer, or memory address that was passed.

Well, what the hell does a * do then? A * in front of a pointer type GETS the value stored at the memory address that it holds. In this case, you are telling the compiler to place the value of 10 at the memory address held by var. var is holding the memory address of variable, which is why it changes!

Originally Posted by smasherprog

There is also SPEED considerations here. Each time a variable is COPIED, there is extra work. Passing something by reference is the fastest, because no copies are made or anything.

Not necessarily: the reference might be implemented using a pointer, and if so there will be the cost of copying a pointer. If the cost of copying the object is the same as that of copying a pointer, then it may actually be very slightly slower to pass by reference.