Get call identifier or address of a function

Question

Suppose that I have this code:

class MyClass
{
public:
   void SomeFunction()
   {
   // Find somehow if this is first, second, or third call of a function in a main loop
   // If the function is called first time create new variables that will be used just for this function call
   }
};

MyClass myClassObject;

 int main()
{
    myClassObject.SomeFunction(); // First call
    myClassObject.SomeFunction(); // Second call
    myClassObject.SomeFunction(); // Third call
}

How can I know inside function what number of call is it? Note that I will probably have 100 function calls placed in code. Also this should work in Visual Studio on Windows and Clang on Mac.

I had one workaround:

void SomeFunction(const char* indetifier = "address")
{
     CheckAddress(indetifier); // This will check if address is stored. If it is not, create variables, if it is, if addresses matches use variables that are tied to that address.
}

I tried not to assign a new string to an "indetifier" and to let it to use default string ("address"). This of course didn't worked well as compiler will optimize "indetifier", so I was thinking that maybe a solution would be to disable optimizations for that variable, but I didn't because there should be some more elegant solution.

Also one thing came on my mind, maybe I could force inline a function and then get it's address, but this also seams like bad workaround.

I could also create new classes for every call but I would like to avoid this as there will be a lot of function calls and I don't want to think 100 different names.

If there is a way to create class object only at first call this would be awesome.

I hope that you understand what I want, sorry if something is not that clear as I am beginner coder.. :D

EDIT:

I can't use static for variables in a class because software that I am developing is a plugin that could have multiple instances loaded inside host and this will probably mess up the variables. I have tested static variables and if I create for example "static int value" anywhere and write something in it in one instance of a plugin this "value" will be updated for all instances of a plugin and this is not something that I want.

Answer 1

In C++ you can use the static keyword in a local variable context to create the object only once at the first call:

#include <iostream>

struct MyObject {
    MyObject() {
        std::cout << "Creating instance " << this << "\n";
    };
};

void foo() {
    static MyObject my_instance;
    std::cout << "... inside function foo ...\n";
}

int main(int argc, const char *argv[]) {
    std::cout << "About to call foo...\n";
    foo();
    std::cout << "... second call ...\n";
    foo();
    std::cout << "... third call ...\n";
    foo();
    return 0;
}

With the above code you will notice that only on object MyObject will be created, on the first call to foo.

Note that if your function is a template then for each instantiation of the template you will get another distinct static variable. For example with:

template<int N>
void foo() {
    static MyObject my_instance;
    std::cout << "... inside function foo ...\n";
}

the all the calls to foo<1>() will use the same variable but calling instead foo<2>() will access another copy of the function (another instantiation of the function template), that will have its own distinct static variable created on the first call to foo<2>(). All static variables that have been initialized will be destroyed after the end of main when the program terminates.

Answer 2

void SomeFunction()
{
// Find somehow if this is first, second, or third call of a function in a main loop
// If the function is called first time create new variables that will be used just for this function call
}

If the first call is to be tracked per object, then you need a member variable that keeps track of how many times SomeFuntion has been called for that object.

If the first call is to be tracked independent of objects, then you can use a static function variable that keeps track of how many times SomeFuntion has been called for that object.

Answer 3

I can't use static for variables in a class because software that I am developing is a plugin that could have multiple instances loaded inside host and this will probably mess up the variables. I have tested static variables and if I create for example "static int value" anywhere and write something in it in one instance of a plugin this "value" will be updated for all instances of a plugin and this is not something that I want.

So make a non-static counter?

class MyClass {
   int count;
public:
   MyClass () : count(0) { }
   void SomeFunction () {
       ++ count;
       // do stuff with 'count'
   }
};

MyClass myClassObject;

int main () {
    myClassObject.SomeFunction(); // First call
    myClassObject.SomeFunction(); // Second call
    myClassObject.SomeFunction(); // Third call
}

Or just pass it as a parameter...

class MyClass {
public:
   void SomeFunction (int count) {
       // do stuff with 'count'
   }
};

MyClass myClassObject;

int main () {
    myClassObject.SomeFunction(1); // First call
    myClassObject.SomeFunction(2); // Second call
    myClassObject.SomeFunction(3); // Third call
}

But I'm really wondering what you're actually trying to do, and I highly suggest sitting back and rethinking this whole thing, because there are a number of red flags / confusing points here...

Answer 4

If you're only interested in checking whether it's the first call, you can add a bool SomeFunction_first_call; to the MyClass, to act as a flag. The constructor sets the bool to true. MyClass::SomeFunction() uses the conditional check if (SomeFunction_first_call) /* ... */ to determine whether it's the first call, as follows:

class MyClass
{
    bool SomeFunction_first_call;

public:
    MyClass() : SomeFunction_first_call(true) {}

    void SomeFunction()
    {
        if (SomeFunction_first_call)
        {
            // This code only executes on first call.
            do_something();

            // Successfully handled first call, set flag to false.
            SomeFunction_first_call = false;
        }

        // This code always executes.
        do_something();
    }
};

Similarly, if you're only concerned about the first HOWEVER_MANY_CALLS calls, where HOWEVER_MANY_CALLS is a number, you can use something like this:

#include <cstdint>

class MyClass
{
     uint8_t SomeFunction_calls;

public:
    MyClass() : SomeFunction_calls(0) {}

    void SomeFunction()
    {
        // This segment will be executed until (SomeFunction_calls == HOWEVER_MANY_CALLS).
        // After this, the segment will be skipped, and the counter will no longer increment.
        if (SomeFunction_calls < HOWEVER_MANY_CALLS)
        {
            // This code only executes on first HOWEVER_MANY_CALLS calls.
            do_something();

            // Increment counter.
            ++SomeFunction_calls;
        }

        // This code always executes.
        do_something();
    }
};

Make sure to use the appropriately signed variable for the number of calls that need special handling (i.e. uint8_t for 0..255, uint16_t for 256..65,535, etc.). If different instances of MyClass will need to keep track of a different number of calls, then use a non-type template parameter to indicate this, and optionally, a defaulted typename to indicate what type the counter should be.

#include <cstdint>

template<uint64_t N, typename T = uint64_t>
class MyClass {
    T SomeFunction_calls;

    ...

    void SomeFunction()
    {
        if (SomeFunction_calls < N) {
            ...
        }

        ...
    }
};

In this case, a MyClass<4> will have special treatment for the first 4 calls to SomeFunction(), a MyClass<4444444444444444444> will have special treatment for the first 4,444,444,444,444,444,444 calls, and so on. The counter will default to uint64_t, as that should be large enough to hold the value; when only a smaller number of calls need special treatment, you can specify a smaller type, such as MyClass<4, uint8_t> or MyClass<444444444, uint32_t>.