CODEWITHSUNDEEP
c++oopstaticc++17
SchnJulian
SchnJulian

Reputation: 192

Check if class is instantiated in method

I have a class that has a few static functions that can be called even if there is no instance of that class. There is also a method init() that I use to set some variables. This method is not static thus it needs an instance. Now if this was done I want the static methods to behave differently. Sort of like:

static foo(){
  if(noInstance()){
    doA();
  }else(){
    doB();
  }
}

Is this even possible? Or a bad idea and should just make the user call different methods if there is an instance? Thanks

EDIT It sounds weird but this is my use case:

class A{

public:
    static inline bool hasInstance = false;
    int data;

static int getData(){
    if(hasInstance){
        return data; // Can't do this from a static function
    }else{
        return 0;
    }
}

};

I know that I cant access the data from a static function beacuse there is no this pointer. I'm coding a library and I want the user to be able to use the static method if he dosen't want an instance but if there is an instance it should make use of the data of its instance.

If had an idea but I don't know wether that's good style:

static int getData(A *ref){
    if(ref != nullptr){
        return data;
    }else{
        return 0;
    }
}

I'd glad to hear from someone with more experience wether I should do that.

Upvotes: 0

Views: 535

Answers (3)

463035818_is_not_an_ai
463035818_is_not_an_ai

Reputation: 123094

I'm coding a library and I want the user to be able to use the static method if he dosen't want an instance but if there is an instance it should make use of the data of its instance.

In general, free functions are recommended rather than member functions (gotw). It is actually rare to have good reasons to make a static function a member function. It would need to be a member if it would need access to privates of the class, but that doesnt seem to be the case here and then it still could be a friend function.

Let's look at your approach:

static int getData(A *ref){
    if(ref != nullptr){
        return data;
    }else{
        return 0;
    }
}

You probably meant to write ref->data;, also I guess you are not merely returning the value of the member. That would be of little use, because If I have an instance I can get my hands on x.data without needing to call getData. And I suppose 0 is just a placeholder for someother value that you have there in the real code.

I am going a bit subjective now...

If I was a user of your library, I would want to know if getData returns data from one of the objects I did create or something else. Having one and the same function that does both would confuse me. I don't like pointers and I am scared of nullpointers, so if you force me to write

getData(nullptr);

this would not make me happy. I would like to have two different functions:

int getData() { return 0; }
int getData(const A& x) { return x.data; }

If I have no instance, I can call the first, if I have one I can call the second.

Upvotes: 1

Roman2452809
Roman2452809

Reputation: 448

Not sure what is your final goal, but I would recommend reconsidering your design, because this static/hasInstance behavior smells. Anyway, here is what you need:

using namespace std;

#include <iostream>

class MyClass
{
private:
    static bool hasInstance;
public:
    MyClass()
    {
        hasInstance = true;
    }

    static void foo()
    {
        if (hasInstance) {
            std::cout << "I have an instance\n";
        }
        else {
            std::cout << "No instance\n";
        }
    }
};

bool MyClass::hasInstance = false;

int main () {
    MyClass::foo();
    MyClass a;
    a.foo();
    MyClass::foo();
    return 0;
}

EDIT: Don't use it in real code. If you just curious, you can do almost everything in C++, so you could pass the object sometimes, it's dirty and ugly, but just for the demo: using namespace std;

#include <iostream>

class MyClass
{
private:
    int someVariable;
public:
    MyClass()
    {
        someVariable = 42;
    }

    static void foo(MyClass *obj = nullptr)
    {
        if (obj) {
            std::cout << obj->someVariable << std::endl;
        }
        else {
            std::cout << "No instance\n";
        }
    }
};

int main () {
    MyClass::foo();
    MyClass a;
    a.foo(&a);
    MyClass::foo(&a);
    return 0;
}

Upvotes: 0

Cezar Todirisca
Cezar Todirisca

Reputation: 190

I think you can use a static variable, let it be named count. You initialize count with 0, and every time you create an instance of that class, you increment count. If count is 0, that means you did not created any instance, therefore you can't use some methods.

Upvotes: 4

Related Questions