Printable View
What is the difference between sending a pointer as, say, an argument, vs. just sending a copy of the data?
Example:
Thanks!Code:void send_me_a_string_pointer(string* pointer){
std::cout<<(*pointer)<<"\n";
}
vs.
void send_me_a_string_copy(string copy){
std::cout<<copy<<"\n";
}
You could do things like
- declare your own class, with cout statements in the constructor/destructor
- use sizeof on the parameter in the function
- try calling your function taking a pointer with NULL as a parameter
Sometimes, the object which you wish to pass to the function is very expensive to copy.
What if the string passed to send_me_a_string_copy was the Declaration of Independence or something
ridiculously long! It would waste memory as well as time to copy such a long chunk of data. In this case,
the average sized string usually won't take too long to copy. However, if you are passing another object
that is always bulky or you are calling this function 10,000 times, then you might stand to benefit
from passing by pointer.
What about passing by reference?
It's true that passing by reference or constant-reference can have the same effect, but passing an
object by pointer allows you to pass a NULL value if you wish. Passing by copy or reference REQUIRES
you to actually possess a string object. It might be best for your function to have some sort of default
behavior if you didn't have such an object.
Not calling a function if you "didn't have such an object" would eliminate any such need.Quote:
Originally Posted by DrPiratePhD
I know for sure that you won't be able to tell the difference if displaying a string is all you're going to do with a copy or a pointer.Quote:
Originally Posted by Shokwav
You might need a copy of an object if a function argument is going to be changed. If you change a copy of the object, the changes will not persist past the end of the function, so it's one way to protect yourself. If you want the changes the function makes to persist after the function ends, pass-by-reference semantics (which includes the use of pointers) is necessary.
but I'm sure you realize that there are situations where you want to call the function whether you have the object or not, and handle a null in a special way.Quote:
Originally Posted by grumpy
Sure but that is a design choice. Either way, a decision has to be made as to whether an object is valid. The only difference is whether caller or callee makes that determination. Sometimes it makes sense for the caller to do it (eg if a function is called many times and supplied with the same object) and sometimes for the callee to do it.Quote:
Originally Posted by Elkvis
Pass by value (sending a copy as you call it) is typically slower performance-wise and does not allow you to modify the original thing passed,
Pass by pointer is typically faster and does allow you to modify the thing passed in. It also allows the thing being passed in to be optional (i.e. it can be NULL).
In this case the best option is to pass by reference, or more specifically by const-reference. No slow copying occurs, no modifications can be made, and the value is not optional.