Passing a pointer to a function/dynamic memory allocation
-
I am trying to create a function that takes a pointer as a parameter that will end up being an array. The function returns the number of elements that will be in the array. I'm having a problem with the allocating part in the function. Here is what I have:
struct FooStruct { int aFoo, bFoo; } int GetFooList(FooStruct *pFoos) { // Find out the max foos we're going to have pFoos = new FooStruct[MaxFoos]; return MaxFoos; }My function works, but the problem comes from the calling function. If I create a pointer to a FooStruct and pass that, it does not get updated with the address that the new comes back with. I still don't fully grasp pointers (just the basics) so I may be going about this the wrong way. I would imagine that this would be a standard situation with programming (calling a function to get an unknown number of items returned), but I don't know what this would be called so my searches have not come up with anything useful. Is this a good way to achieve what I am looking for, or am I wandering down the wrong path? Any suggestions or pointers (sorry for the pun) on ways to accomplish this would be greatly appreciated!! -
I am trying to create a function that takes a pointer as a parameter that will end up being an array. The function returns the number of elements that will be in the array. I'm having a problem with the allocating part in the function. Here is what I have:
struct FooStruct { int aFoo, bFoo; } int GetFooList(FooStruct *pFoos) { // Find out the max foos we're going to have pFoos = new FooStruct[MaxFoos]; return MaxFoos; }My function works, but the problem comes from the calling function. If I create a pointer to a FooStruct and pass that, it does not get updated with the address that the new comes back with. I still don't fully grasp pointers (just the basics) so I may be going about this the wrong way. I would imagine that this would be a standard situation with programming (calling a function to get an unknown number of items returned), but I don't know what this would be called so my searches have not come up with anything useful. Is this a good way to achieve what I am looking for, or am I wandering down the wrong path? Any suggestions or pointers (sorry for the pun) on ways to accomplish this would be greatly appreciated!!hpjchobbes wrote:
My function works, but the problem comes from the calling function. If I create a pointer to a FooStruct and pass that, it does not get updated with the address that the new comes back with. I still don't fully grasp pointers (just the basics) so I may be going about this the wrong way.
That is the standard behavior. To make things easier, see pointers as being a value (the value is the address of a certain memory area). Thus you are in fact passing a value to a function, and the function will make a copy of this value for itself. You create a new array and you store this new value in the copy. Thus, your calling function will never be updated. To solve this 'problem', pass the pointer by reference. This instruct your function that it must work on the variable and not make a copy of it:
int GetFooList(FooStruct* &pFoos)
Cédric Moonen Software developer
Charting control [v1.2] -
I am trying to create a function that takes a pointer as a parameter that will end up being an array. The function returns the number of elements that will be in the array. I'm having a problem with the allocating part in the function. Here is what I have:
struct FooStruct { int aFoo, bFoo; } int GetFooList(FooStruct *pFoos) { // Find out the max foos we're going to have pFoos = new FooStruct[MaxFoos]; return MaxFoos; }My function works, but the problem comes from the calling function. If I create a pointer to a FooStruct and pass that, it does not get updated with the address that the new comes back with. I still don't fully grasp pointers (just the basics) so I may be going about this the wrong way. I would imagine that this would be a standard situation with programming (calling a function to get an unknown number of items returned), but I don't know what this would be called so my searches have not come up with anything useful. Is this a good way to achieve what I am looking for, or am I wandering down the wrong path? Any suggestions or pointers (sorry for the pun) on ways to accomplish this would be greatly appreciated!!In short:
int GetFooList( FooStruct **ppFoos ) {
...
*ppFoos = new FooStruct[MaxFoos];
return(MaxFoos);
}
FooStruct *pFoos = NULL;
int nFoos = GetFooList(&pFoos);In long: A pointer is just another data type like an integer (char, short, int, long, long long) or real (float, double). So, turn the function around, what if you wanted to return the pointer and update the size as a parameter:
FooStruct* GetFooList( int *nFoos ) {
...
FooStruct *pfs = new FooStruct[MaxFoos];
*nFoos = MaxFoos;
return(pfs);
}
int nFoos = 0;
FoosStuct *pFoos = GetFooList(&nFoos);Don't get wrapped up by the fact that a pointer data type is defined with a *. [EDIT] Or, as Cedric pointed out, use references. I was trying to stay with a pointer based explaination. [/EDIT]
...cmk Save the whales - collect the whole set
-
I am trying to create a function that takes a pointer as a parameter that will end up being an array. The function returns the number of elements that will be in the array. I'm having a problem with the allocating part in the function. Here is what I have:
struct FooStruct { int aFoo, bFoo; } int GetFooList(FooStruct *pFoos) { // Find out the max foos we're going to have pFoos = new FooStruct[MaxFoos]; return MaxFoos; }My function works, but the problem comes from the calling function. If I create a pointer to a FooStruct and pass that, it does not get updated with the address that the new comes back with. I still don't fully grasp pointers (just the basics) so I may be going about this the wrong way. I would imagine that this would be a standard situation with programming (calling a function to get an unknown number of items returned), but I don't know what this would be called so my searches have not come up with anything useful. Is this a good way to achieve what I am looking for, or am I wandering down the wrong path? Any suggestions or pointers (sorry for the pun) on ways to accomplish this would be greatly appreciated!!Well, the reason of failure is; "I still don't fully grasp pointers (just the basics)" :) The problem is that you pass the pointer by value; IOW the actual pointer gets copied and the very copy is passed to the function. Inside of the function, you assign the address [returned by new] to the copy of the original pointer and thus the original pointer will not be affected. To make it work as you expect, make the following changes in the function prototype;
int GetFooList(FooStruct *& pFoos) {
...
}Noticed? Now you pass the pointer by its reference.
-- ===== Arman
-
I am trying to create a function that takes a pointer as a parameter that will end up being an array. The function returns the number of elements that will be in the array. I'm having a problem with the allocating part in the function. Here is what I have:
struct FooStruct { int aFoo, bFoo; } int GetFooList(FooStruct *pFoos) { // Find out the max foos we're going to have pFoos = new FooStruct[MaxFoos]; return MaxFoos; }My function works, but the problem comes from the calling function. If I create a pointer to a FooStruct and pass that, it does not get updated with the address that the new comes back with. I still don't fully grasp pointers (just the basics) so I may be going about this the wrong way. I would imagine that this would be a standard situation with programming (calling a function to get an unknown number of items returned), but I don't know what this would be called so my searches have not come up with anything useful. Is this a good way to achieve what I am looking for, or am I wandering down the wrong path? Any suggestions or pointers (sorry for the pun) on ways to accomplish this would be greatly appreciated!!struct FooStruct { int aFoo, bFoo; }; int GetFooList(FooStruct * & pFoos) { // Find out the max foos we're going to have pFoos = new FooStruct[MaxFoos]; return MaxFoos; }
-
I am trying to create a function that takes a pointer as a parameter that will end up being an array. The function returns the number of elements that will be in the array. I'm having a problem with the allocating part in the function. Here is what I have:
struct FooStruct { int aFoo, bFoo; } int GetFooList(FooStruct *pFoos) { // Find out the max foos we're going to have pFoos = new FooStruct[MaxFoos]; return MaxFoos; }My function works, but the problem comes from the calling function. If I create a pointer to a FooStruct and pass that, it does not get updated with the address that the new comes back with. I still don't fully grasp pointers (just the basics) so I may be going about this the wrong way. I would imagine that this would be a standard situation with programming (calling a function to get an unknown number of items returned), but I don't know what this would be called so my searches have not come up with anything useful. Is this a good way to achieve what I am looking for, or am I wandering down the wrong path? Any suggestions or pointers (sorry for the pun) on ways to accomplish this would be greatly appreciated!!See this thread.
"A good athlete is the result of a good and worthy opponent." - David Crow
"To have a respect for ourselves guides our morals; to have deference for others governs our manners." - Laurence Sterne
-
I am trying to create a function that takes a pointer as a parameter that will end up being an array. The function returns the number of elements that will be in the array. I'm having a problem with the allocating part in the function. Here is what I have:
struct FooStruct { int aFoo, bFoo; } int GetFooList(FooStruct *pFoos) { // Find out the max foos we're going to have pFoos = new FooStruct[MaxFoos]; return MaxFoos; }My function works, but the problem comes from the calling function. If I create a pointer to a FooStruct and pass that, it does not get updated with the address that the new comes back with. I still don't fully grasp pointers (just the basics) so I may be going about this the wrong way. I would imagine that this would be a standard situation with programming (calling a function to get an unknown number of items returned), but I don't know what this would be called so my searches have not come up with anything useful. Is this a good way to achieve what I am looking for, or am I wandering down the wrong path? Any suggestions or pointers (sorry for the pun) on ways to accomplish this would be greatly appreciated!!I see where my mistake was. I was not thinking of the pointer being passed as a value. Thanks everyone for the replies. I'm going to need to play around with this a lot more so I get a full understanding of it! I also like the idea of swapping the parameter and the return value. This is a lot easier to understand. I should have thought of that myself. I'll read up on the link that was provided. I did some searches on 'array pointer', but everything I found was about having a known array size at compile time. Thanks for the link, it looks like it has a lot of good information!