Thread: confusion over use of a function

Originally Posted by flyingants

My question is how do I enter the parameters for this function in the calling program when those parameters are unknown until it opens the database file? Is there some trick with pointers? I can't help but be feel I'm missing something simple. Any advice would be much appreciated.

I suggest that you assume that there is some maximum number of database entries, say #define MAX_ENTRIES 100. Now, you can write:

Code:

char metals[MAX_ENTRIES][30];
double aValues[MAX_ENTRIES];
/* etc */

And pass these to the function. The caller would then use the last argument to find out how many entries there really are.

Of course, there would be a problem if the actual number of entries is greater than the maximum that you assumed. Normally, we might use CommonTater's suggestion in post #2 to get around this, but unfortunately you cannot actually make use of CommonTater's suggestion given your function prototype since you need the caller to pass a pointer to a pointer for this to work. The best you can do now is to just stop reading and ignore whatever entries there are beyond your assumed maximum.

Originally Posted by msh

Main point is that type-name variable-name[] is the same as type-name *variable-name.

... where it appears in a parameter list.

Unfortunately, msh's suggestion is effectively the same as CommonTater's suggestion. With your given function prototype, it cannot work. (Well, if you take CommonTater's "declare pointers globally" suggestion literally then it can work, but you'll basically be ignoring the parameters in favour of global variables, which should generally be avoided. If I were your instructor, you'll be lucky to barely pass this assignment with such code.)

Originally Posted by msh

Could you please explain the issue? I'm missing something here.

What you are suggesting is similiar to this:

Code:

#include <stdlib.h>
#include <stdio.h>

void foo(int *p)
{
    p = malloc(sizeof(*p));
    *p = 123;
}

int main(void)
{
    int *p = 0;
    foo(p);
    printf("%d\n", *p);
    free(p);
    return 0;
}

The problem is that p in the main function has not been changed. After the call to foo(p), it is still a null pointer. The return value of malloc in foo has been assigned to the parameter p, which is local to foo. To it properly, you could change it to:

Code:

#include <stdlib.h>
#include <stdio.h>

void foo(int **p)
{
    *p = malloc(sizeof(**p));
    **p = 123;
}

int main(void)
{
    int *p = 0;
    foo(&p);
    printf("%d\n", *p);
    free(p);
    return 0;
}

But flyingants has no such liberty as he/she is required to use the given function prototype.