
Unused Arguments Aren't a Problem When Recursing Right? - ingve
http://www.nullterminatedstrings.com/c++/recursive-warning/
======
jgh
ok my brain is running on empty right now but I don't really see any
explanation about what the problem actually is... I get that something related
to some scripting language you're using for your game isn't working, but you
never actually explained what is broken.

Are unused arguments a problem when recursing? I can imagine they are if
they're taking up stack space and you're doing an awful lot of recursing (I
don't really use recursion enough in my C++ code to really run into issues
like this, so I am a little ignorant on the side effects of recursing deeply).

Anyway it's time for bed and I'm sure this article is going to be giving me
nightmares tonight.

~~~
aribia
I think the problem the author is trying to bring up is that if the only place
the variable is used is in a recursive call, this should be the same warning
as if its not used at all. There's no way it can impact the return value (or
side effects) of the function.

------
nocsaer1
gcc also doesn't _detect_ the unused variable. Looking at the -Wunused warning
description it does so correctly since a variable is considered unused if it
is declared only. In this case it is also used as a parameter.

To detect it, split the recursive function into two, one that recurses and one
that does the job at the end. Both can take the same relevant arguments and
the latter function will _detect_ any unused parameters.

------
belovedeagle
Of course, to "really" solve this problem you'd have to recognize "mutually
unused" arguments: foo(a,b) calls foo(b,a) and doesn't otherwise use the
arguments. But foo(x,a) which uses x and calls foo(a,x) uses both. Not
difficult to solve, and a few seconds' thought puts it in O(m*n) with m
recursive calls and n parameters... but probably not worth the trouble.

~~~
chaosemer
Even worse, foo(a,b) could call bar(a,b,c) which calls foo(b,a), all without
otherwise looking at a or b. This could get really bad really fast.

But that feels like the wrong way to analyze this. Even though a full solution
isn't practical, a limited one may be.

~~~
nocsaer1
There is no way of fully detecting it, because of function pointers.

------
k_sze
Just a gut feeling. Properly solving this might require solving the halting
problem: you don't know the variable is unused until you actually evaluate the
code. Otherwise you can only aim for detecting very trivial cases.

~~~
nocsaer1
Yes. See my comment below. The bug is trivially avoided by adhering to a
coding standard that actually makes the code better. See my other comment
below.

