Comments on: Recursion Depth Counting

By: Term Paper

Term Paper — Tue, 28 Dec 2010 10:34:36 +0000

The Recursion Depth Counting is really nice thing to get know about and I think this good to have such information for knowledge to gain, and to make most of it.

By: Term Papers

Term Papers — Tue, 07 Dec 2010 11:27:56 +0000

It’s a very good post.I am very happy to learn the things from the article.I will continue to read your articles. And please keep more posting like this , thanks

By: David Bieber

David Bieber — Sat, 28 Aug 2010 05:57:33 +0000

The #1 problem is that it’s very easy to forget to decrement the recursionDepth counter variable in case you return from the function somewhere else than the end of it. I happen to do that very very often, and I know myself well enough to know that I’ll probably forget to care about the recursionDepth variable if I add some new code (with a new return statement) in the middle of that function. tava tea

By: Jamie Allen

Jamie Allen — Wed, 06 Jan 2010 07:11:07 +0000

I was a supposed to take up Java Script as an extra course for the company that I was applying to did not find my resume that impressive. Its a good thing I did not continue for there are a lot of other way to learn about programming languages, especially on the web.

By: PAF

PAF — Wed, 18 Apr 2007 00:08:17 +0000

better late than never: what about making your template argument a void*, and use the function itself as the template argument. You would get a separate object for each function, clashing only if the two functions are … the same.
Maybe this would work with a char* template argument and then using some predefined macro to make a unique string for each function, like __FILE__ #__LINE__

In these cases, thread-safety would have to be implemented in the RecursionCounter itself.

By: Knic Knic

Knic Knic — Sat, 14 Apr 2007 19:31:18 +0000

Personally I always use a different solution (of course it adds to stack bloat, but whatever) but it has served me well in programming competitions. Also the compiler wont catch it if you make a call to f without using the parameter recursionDepth, which can lead to annoying bugs. However default parameters never bit in this case, because I pretty much always have a depth in there.

void f(int recursionDepth = 0)
{
++recursionDepth;

printf( “Recursion depth is: %dn”, recursionDepth );
// Lots of code here; for each return path, don’t forget
// to decrement recursionDepth!

}

By: rix

rix — Wed, 11 Apr 2007 07:33:09 +0000

I would make use of C99′s __func__ , or __PRETTY_FUNCTION__ (GCC only, but how useful) from a macro, something like:

class RecursionCounter
{
public:
inline RecursionCounter(string funcname) { counter[funcname]++; }
…
private:
static std::map counter;
};

#define RECURSION_COUNTER RecursionCounter _counter(__func__)

void f()
{
RECURSION_COUNTER;
…
}

By: Kblindert

Kblindert — Tue, 10 Apr 2007 22:35:16 +0000

With some spicy invariants added

struct algo
{
int rcount;
algo() : rcount(0) {}
// Recursive alorithm entrypoint
// Assures algoriithm isn’t started yet.
f() {
assert( rcount == 0 );
f_intern();
assert( rcount == 0 );
}
private:
struct reclvl {
reclvl(int& _r) : r(++_r) {}
~reclvl() { –r; }
int level() const { return r; }
private:
int& r;
};
f_intern()
{
reclvl( a_rcount );

do_stuff().

}
};

By: Anonymous

Anonymous — Tue, 10 Apr 2007 21:56:08 +0000

what about passing a ref on the counter to the class (int’s just here to increment the value;

class incrementor {
public:
incrementor(int& i) : m_i(i) {m_i++;}
~incrementor() {m_i–;}
int& m_i;
}

and the function is

void f() {
static int recursionDepth=0;
incrementor incr(recursionDepth);

printf( “Recursion depth: %d\n”, recursionDepth );
}

By: Anonymous

Anonymous — Tue, 10 Apr 2007 17:20:52 +0000

You could try using Boost.Fusion’s compile-time map using

class MY_F_COUNTER;
class MY_G_COUNTER;
…

as keys to get at the run-time counters.