Calling non-static variable from static function

Question

I am a beginner programmer in C++ and doing a PoC for my company. So I apologize for my basic question.

class TestOne{
  private:
    TestTwo* t2;

  void createInstance(TestTwo* param){
    t2 = param;
  }

  static void staticFunctionToAccessT2(){
    // Now here I want to access "t2" here in the current instance of the class
    // By current instance I mean "this" in non-static context
    // currently there is no function to get object, but can be created
    // ** we cannot call new TestOne(), because that will create a new instance
    // ** of the current class and that I don't want.
  }
}

Any help in this regard will be greatly appreciated.

Thanks

===UPDATE===

This can be taken as a scenario in which I am developing an application in QT Creator, where I have a static function of predefined signature and want to access the UI elements for text change(like TextEdit)

First, this isn't C++. Second, it makes absolutely no sense to access some per-object variable with no object. — Qaz
– Qaz, Commented Nov 14, 2014 at 12:32
Sorry chris, but I am actually a Java programmer that's why I made the mistake, I'll update the code sample. Thanks for pointing it out. — Jayesh
– Jayesh, Commented Nov 14, 2014 at 12:33
In a static function, there is no "current instance". That's what static means. If you want there to be an instance, either drop the static, or pass one to the function in some other manner. — Mike Seymour
– Mike Seymour, Commented Nov 14, 2014 at 12:35
@chris Actually I want to access the T2 at that place, but couldn't find a solution for the same. Can you please help. — Jayesh
– Jayesh, Commented Nov 14, 2014 at 12:36
@Jayesh: The T2 at what place? Without an object, you simply can't access an object. The question makes no sense whatsoever. — Mike Seymour
– Mike Seymour, Commented Nov 14, 2014 at 12:36

Community · Accepted Answer · 2017-05-23 11:47:26Z

3

You can't do this, even in Java.

static methods are simply local helper functions for all instances of the class with no access to individual class state (for example t2).

Either remove the static from the method, or make the member variable a static variable, depending on what you are trying to accomplish.

EDIT:

If I understand you correctly your SDK wants a function pointer which it will call to modify your instances' t2. Your mutator method should be public and non-static. So let's just say you redefined staticFunctionToAccessT2 like this:

public: void mutateT2();

If the instance you wanted to call mutateT2 on was defined as:

TestOne foo;

Where your SDK wants a function pointer you could pass this in:

std::bind(&TestOne::mutateT2, foo)

As is pointed out by Mike Seymour below this only works if the SDK method parameter is a std::function not if its parameter is a raw function pointer.

edited May 23, 2017 at 11:47

CommunityBot

11 silver badge

answered Nov 14, 2014 at 12:37

Jonathan Mee

39.1k26 gold badges148 silver badges319 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Mike Seymour Over a year ago

If it wants a function pointer, then you can't give it a bind result; that's a class type, containing the bound values, so not convertible to a simple function pointer. There's no way to pass extra state if it only takes a function pointer.

Jonathan Mee Over a year ago

@MikeSeymour It depends on the parameter type. For example Qt's slots accept a std:function type, which will accept the output of std::bind. I suspect that is what Jayesh was using his function for.

Mike Seymour Over a year ago

Indeed, if the parameter type is std::function or similar, then it will accept any callable object. But if it wants a function pointer, then you can't use bind, contrary to the final sentence of your answer.

Jonathan Mee Over a year ago

@MikeSeymour I've edited the answer for the sake of correctness.

Community · Accepted Answer · 2017-05-23 12:34:50Z

A static member function has no "current instance".

If you want to limit your class to having only one instance you are looking for the Singleton design (anti-)pattern, Singleton pattern in C++. It's actually not that evil and I always feel an attraction to it whenever I am working with classes having static member variables.

There are a number of approaches to making the singleton work better, close attention to RAII should be your driving goal here and I use std::unique_ptr<TestOne> safeInstance; while I'm initialising in my getInstance() static method, in the absence of exceptions in my Android environment.

I generally would urge you not to use the Singleton Pattern if you have insufficent experience to need to ask this question. But it seems to address most of the issues in your question.

Additionaly, to call non-static "variable", I assume you meant "method", your static function must work with your singleton instance, assuming it was created successfully that is. It can even access non-static variable through the singleton instance.

Mike Seymour · Accepted Answer · 2014-11-14 12:49:01Z

There is no "current instance"; you can't access non-static members from a static function without access to some instance somewhere.

From your comments, it seems that you're using a broken API with a callback (or similar) mechanism that doesn't pass user data to the function you provide. In that case, you'll have to find some other way to get data to the function; perhaps a static member:

static TestOne * bodge;
static void staticFunctionToAccessT2(){
    TestTwo * t2 = bodge->t2;
}

so the API can be used thusly

TestOne::bodge = my_t1;
broken_api(&TestOne::staticFunctionToAccessT2);

Be careful not to set bodge to some other value until the API has finished whatever it's doing with your callback.

A less broken API would define a callback type that can take a "user data" parameter; perhaps a void* pointer, which can point to arbitrary data. You can use that thusly:

static void staticFunctionToAccessT2(void * p) {
    TestOne * t1 = static_cast<TestOne*>(p);
    TestTwo * t2 = t1->t2;
}

less_broken_api(&TestOne::staticFunctionToAccessT2, my_t1);

A nice modern API would accept arbitrary callable types, so you could use a non-static function:

void memberFunctionToAccessT2() {
    TestTwo * t2 = this->t2;
}

nice_api([=]{my_t1->memberFunctionToAccessT2();});

Vikash Mohapatra · Accepted Answer · 2022-10-01 01:52:50Z

There is possibly a way to set the non static variable member of a class using a static function call, but this can be done when you pass the reference of the same class to the static function and access the non static function to set the not static member variable. But again there is no good reason why someone needs to do this. May be just for interview perspective I could definitely say there is a way for doing it Find the below code snippet doing the same:

#include <iostream>
using namespace std;
class Test{
    int x;
    static int y;
    public:
        static void setY(int val){
            y = val;
        }
        void setX(int val){
            x = val;
        }
        static void setXY(int xval,int yval, Test& obj){
          obj.setX(xval);
            y = yval;
        }
        void display(){
            cout<<"x : "<<x<<", y: "<<y<<endl;
        }
};

int Test::y = 0;
int main()
{
    Test t;
    t.setY(10);
    t.setX(1);
    t.display();
    
    Test t1;
    t1.setX(100);
    t1.display();
    
    t1.setXY(1000,2000,t1);
    t1.display();


    return 0;
}

Output from the above code execution : x : 1, y: 10 x : 100, y: 10 x : 1000, y: 2000

Code Snippet along with output : Code_Snippet_With_Output

Collectives™ on Stack Overflow

Calling non-static variable from static function

4 Answers 4

4 Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

4 Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related