c recursion program problem

I'm new to concept of recursion. I want to write a recursive function which take a float and integer a开发者_运维知识库s argument and call it recursively in a way that the float value remain constant and integer value changes

I write the following code:

#include <stdio.h>

float sum(float f, int k)
{
    static float c;
    c = f - k;
    c = sum(f, k - 1);
    return c;
}

int main()
{
    float f, g = 10.00;
    int i = 5;
    f = sum(g, i);
    printf("the sum of integer and float = %f", f);
}

When I compile it it shows no errors but when I run the program it shows a segmentation fault.

My question are following:

1. what is wrong with the code?
2. why it is showing segmentation error?
3. how to use recursion in a function which has more than one argument?

Please explain me with some example of recursive function which has two arguments.

The code is wrong because it can never end (I presume it fails with a stackoverflow error).

For recursion, you need two things

1. A base case
2. A recursive case that moves towards the base case

Looks like you've only got the second. I suspect sum should return when k is zero. Something like this hopefully makes sense:

 float sum(float f, int k) {
     if (k <= 0) {
         // The base case
         return f;
     } else {
         // The recursive case.  This does one step of the work
         // and moves towards the base case
         return 1 + sum(f, k - 1);
     }
 }

Your recursion does not have a base (non-recursive), terminating case.

Every call to sum makes a recursive call to itself, this continues till your stackoverflows, resulting in a seg fault.

The recursion never stops, and eventually you run out of stack. You need to decide when it is time to stop the recursion. for example, if k equals 0 you don't call sum again, but exit with return.

float sum(float f ,int k)
{
    static float c;
    if (k > 0)
    {
        c=f-k; /// <<< why is this here? you ignore the value and overwrite it in the next step.
        c=sum(f,k-1);
    }
    return c;
}

Of course there are additional problems: having c as static may be a problem that will affect the correctness of the calculation, and also the place I marked looks suspicious because you loose the value and overwrite it with the subsequent call to sum.

How about this?

#include <stdio.h>
float sum(float f, int k, float c) {
    if (k == 0)
        return c;
    sum(f, k - 1, f - k);
}

The first thing I see is that your recursion has no termination. It will go on forever. Perhaps you want:

float sum(float f ,int k)
{
    static float c;

    c=f-k;
    if (k != 0)
        c=sum(f,k-1);
    return c;
}

So that when k is zero the recursion stops. You had a stack overflow.

When you do recursion you need a status to end it.

So your code with changes:

#include <stdio.h>

float sum(float f, int k)
{
    if(k == 0) return f;
    return 1 + sum(f,k-1);
}

int main()
{
    float f, g = 10.00;
    int i = 5;
    f = sum(g, i);
    printf("the sum of integer and float = %f", f);
}

With that code, and your example f=10.00 and i=5

Call sum(10.0, 5)
return 1 + sum(10.0, 4)
           1 + sum(10.0, 3)
               1 + sum(10.0, 2)
                   1 + sum(10.0, 1)
                       1 + sum(10.0, 0)
                           10
                       1 + 10 = 11
                   1 + 11 = 12
               1 + 12 = 13
           1 + 13 = 14
       1 + 14 = 15
return 15;

I don't understand what the "sum" function is for. Is it supposed to be adding f and k? In which case, there is no recursion; you should just add f and k: return f + k.

But to try to answer your questions:

1. There is no base case. This is the cause of the infinite recursion. Every recursive function needs a base case which is a condition under which it does not recurse. Your function recurses no matter what; therefore it will always recurse forever.
2. When recursion segfaults, it's usually due to a stack overflow (no pun intended); it means you are recursing forever and eventually running out of space.
3. You can use recursion in a function with more than one argument, just the same as any other function. Just call it with whatever the new values are for the next iteration.

Note that you often have a "constant" value, that doesn't change during the recursion. To do that, you just pass the value unchanged on the recursive call, so the same value is available at each step.