Passing an array as argument to a function
-
Hi What is the syntax when you want to pass an array as argument? I`m looking for syntax for both function call and function definition.
Much the same syntax as when passing anything, in this case a pointer is the norm:
int myFunction(char* anArrayOfChars) // a pointer to the array
{
// function code ...
}...
// calling code
char anArray[32];
// fill the array
int value = myFunction(anArray) // name of the array is a pointer to its content -
Much the same syntax as when passing anything, in this case a pointer is the norm:
int myFunction(char* anArrayOfChars) // a pointer to the array
{
// function code ...
}...
// calling code
char anArray[32];
// fill the array
int value = myFunction(anArray) // name of the array is a pointer to its contentThanks will modifying the array content within the function make the edit permanent i.e. the modification will remain after the function ceased to exist. i.e. "myFunction(&anArray)" won`t this edit outside the function. I need the edit to work backwards.
-
Thanks will modifying the array content within the function make the edit permanent i.e. the modification will remain after the function ceased to exist. i.e. "myFunction(&anArray)" won`t this edit outside the function. I need the edit to work backwards.
Yes, if the function changes anything in the array then that data will remain when the function returns to the caller. Note: you do not need the addressof operator (
&) on an array name. Just code it as I showed in my example. Try this simple test:void myFunc(char* somedata)
{
strcpy(somedata, "Bad stuff");
return;
}//...
char myArray[] = "Good stuff";
myFunc(myArray);
printf("Returned value %s\n", myArray); -
Yes, if the function changes anything in the array then that data will remain when the function returns to the caller. Note: you do not need the addressof operator (
&) on an array name. Just code it as I showed in my example. Try this simple test:void myFunc(char* somedata)
{
strcpy(somedata, "Bad stuff");
return;
}//...
char myArray[] = "Good stuff";
myFunc(myArray);
printf("Returned value %s\n", myArray);I edited my previous post a bit also
void myFunc(char* somedata)
{
strcpy(somedata, "Good stuff");
return;
}//...
char myArray[] = "Bad stuff";
myFunc(myArray);
printf("Returned value %s\n", myArray);Quote:
void myFunc(char* somedata) { strcpy(somedata, "Good stuff"); return; } //... char myArray[] = "Bad stuff"; myFunc(myArray); printf("Returned value %s\n", myArray);
will this function? the array has 9 elements(bad stuff 9 chars.) "good stuff" is 10.
-
I edited my previous post a bit also
void myFunc(char* somedata)
{
strcpy(somedata, "Good stuff");
return;
}//...
char myArray[] = "Bad stuff";
myFunc(myArray);
printf("Returned value %s\n", myArray);Quote:
void myFunc(char* somedata) { strcpy(somedata, "Good stuff"); return; } //... char myArray[] = "Bad stuff"; myFunc(myArray); printf("Returned value %s\n", myArray);
will this function? the array has 9 elements(bad stuff 9 chars.) "good stuff" is 10.
Well, of course that breaks it so you may find that your code crashes. You must not overwrite arrays that are passed to you with more data than it can hold. But this conversation is missing some vital information. Maybe you can explain exactly what problem you are trying to solve.
-
Well, of course that breaks it so you may find that your code crashes. You must not overwrite arrays that are passed to you with more data than it can hold. But this conversation is missing some vital information. Maybe you can explain exactly what problem you are trying to solve.
@Richard Meh I`m really not doing anything worth much attention. My code is stashed with hacks so I`m just trying to fix on it.
"DreamLand Page" on facebook
-
@Richard Meh I`m really not doing anything worth much attention. My code is stashed with hacks so I`m just trying to fix on it.
"DreamLand Page" on facebook
-
Thanks for pointing how things are meant to be done Richard
"DreamLand Page" on facebook
-
I edited my previous post a bit also
void myFunc(char* somedata)
{
strcpy(somedata, "Good stuff");
return;
}//...
char myArray[] = "Bad stuff";
myFunc(myArray);
printf("Returned value %s\n", myArray);Quote:
void myFunc(char* somedata) { strcpy(somedata, "Good stuff"); return; } //... char myArray[] = "Bad stuff"; myFunc(myArray); printf("Returned value %s\n", myArray);
will this function? the array has 9 elements(bad stuff 9 chars.) "good stuff" is 10.
You can write it like this
void myFunc(char somedata[]) // edited to remove * after char: see Richard's post below
to highlight that it's actually an array rather than just a pointer to a single
char. Given that it's an array, its size is often provided to avoid the kind of trampling that you pointed out:void myFunc(char somedata[], size_t n)
Robust Services Core | Software Techniques for Lemmings | Articles
-
You can write it like this
void myFunc(char somedata[]) // edited to remove * after char: see Richard's post below
to highlight that it's actually an array rather than just a pointer to a single
char. Given that it's an array, its size is often provided to avoid the kind of trampling that you pointed out:void myFunc(char somedata[], size_t n)
Robust Services Core | Software Techniques for Lemmings | Articles
-
Thanks for pointing how things are meant to be done Richard
"DreamLand Page" on facebook
Further to what Richard has said, you could also do some defensive programming by passing in the length of the array. eg:
void myFunc(int* somedata, size_t data_len)
{
for(size_t i = 0; i < data_len; ++i)
somedata[i] *= 2;
return;
}//...
int myArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
const size_t arrLen = sizeof(myArray)/sizeof(myArray[0]);
myFunc(myArray), arrLen);
// ... etcThis will prevent data overflows, and/or segfaults, when accessing myArray inside the function. Things to note: * we can get the compiler to tell us how many elements in the array using the
sizeof(myArray)/sizeof(myArray[0])construct. This is calculated at compile time and in release mode, in most cases it will be optimized out, so it does not add to your memory usage, if that's a concern. * Using the constantarrLenmeans that if we change the number of elements in myArray, we don't need to go through the code and find all uses of myArray and make sure we're passing in the right number * If we had usedarrLen = sizeof(myArray)/sizeof(int), we need to remember to change the definition ofarrLenif we change the type ofmyArray. Usingsizeof(myArray[0]mean that if we change the type of myArray fromint[]todouble[], for example, we don't need to remember to change the definition ofarrLenas wellKeep Calm and Carry On
-
thanks Greg for that tip
Under C any pointer is already a pointer to an array it's built into the language along with pointer arithmetic ... you need to just learn that. Literally declare any pointer of anything lets do a float float* p; now you can access it as an array p[0] = 5.0; p[100] = 10.0; It will crash because the pointer isn't really to any memory but it makes the point the pointer is already a pointer to an array There are no exceptions to the rule it doesn't matter if the pointer is to a fundamental type or struct .... so I don't get how you could ever forget that. In the C community the [] use is rare because it's two extra characters to type. It also has implication when declaring variables because it puts that array on the stack not on data memory or constant memory (rodata) if it determines its a constant. So if you get into the habit of using that form you can get some undesirable things happen. Personally you are learning and I would learn to live without it and just learn them as you will most often see them written. The topic is well covered in dummies guide to C but you will note the last statement How to Use Arrays and Functions Together in C Programming - dummies[^]
In vino veritas
-
Further to what Richard has said, you could also do some defensive programming by passing in the length of the array. eg:
void myFunc(int* somedata, size_t data_len)
{
for(size_t i = 0; i < data_len; ++i)
somedata[i] *= 2;
return;
}//...
int myArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
const size_t arrLen = sizeof(myArray)/sizeof(myArray[0]);
myFunc(myArray), arrLen);
// ... etcThis will prevent data overflows, and/or segfaults, when accessing myArray inside the function. Things to note: * we can get the compiler to tell us how many elements in the array using the
sizeof(myArray)/sizeof(myArray[0])construct. This is calculated at compile time and in release mode, in most cases it will be optimized out, so it does not add to your memory usage, if that's a concern. * Using the constantarrLenmeans that if we change the number of elements in myArray, we don't need to go through the code and find all uses of myArray and make sure we're passing in the right number * If we had usedarrLen = sizeof(myArray)/sizeof(int), we need to remember to change the definition ofarrLenif we change the type ofmyArray. Usingsizeof(myArray[0]mean that if we change the type of myArray fromint[]todouble[], for example, we don't need to remember to change the definition ofarrLenas wellKeep Calm and Carry On
-
You can write it like this
void myFunc(char somedata[]) // edited to remove * after char: see Richard's post below
to highlight that it's actually an array rather than just a pointer to a single
char. Given that it's an array, its size is often provided to avoid the kind of trampling that you pointed out:void myFunc(char somedata[], size_t n)
Robust Services Core | Software Techniques for Lemmings | Articles
-
good pick didn't even notice the * because that form is so foreign to me.
In vino veritas
-
There is also the
_countof()macro, which gives the number of elements in arrays of any simple or composite type.Best macro ever added into C standard ... wish more people would use it.
In vino veritas
-
Best macro ever added into C standard ... wish more people would use it.
In vino veritas
-
There is also the
_countof()macro, which gives the number of elements in arrays of any simple or composite type. -
Under C any pointer is already a pointer to an array it's built into the language along with pointer arithmetic ... you need to just learn that. Literally declare any pointer of anything lets do a float float* p; now you can access it as an array p[0] = 5.0; p[100] = 10.0; It will crash because the pointer isn't really to any memory but it makes the point the pointer is already a pointer to an array There are no exceptions to the rule it doesn't matter if the pointer is to a fundamental type or struct .... so I don't get how you could ever forget that. In the C community the [] use is rare because it's two extra characters to type. It also has implication when declaring variables because it puts that array on the stack not on data memory or constant memory (rodata) if it determines its a constant. So if you get into the habit of using that form you can get some undesirable things happen. Personally you are learning and I would learn to live without it and just learn them as you will most often see them written. The topic is well covered in dummies guide to C but you will note the last statement How to Use Arrays and Functions Together in C Programming - dummies[^]
In vino veritas
float* p;
now you can access it as an array
p[0] = 5.0;
p[100] = 10.0;I understand "p[0] = 5.0;" since that`s the first element, but then "p[100] = 10.0;" don`t you need to alocate first "p = new float[101]"
-
I didn't know about
_countof(). Is it an MS only extension? Trying to compile with gcc under linux produces an implicit declaration warning in C and a not declared in this scope in C++Keep Calm and Carry On
