Passing Structure Pointers to Functions

OK, I am working on a relatively big program, one that scans for directories and prints them nicely to a file, depending on many options that the user types at the command line.

So the first thing I do is parse the options to a structure that contains many bool variables. The structure looks like this:

Code:

---

typedef struct arguments{
        bool help;
        bool recurse;
        bool complete;
        bool output;
        bool verbose;
        bool each_folder;
        unsigned int other;
        char filepath_arg[MAX_DIR_LENGTH];
} DIR_OPTIONS;

---

That structure is in a header file. And the bool variables will turn on or off many if()'s on the program, which will implement the options. My problem is that my source code is divided in many modules, the main module which basically parses the arguments and starts the dir scanning engine, which is in module dir.c that calls another module fileinit.c which initializes the file (or files) that will be written. So somehow, I have to pass the arguments to the other functions.

First thing I thought was making the structure global:

Code:

---

DIR_OPTIONS options={0,0,0,0,0,0} //init as false

int main(int argc, char *argv[])
{
    ......
}

---

And in the other modules:

Code:

---

extern DIR_OPTIONS options;

---

My solution works, but I don't know... I have seen absolutely no program that does this. But I have seen many programs that use pointers to pass options.

So, I tried something like this:

Code:

---

int main(int argc,char *argv[])
{
        DIR_OPTIONS *options;
        options=(DIR_OPTIONS *)malloc(sizeof(DIR_OPTIONS)); //allocate memory for the function
        dir(options);
}

void dir(DIR_OPTIONS *options)
{
        ...
}

---

But it simply doesn't work. For some reason the compiler gives me errors if I try to do something like

Code:

---

*options={0,0,0,0,0,0};

---

and... it simply doesn't work. The program stops and the file it is supposed to write has nothing in it.

So my big question is: How can I create a structure in the main() function, and pass it to other functions as a pointer? I don't want the recursive dir() function taking up stack space because of declaring a DIR_OPTIONS struct in it, so I just want to pass dir() a pointer. And I just don't want to make it global-external.

Thanks a lot!!!

P.S: Is there a reason why (apparently) global variables are not preferred? Or are they completely fine?

Code:

---

{0,0,...}

---

syntax can only be used to initialize a struct. Once created, you can't do it anymore.
A pointer is simple a variable that holds an address, so passing a structure directly won't work, naturally. What you need to do is to take the address of it using & while passing it. Then it will work you'll see.

coool... why didn't I think of it??? Just call the function like this

Code:

---

dir(&options);

---

let me try that very very fast.

Yes, that's the ticket.

IT WORKS!!!!!1!11one

So... in the main function I have to use options.etc when referring to a variable in the struct, and in the other function I have to use the -> thingy.

but, lets say I initialize the structure pointer in the main function. I need to allocate memory with malloc (right, just like I did in the preceding code?) first, and then I need to initilize the options->etc variables one by one? Isn't there a

Code:

---

options={}

---

shortcut?

Let me code it better... will this work?

Code:

---

DIR_OPTIONS *options
options=(DIR_OPTIONS *)malloc(sizeof(DIR_OPTIONS));
options->var1 = 0
options->var2 = 0
etc. etc.

---

Thanks a bunch.

You don't need to allocate memory with malloc. Since the struct will always exist in main, you can still pass it to other functions without it going out of scope. So in this case you're fine.
But if you need malloc in the future, all you need to do (with the same effect as {0}) is:

Code:

---

memset(var, 0, sizeof(*var));

---

And var would be the whole structure... right? (In my case, options)... or would it be the individual variables inside the structure?

No, it would "zero out" an entire struct, so the whole variable. But in your case, it's not necessary since you don't need malloc at all.

Thanks a lot!

So, I don't have to use malloc to create the first structure, but I need it if I want to create more and more structures on the run? And.. when I do that, I just initialize them by using memset, and I could access it later using pointers?

Wow.. these pointers are powerful.

Oh and I bet I can do this too:

Code:

---

int main(int argc, char *argv[])
{
        DIR_OPTIONS options={0,0,0,0,0,0}
        DIR_OPTIONS *address=&options;
       
        //call the dir function
        dir(address);
       
        //and to later access the variables I can use
        address->variable
        //or
        options.variable
}

---

Am I right?

Thanks a lot Elysia. You really do know everything!

Quote:

---

Originally Posted by samus250

Thanks a lot!

So, I don't have to use malloc to create the first structure, but I need it if I want to create more and more structures on the run? And.. when I do that, I just initialize them by using memset, and I could access it later using pointers?

Wow.. these pointers are powerful.

Oh and I bet I can do this too:

Code:

---

int main(int argc, char *argv[])
{
        DIR_OPTIONS options={0,0,0,0,0,0}
        DIR_OPTIONS *address=&options;
       
        //call the dir function
        dir(address);
       
        //and to later access the variables I can use
        address->variable
        //or
        options.variable
}

---

Am I right?

Thanks a lot Elysia. You really do know everything!

---

Exactly.

Quote:

---

Originally Posted by samus250

Thanks a lot!

So, I don't have to use malloc to create the first structure, but I need it if I want to create more and more structures on the run? And.. when I do that, I just initialize them by using memset, and I could access it later using pointers?

Wow.. these pointers are powerful.

Oh and I bet I can do this too:

Am I right?

Thanks a lot Elysia. You really do know everything!

---

Yes, pointers are very powerful. They're a backbone of the language.
And yes, you can do as you show, but there's little point of it right there.
It's possible to do this, too:

Code:

---

int main(int argc, char *argv[])
{
        DIR_OPTIONS options={0,0,0,0,0,0}
        dir(&options); /* Pass options directly without the need of a temp var */
        (&options)->help;
        void* pOptions = malloc(1 * sizeof(DIR_OPTIONS));
        if (pOptions) ((DIR_OPTIONS*)pOptions)->bHelp;
        free(pOptions);
}

---

Among much else.
But beware that pointers can also be very dangerous. It's very easy to forget to free memory alloced using malloc. And it's also very easy to use previously freed memory, as well.
So the general rule is to avoid pointers if you don't need them. Especially ones allocated dynamically through malloc.

Cool thanks a lot. I'll keep playing with these pointers.

Oh and one last question (I promise)!
I've seen this:

Code:

---

int main(int argc, char *argv[])
{
        function(argv);
}

void function(char **argv)
{
        ...
}

---

Apparently, in the function() function, argv is treated the same way as if it was on main(). But why does the function need to be prototyped with **argv? What is that double asterisk thing?

Thanks again.

It's a pointer to a pointer, which is what argv is.

Oh ok I get it. A pointer that points to the argv pointer. Smooth

Thanks.

Quote:

---

A pointer that points to the argv pointer.

---

Not quite. The argv pointer in function is a copy of the argv pointer in main.

oh ok so... the functions will have their own local pointers and both of them would be pointing to argv's address?