How to make functions variables public, they are not in a class C++

Question

I would like to know how I can make a function's variable public to other functions.

Example:

void InHere
{
    int one = 1; // I want to be public
}
int main()
{
    InHere(); // This will set int one = 1
    one = 2; // If the variable is public, I should be able to do this
    return 0;
}

Does anyone know how to do this? The only things I find when searching is for classes, as you can see nothing is in a class and I don't want them to be in one.

Any help is really appreciated!

Answer 1

A variable defined locally to a function is generally inaccessible outside that function unless the function explicitly supplies a reference/pointer to that variable.

One option is for the function to explicitly return a reference or pointer to that variable to the caller. That gives undefined behaviour if the variable is not static, as it does not exist after the function returns.

int &InHere()
{
     static int one = 1;
     return one;
}

void some_other_func()
{
     InHere() = 2;
}

This causes undefined behaviour if the variable one is not static since, as far as the program as a whole is concerned, the variable only comes into existence whes InHere() is called and ceases to exist as it returns (so the caller receives a dangling reference - a reference to something that no longer exists).

Another option is for the function to pass a pointer or reference to the variable as an argument to another function.

 void do_something(int &variable)
 {
      variable = 2;
 }     

 int InHere()
 {
      int one = 1;
      do_something(one);
      std::cout << one << '\n';    // will print 2
 }

The downside is that this only provides access to functions CALLED BY InHere(). Although the variable does not need to be static in this case, the variable still ceases to exist as InHere() returns (so if you want to combine option 1 and option 2 in some way, the variable needs to be static)

A third option is to define the variable at file scope, so it has static storage duration (i.e. its lifetime is not related to the function);

 int one;
 void InHere()
 {
      one = 1;
 }

 void another_function()
 {
      one = 2;
 }

 int main()
 {
     InHere();
        // one has value 1

     some_other_function();
        // one has value 2
 }

A global variable can be accessed in any function that has visibility of a declaration of the variable. For example, we could do

 extern int one;             // declaration but not definition of one

 int one;                    // definition of one.  This can only appear ONCE into the entire program

 void InHere()
 {
      one = 1;
 }

And, in other source file

 extern int one;         // this provides visibility to one but relies on it
                         //   being defined in another source file 

 void another_function()
 {
      one = 2;
 }

 int main()
 {
     InHere();
        // one has value 1

     some_other_function();
        // one has value 2
 }

Be careful with that though - there are numerous down-sides of global/static variables, to the extent they are usually considered VERY BAD programming technique. Have a look at this link (and pages linked to from there) for a description of some of the problems.