Liczenie użycia funkcji

Witam serdecznie robię zadanie które wyświetla tablice skanowane na różne sposoby , w tym że zadaniu potrzebuję funkcji która liczy użycie danej funkcji , zastanawiam się czy jest to wykonalne. Podam jedynie przykład , nie chciał bym kopiować całego kodu.
powiedzmy że mam funkcję generowania tablicy
`void Array2D::generate(int z)
{

    int m;
    int n;

    srand((unsigned)time(0));

    for (int i = 0; i < m; i++) 
    {
        for (int j = 0; j < n; j++) 
        {
            ((Array2D + i * n) + j) = -z + (std::rand() % (z - (-z) + 1));
        }
    }`

Pytanie: czy mogę stworzyć kolejną funkcję która będzie liczyła użycie tej powyżej ? biorąc pod uwagę że tej funkcji użyję 3 razy w całym kodzie , chciałbym mieć licznik który mi liczy ilość . Mam nadzieję że jest to zrozumiałe , ewentualnie czekam na pytania. Dziękuję.

Chcesz liczyć wywołania czy odniesienia w kodzie? Zasadnicze pytanie: po co? IMHO najlepiej nada Ci się tutaj jakiś gprof. Tylko ponownie: po co Ci to?
EDIT: albo po prostu opakować to w fumktor z licznikiem... tylko nadal nie łapię czemu by to miało służyć w praktyce.

chcę liczyć wywołania tej funkcji.

xan922 napisał(a):

chcę liczyć wywołania tej funkcji.

Nie wiecie o co prosicie
Mt 20.22

zadałem pytanie czy jest to wykonalne jeżeli nie lub totalnie nie zalecane to proszę to napisać i zakończymy post. Jeżeli natomiast jest to spokojnie osiągalne proszę o pomoc.

xan922 napisał(a):

zadałem pytanie czy jest to wykonalne jeżeli nie lub totalnie nie zalecane to proszę to napisać i zakończymy post. Jeżeli natomiast jest to spokojnie osiągalne proszę o pomoc.

Osiągalne zależy dla kogo.
Dla Ciebie niewykonalne jest nawet sprecyzowanie celów i założeń

Konkretnie chcesz liczyć ile raz wywołałeś funkcję? Użyj po prostu zmiennej statycznej/globalnej

Dokładnie tak

https://stackoverflow.com/questions/13562660/how-to-get-the-exact-number-of-times-that-a-function-is-executed-in-c/13562678

#include <iostream>
#include <cmath>
using namespace std;

#define M_PI           3.14159265358979323846

struct SinCallCount
{
	size_t count(bool inc=false)
	{
		static size_t cnt=0;
		return cnt+=inc;
	}
	double operator()(double angle) 
	{
		count(true);
		return sin(angle); 
	}
} Sin;

int main()
{
	cout<<Sin(0)<<endl;
	cout<<Sin(M_PI/6)<<endl;
	cout<<Sin(M_PI/4)<<endl;
	
	cout<<"sin count: "<<Sin.count()<<endl;
	return 0;
}

W ramach mocno nadmiarowych zabaw w templatki ;P
https://godbolt.org/z/Ph97ce97r

Też zrobiłem, wchodzę wkleić a tu już jest :D

#include <iostream>
#include <cmath>
using namespace std;

#define M_PI 3.14159265358979323846

template<auto *Func> struct CallCalc;

template<typename Ret,typename ...Args,Ret (*func)(Args...)>
struct CallCalc<func>
{
	private:
	static size_t &callcount()
	{
		static size_t cnt=0;
		return cnt;
	}
	public:
	static size_t count() { return callcount(); }	
	Ret operator()(Args&&... args)
	{
		++callcount();
		return func(std::forward<Args>(args)...);
	}
};

namespace alt
{
	CallCalc<::foo> foo;	
	CallCalc<::sin> sin;
	CallCalc<::cos> cos;
	CallCalc<::pow> pow;
}

int main()
{
    cout<<alt::sin(0)<<endl;
    cout<<alt::sin(M_PI/6)<<endl;
    cout<<alt::sin(M_PI/4)<<endl;
    cout<<alt::sin(0)<<endl;

    cout<<alt::cos(0)<<endl;
    cout<<alt::cos(M_PI/6)<<endl;
    cout<<alt::cos(M_PI/4)<<endl;

    cout<<alt::pow(2,3)<<endl;
    cout<<alt::pow(3,2)<<endl;

    cout<<"sin count: "<<alt::sin.count()<<endl;
    cout<<"cos count: "<<alt::cos.count()<<endl;
    cout<<"pow count: "<<alt::pow.count()<<endl;
    return 0;
}

@xan922: Dostałeś pytanie o powód liczenia funkcji, bo może się okazać, że to w swoim programie nie jest potrzebne. Gdybyś opisał do czego wykorzystujesz informację o liczbie wywołań, byłoby łatwiej.

Wersja w której można użyć wyrażeń typu lambda.

#include <iostream>
#include <functional>

using namespace std;

template< typename R , typename... Args >
struct Fn
{
    Fn( function<R(Args...)> _F ): F{_F} {} function<R(Args...)> F;

    R operator()( Args&&... a )
    {
        ++calls;
        return F(forward<Args>(a)...);
    }

    size_t calls {0};
};

template<class R, class... Args>
Fn(R(*)(Args...)) -> Fn<R,Args...>;

int p2( int a ){ return a*a; }

int main()
{
   Fn f1 {p2};

   cout << "value = " << f1(5) << endl;
   cout << "calls = " << f1.calls << endl;
   cout << "value = " << f1(1) << endl;
   cout << "value = " << f1(2) << endl;
   cout << "calls = " << f1.calls << endl << endl;

   Fn f2 {function{[](int d){ return to_string(d)+"_text";}}};

   cout << "value = " << f2(5) << endl;
   cout << "calls = " << f2.calls << endl;
   cout << "value = " << f2(1) << endl;
   cout << "value = " << f2(2) << endl;
   cout << "calls = " << f2.calls << endl;
}

https://godbolt.org/z/rq1q8TofG