Function Wrapper: Opinions and Critique Desired

Keith Thompson · *nix forums Guru Joined: 28 Feb 2005 Posts: 5173

jaysome <jaysome@spamcop.net> writes:

jaysome · *nix forums addict Joined: 01 Mar 2006 Posts: 69

On Thu, 20 Jul 2006 06:29:49 +0000 (UTC), "I.M. !Knuth"
<not_knuth@yoyodyne.com> wrote:

Keith Thompson · *nix forums Guru Joined: 28 Feb 2005 Posts: 5173

"I.M. !Knuth" <not_knuth@yoyodyne.com> writes:

I.M. !Knuth · *nix forums beginner Joined: 26 Jun 2006 Posts: 14

Keith Thompson <kst-u@mib.org> wrote:

I.M. !Knuth · *nix forums beginner Joined: 26 Jun 2006 Posts: 14

Barry Schwarz <schwarzb@doezl.net> wrote:

I.M. !Knuth · *nix forums beginner Joined: 26 Jun 2006 Posts: 14

Morris Dovey <mrdovey@iedu.com> wrote:

<snip>

Keith Thompson · *nix forums Guru Joined: 28 Feb 2005 Posts: 5173

Barry Schwarz <schwarzb@doezl.net> writes:

Barry Schwarz · *nix forums Guru Joined: 09 Apr 2005 Posts: 390

On Wed, 19 Jul 2006 06:33:14 +0000 (UTC), "I.M. !Knuth"
<not_knuth@yoyodyne.com> wrote:

Morris Dovey · *nix forums addict Joined: 22 Jun 2005 Posts: 90

I.M. !Knuth (in Xns98055B40DA1711011011@81.174.50.80) said:

| 3) Is there some other (maybe obvious) solution to ditching that
| third argument that I've somehow overlooked?

There is usually some other method (no matter what you're doing) :-)

I have two short pieces of recursive code that you might find
interesting:

http://www.iedu.com/mrd/c/getsm.c and
http://www.iedu.com/mrd/c/getsmx.c that deal with a similar situation.

The two are functionally equivalent; but the second module "cheats" in
that it uses a gcc extension to allow embedding one function
declaration inside another. It's non-standard but may have some value
as a thought-provoking device.

--
Morris Dovey
DeSoto Solar
DeSoto, Iowa USA
http://www.iedu.com/DeSoto

I.M. !Knuth · *nix forums beginner Joined: 26 Jun 2006 Posts: 14

A while back, I was mucking around with a recursive function. For
brevity's sake, I'll define it like this:

int func_recurs(int arg1, int arg2, int prev_pos)
{
int crnt_pos = 0;
int result;

/* stuff happens to arg1, arg2, and crnt_pos */

func_recurs(arg1, arg2, (prev_pos + crnt_pos) );

return result;
}

The critical part here (as I'm sure you've figured out already) is that
prev_pos (the previous position) of the last recursion is combined with
crnt_pos (the current positon) of the present recursion and passed along
to become the prev_pos of the next recursion.

But written this way, I had to remember that any call to func_recurs()
always had to look like this:

func_recurs(arg1, arg2, 0);

Frankly, I thought that constant 0 dangling at the end was rather
inelegant. Then it struck me that maybe I could "hide" func_recurs
inside another function so that I wouldn't have to strain my brain
remembering about that pesky third argument; something like:

func_lazymemory(int arg1, int arg2)
{
func_recurs(arg1, arg2, 0);
}

Being new to C, I felt pretty clever for coming up with this all on my
own. But then I thought: "Bah! Smells of kludge. There must be a
better way."

So I changed it to:

int func_recurs(int arg1, int arg2)
{
--> static int prev_pos; /* conveniently init'd to 0 on 1st call */
int crnt_pos = 0;
int result;

/* stuff happens to arg1, arg2, and crnt_pos */

--> prev_pos += crnt_pos; /* adjust for next recursion */
--> func_recurs(arg1, arg2);
--> prev_pos -= crnt_pos; /* restore for current recursion */

return result;
}

Drawing your attention to the four "-->" lines, I then thought: "Boy is
that ugly", but I no longer felt I'd somehow cheated inside my code. I
packed away the function and forgot about it ... until tonight.

Tonight I was browsing through some months' old threads on clc and came
across one that discussed function wrappers. "Cool," I thought. A
response referenced the FAQ, so I pulled it up and had a read. So, my
clever idea is old hat. Figures! Very Happy

I started thinking again about how I dealt with that function and came
up with some questions and concerns:

1a) Is my use of a wrapper appropriate (or am I ignorant of some wrapper
rule or style convention)?

1b) Wouldn't the wrapper be improved (and the program conserve some
storage) if it were re-written to pass pointer values like this?

func_lazymemory(int *arg1, int *arg2)
{
func_recurs(arg1, arg2, 0);
}

2a) Is one of my solutions better/cleaner/preferable over the other?

2b) Or are they equivalent, and picking one is a matter of (my) personal
style?

3) Is there some other (maybe obvious) solution to ditching that third
argument that I've somehow overlooked?

Thanks for your attention.

--
I.M. (definitely) !Knuth

Google