Thread: I want my functions to "remember" their integers

Originally Posted by hk_mp5kpdw

Make your function's variables static perhaps.

I don't know what that means? Is that a good solution?

Declare it like this in your function:

Code:

static int x = 42;

That means the first time your function is called, x starts with a value of 42. Whatever you change it to, that new value will be remembered, and next time you start the function, it will start with the new value. It wont be 42 every time.

The technical way to describe such a variable is one having static duration, and local scope. Think of it like a hybrid local/global. It exists throughout the entire duration of the program (static duration). It's stored with any global variables, and follows the same rules of initialization, i.e. if uninitialized, it's zero, if initialized, it's initialized once at program start up, not every time the function starts. The difference between a static local and a global is that only the function with the static local declaration can see the variable (local scope).

Note that this means there is only one copy of the variable for the entire program. That means this solution can cause problems if you're using recursive functions (functions that call themselves, or that call other functions that then call it), but can also help in recursive functions, depending on what you want to do with it. It can also be a problem with multi-threaded apps (probably not an issue for you).

Originally Posted by sampleandhold

Thanks for the good explanation! (:

You're welcome.

Now I'm very curious if static variables will work with my program. When I started my program I wanted to use lots of global variables but the book I'm reading doesn't recommend
using them. It also doesn't give any explanation why so I avoided them.

Read this: Global Variables Are Bad.

From what I understood from your post there's only one copy of a static variable, does that mean I can't pass a static variable to another function?
Can I make a static variable pointer?

You can pass it to another function, because C passesby value, meaning that it passes a copy of the of the variable. Whatever you do in the function you passed it to, those changes only exist in that function, the original variable, static or not, is left alone. You can make any local variable static in this sense*, whether it be an int, double, array, pointer, struct or union. static is a type qualifier, meaning it just gives extra info/instructions about that variable, it is not a special type of variable on it's own. You can also make a pointer point to a static variable and change the static variables value through the pointer.

* The 'static' keyword has a totally different meaning when applied to file-scope symbols (functions and global variables). IMO, it's was a poor design choice and is very confusing, but we must live with it. You probably don't need to worry about this too much.

Originally Posted by anduril462

You're welcome.


Read this: Global Variables Are Bad.


You can pass it to another function, because C passesby value, meaning that it passes a copy of the of the variable. Whatever you do in the function you passed it to, those changes only exist in that function, the original variable, static or not, is left alone. You can make any local variable static in this sense*, whether it be an int, double, array, pointer, struct or union. static is a type qualifier, meaning it just gives extra info/instructions about that variable, it is not a special type of variable on it's own. You can also make a pointer point to a static variable and change the static variables value through the pointer.

* The 'static' keyword has a totally different meaning when applied to file-scope symbols (functions and global variables). IMO, it's was a poor design choice and is very confusing, but we must live with it. You probably don't need to worry about this too much.

All right! Thanks for the information. It really helped alot with a problem I had. I have one more question though. Does a static variable stay static when it's passed to another function?

The variable stays static for the entire time the program is running. But remember, when you pass that variable to another function, you don't pass the actual variable, you just copy the value. Think of the parameter in the other function as a local variable that gets initialized with whatever value you pass in. Retry hk_mp5kpdw's example from post #7 and observe the output. Then try it again, changing foo2() to the following, and observing the difference:

Code:

void foo2(int bar)
{
    bar = bar * 2;
    printf("In foo2(), bar = %d\n", bar);
}

Originally Posted by anduril462

The variable stays static for the entire time the program is running. But remember, when you pass that variable to another function, you don't pass the actual variable, you just copy the value. Think of the parameter in the other function as a local variable that gets initialized with whatever value you pass in.

I think I've found a good solution to make the value of the variable stays static after it's passed. It's simple but it's going to work!

Code:

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


main()
{
    int static var;
    var = 23;


    printf("The value of var is %d", var);
    fun2(var);
}


fun2(int var)
{
    int static newVar;
    newVar = var;


    printf("\nnewVar is %d and it's static!", newVar);


    return 0;
}

Setting the value of two static variables the same doesn't link them in any way whatsoever, they're still two totally separate values. But if I understand you, there is a better way. If you declare a variable in main and simply pass it around to the functions that need it, you get the same effect. The variable is created at the beginning of main, effectively when your program starts, and lives until the end of main, effectively when your program ends. Any function you call from main, and any functions that those functions call, directly or indirectly, can have access to that variable if you simply pass it to functions as needed. One variable, visible and changeable by any functions you want.

Originally Posted by anduril462

Setting the value of two static variables the same doesn't link them in any way whatsoever, they're still two totally separate values. But if I understand you, there is a better way. If you declare a variable in main and simply pass it around to the functions that need it, you get the same effect. The variable is created at the beginning of main, effectively when your program starts, and lives until the end of main, effectively when your program ends. Any function you call from main, and any functions that those functions call, directly or indirectly, can have access to that variable if you simply pass it to functions as needed. One variable, visible and changeable by any functions you want.

I know the variables aren't linked in anyway. But they will have the same value until I change one of them. And I don't want to change them. I want them to be static. They'll have different names but I'll use them for the same purpose in seperate functions.
I want to use static variables because with a regular int variable, when I change it's value within the function and the function finishes. And when it gets called again it starts from the top and the variable is no longer what it was until it reaches the part where it's changed!

For example if I change a variable called var1 to 3 in the middle of function1. And I call function2 and then I call function1 again. In function1 var1 won't be 3 anymore. I need to var1 to be 3 as soon as the function begins. So the function can execute in different ways depending on a variable value.