Hi,
I have this clarification. if we are passing arguments to a function, is it better to work completely with the arguments or create a local copy of the argument and work with the copy of the argument.
For example
ThanksCode:int main(void) { uint8_T var=0; dummy_function (&var); } void dummy_function(uint8_T *a_var_u8) { uint8_T *p_localcopy_u8 = a_var_u8; // use a_var_u8 or // use p_localcopy_u8 // for the remaining programming }
satya
There is a difference between passing argument; and passing a argument by address/pointer!
Tim S.
"...a computer is a stupid machine with the ability to do incredibly smart things, while computer programmers are smart people with the ability to do incredibly stupid things. They are,in short, a perfect match.." Bill Bryson
The function's parameters are variables local to the function. Do you need a copy? If you don't, then why bother?Originally Posted by Satya
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Yes. But my question is whether i pass argument or argument by address/ pointer, at the function definition there is a variable inside the parenthesis can i use the name of the same variable or it is better to make a copy of the same and use the name of that variable?
Code:function(int var) { printf("%d",var); } // is better or function (int var) { int temp=var; printf("%d",temp); } similarly for pointers void function(int *p) { int value = *p; printf("%d",value); } or void function(int *p) { int *temp = p; value = *temp; printf("%d",value); }
If the latter is better than the former, then this is even better:
Code:void function(int var) { int temp0 = var; int temp1 = temp0; int temp2 = temp1; int temp3 = temp2; int temp4 = temp3; int temp5 = temp4; int temp6 = temp5; int temp7 = temp6; int temp8 = temp7; int temp9 = temp8; printf("%d", temp9); }In this particular trivial example, it would be better to just use *p. That said, sometimes it does make sense to copy what the pointer points to to a local object, e.g., you are dealing with a pointer to a pointer that is pretty much always dereferenced in the body of the function, so instead of writing:
you might write:Code:void function(int **p) { *p = malloc(etc); /* use *p and (*p)[i] here and there */ }
Code:void function(int **p) { int *q = malloc(etc); /* use q and q[i] here and there */ *p = q; }
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Well if you're really worried about changing something when you shouldn't, declare it const
void dummy_function(const uint8_T *a_var_u8)
If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
If at first you don't succeed, try writing your phone number on the exam paper.
That depends on what your criterion is for "better". Better is not an absolute. Is a green car better than a blue one? Only if you like green cars. [Of course, red cars are always better, because they are faster].
It is sometimes appropriate to copy arguments, depending on what the function is actually doing. To state the obvious, if the required effects can be achieved without creating a local copy, then it is not necessary to create a local copy. If the code is more understandable by working with a local copy, the there is nothing wrong with that.
If the function needs to perform rollback (performs a lot of operations, with reversion to original state if any of those operations fail) then one way is to store original values, and write them back if needed. Alternatively, a copy might also be made, and all operations performed on the copy, which is only written to the argument at the end once all other operations have succeeded. Another approach is for the function might track completely different data about operations performed, so it can literally unwind the operations performed (in which case it won't store copies of the original arguments, but will store other data so it can do the rollback).
