C中递归函数的错误输出

Question

I am supposed to make a recursive function that prints an integer digit by digit using putchar() and not printf. The output should be 1234 but I am getting 1234(smiley face)1234. Why is this so?

Also, can you add a '\\n' outside of a printf?

Many thanks.

#include <stdio.h>

int printnumber();

int main()
{
    int n = 1234;
    printnumber(n);
    return 0; 
}

int printnumber(int n) {
    int x, y;
    x = flip(n) % 10;
    putchar(x);
    y = flip(n) / 10;
    if (y < 0)
        printnumber(y);
}

int flip(int n)
{
    if (n < 0) {
        putchar('-');
        n = -n;
    }
    if (n / 10)
        flip(n / 10);
    putchar(n % 10 + '0');
}

Answer 1

Your code has undefined behaviour because function flip declared as having return type int actually returns nothing.

Also it seems that function flip does all the job. So it is not clear what is the sense of function printnumber.

You could simply define the function the following way

#include <stdio.h>

void print_number( int n )
{
    if ( n < 0 ) 
    {
        putchar('-');
        n = -n;
    }

    if ( n / 10 ) print_number( n / 10 );
    putchar( n % 10 + '0' );
}

int main(void) 
{
    print_number( -1234 );


    return 0;
}

The output is

-1234

Answer 2

In your code,

x = flip(n) % 10;

Line invokes undefined behaviour.

You did not return any value from int flip(int n) . So, while executing the above stement, the compiler will have no explicit return value from flip(n) call and hence, the result is undefined.

Related Reading: From the C99 specification document, chapter 6.9.1, paragraph 12

If the } that terminates a function is reached, and the value of the function call is used by the caller, the behavior is undefined.

Note: Think of a simpler logic. This is kind of overkill for printing the digits.

Answer 3

That code looks way too complicated. Here's my single function version:

void printNumber(int n) {
    if (n < 0) {
        putchar('-');
        printNumber(-n);
    } else {
        if (n >= 10) {
            printNumber(n / 10);
        }
        putchar('0' + (n % 10));
    }
}

ie output - and recurse for negative numbers, otherwise using inverted recursion (so that the digits come out in the right order) first recursively calls itself for the leftmost digits and then prints the rightmost digit.

It's also possible to avoid the separate divide and modulus operations using the standard div function that produces both in one step, although whether this is more efficient is implementation dependent.

void printNumber(int n) {
    if (n < 0) {
        putchar('-');
        printNumber(-n);
    } else {
        div_t d = div(n, 10);
        if (d.quot) {
            printNumber(d.quot);
        }
        putchar('0' + d.rem);
    }
}

Answer 4

Assuming this is what you intend to do. While using recursive functions the lines after the recursive function call are pushed onto the stack so we can make use of it and print 1234 as shown below.

#include <stdio.h>

void printnumber();

int main()
{
    int n = 1234;
    printnumber(n);
    return 0; 
}

void printnumber(int n) {
    char ch;
    int x;
    if(n == 0)
    return;
    else
    {
       x = n % 10;
       n = n/10;
       ch = x + '0';
       printnumber(n);
       putchar(ch);
    }
}

Answer 5

Is there any need of flip() function ? You can check this...

#include <stdio.h>

void printnumber(int n);

int main()
{
    int n = -1234;
    printnumber(n);
    return 0;
}

void printnumber(int n) {
    if(n/10==0)
    {
        if(n<0)
        {
            putchar('-');
            n=-n;
        }
        putchar(n+'0');
        return;
    }
    int x, y;
    x=n%10;
    if(x<0)
    x=-x;
    printnumber(n/10);
    putchar(x+'0');
}

Answer 6

I assume you want :

• a function taking an int and displayint it
• calling a recursive function printing digit by digit
• display adds a new line ( \\n ) after the number

But as your functions do not return anything of interest it is better to declare them void. It would have avoided the undefined behaviour of using the value of a function without any return ( x = flip(n) % 10; in printnumber)

You can do for example :

#include <stdio.h>

/* function declaration before usage */
void flip(int n);
void printnumber(int n)

int main()
{
    int n = 1234;
    printnumber(n);
    return 0; 
}

/* prints a int followed by new line */
void printnumber(int n) {
    if (n < 0) {
        putchar('-');
        n = -n;
    }
    flip(n);
    putchar('\n');
}

/* recursively prints decimal digits of an int */
void flip(int n)
{
    if (n / 10)
        flip(n / 10);
    putchar(n % 10 + '0');
}

EDIT per comment : if you want only one function, you should better put in main what should happen only once :

#include <stdio.h>

/* function declaration before usage */
void printnumber(int n)

int main()
{
    int n = 1234;
    if (n < 0) {
        putchar('-');
        n = -n;
    }
    printnumber(n);
    putchar('\n');
    return 0; 
}

/* recursively prints decimal digits of an int */
void printnumber(int n)
{
    if (n / 10)
        printnumber(n / 10);
    putchar(n % 10 + '0');
}

Answer 7

Answering your easier question first, you can use putchar('\\n') to output a newline. printf just repeatedly calls putchar.

Your code is a little over complex, and among other things flip() doesn't return a value (Always switch on compiler warnings - they tell you when you're doing something silly (or dangerous)).

An implementation would be something like this:

#inclde <stdio.h>

void print_digits(unsigned n)
{
    if (n >= 10) { print_digits(n / 10); }
    putchar(n % 10 + '0');
}

void printnumber(int n)
{
    /* Copes with max negative integer */
    unsigned u = n;
    if (n < 0) { putchar('-'); u = -u; }
    print_digits(u);
}

int main(void)
{
    int n = 1234;
    print_number(n);
    putchar('\n');
    return 0;
}

Answer 8

Two issues

1. Using the return value from int flip() , but the function failing to provide a return value invokes undefined behavior (UB) - anything can happen. @Sourav Ghosh

2. n = -n; is a niche problem also. When n == INT_MIN on many systems which use 2's complement integer, the result is also UB. To solve that, negate positive numbers and recurse with negative numbers. With int , the range of negative numbers is always at least or greater than the range of positive numbers.

Add '\\n' outside of a printf with another putchar() .

#include <limits.h>
#include <stdio.h>

static void printdigit(int n) {
  if (n <= -10) {
    printdigit(n / 10);
  }
  putchar('0' - n % 10);  // use -
}

void printnumber(int n) {
  if (n < 0) {
    putchar('-');
  } else {
    n = -n;
  }
  printdigit(n);
  putchar('\n');
}
int main(void) {
  printnumber(1234);
  printnumber(-1234);
  printnumber(INT_MIN);
  printnumber(INT_MAX);
  printnumber(0);
  return 0;
}

Output

1234
-1234
-2147483648
2147483647
0