Question

I am getting this error

error: Access.Core may be used uninitialized in this function 

And this is my code:

 static int FirstTime = 1;  MyStruct Access;   if (FirstTime) {    FirstTime = 0;    Access = Implementation();    DoSomething(Access);  }   if(Other_Variable) {     Access = Implementation2();     DoSomething(Access);   }    //The Other_Variable will be set to 1 and to 0 by other part of the code 

My code is like that because I want to call to the function Implementation only the first time. In every call the Access variable is going to be updated so it does not make many sense make it static.

If I make Access static works, but I do not like make it static because in every other call Access is going to be updated. Any way to avoid the problem without making it static?.

Also any better options to execute only once a function instead of using a static variable are welcome.

Answer 1

Make Access like this (and remove FirstTime and the if):

static MyStruct Access = Implementation(this_b); 

The reason you get this warning is because static variables survive one function call. Their value is retained across all function calls (without regard to which thread calls that function). So, FirstTime will control whether you initialize Access. The first time you call the function that code is in will correctly initialize the Access variable. But with every further function call, FirstTime is zero, and you will not initialize Access anymore, and thus will use an uninitialized variable down the code.

Edit: Now, with your updated information, you say that you have two Implementation functions. The first time you want to use one, and all the other times you want to use another function. How about this then:

 // static will be false/zero by default  static bool AlreadyCalled;  MyStruct Access;   if (!AlreadyCalled) {    Access = Implementation();    AlreadyCalled = true;  } else {    Access = Implementation2();  } 

Depending on your actual use case, there may be better ways to handle this, though. For example, why not update the state of Access, like this:

// let the default constructor initialize it // to a plausible state static MyStruct Access;  // use RAII to update the state of Access when this // function returns.  MyUpdater updater(Access);  // now, do whatever the function does.  

Something like this for MyUpdater:

struct MyUpdater {     MyStruct &s;     MyUpdater(MyStruct &s):s(s) { }     ~MyUpdater() {         s.ChangeState();     } }; 

That pattern is called RAII: You associate some useful action with the constructor and destructor of a locally allocated object.