Segmentation faults ahoy!

Hey /prog/, total C noob here.
I wanted to write a recursive C function but somehow I always get a segmentation fault. This is my code:

########################################################
#include <stdio.h>
#include <stdlib.h>

main(){
   
    int n;                //depth of recursion
    printf("Enter number: ");
    scanf("%d", &n);
   
    int result;
    n = (int)malloc(sizeof(int));
    result = (int)malloc(sizeof(int));

    result = (catalan(n)*catalan(n-1));

    printf("Catalan number: %d \n", result);
   
    return result;

}

int catalan(int n){
    if(n==1){
        return 1;
    }
    return n*catalan(n-1);
}
########################################################

I've already tried some stuff with the memory allocation but it simply won't run.

>>1
I wanted to write a recursive C function
I know that I fucking HBT, but
DON'T USE RECURSION IN C!!!

    n = (int)malloc(sizeof(int));
    result = (int)malloc(sizeof(int));

=>


    n = (int*)malloc(sizeof(int));
    result = (int*)malloc(sizeof(int));

   
    int n;                //depth of recursion
    printf("Enter number: ");
    scanf("%d", &n);
   
    int result;

=>

   
    int* n;                //depth of recursion
    printf("Enter number: ");
    scanf("%d", n);
   
    int* result;

>>2
Why?

YOU HAVE TWO OPTIONS:

1)
int *n;
int *result;
scanf("%d",n);
*result = catalan(*n)*catalan(*n-1);
printf("Catamarangatang number: %d\n", *result);

2)
OR YOU CAN JUST REMOVE THE MALLOC LINES BECAUSE YOU DON'T EVEN FUCKING HAVE ANY POINTERS AND YOU DON'T FUCKING NEED ANY ``pudding''

>>5
Each function call allocates new space on the stack for local variables/argument passing, slowly eating all the space available and resulting in a stack overflow.

inb4 C standard: Yes, the C standard doesn't mention any stack, but we are talking about x86 and we use a stack, so shut the fuck up, ``C standard faggot''

>>6

3)
>>2

>>7
Is there another way for compiling recursive functions?
Translating them into iterative functions, perhaps? (I think this is difficult, but maybe there are compilers that do this thing)

n = (int)malloc(sizeof(int));

ahahaha, oh wow

>>9
If your compiler is smart enough, you could use tail recursion, but it's pointless in C, just use a for loop.

ITT: [spoiler]YHBT[\spoiler]

Okay now I got rid of the segmentation fault

Too bad the algorithm for the catalan number is wrong.

babby_face.jpg

>>13
babby_face.jpg

Get out. Now. You are no longer welcome here.

Parla català amb el meu cul, afeminat

>>14
Sod off, ``plonker''.

    UDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDIPUDDI

2 Name: ​ : 2010-11-30 17:57

    ​

3 Name: Anonymous

Well, my heap usually starts somewhere after 0800:0000h, maybe that's your problem.
Try enlarging your stack (it grows down in x86, see, so the numbers will be smaller) and calling catalan() on an address there. It's less likely to break then.

#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>

uintmax_t cata(uintmax_t n) {
  return n ? (4*n-2)*cata(n-1)/(n+1) : 1;
}

int main(int argc, char **argv) {
  uintmax_t n = argc<2 ? 0 : strtoumax(argv[1],0,0);
  printf("Catalan(%ju) = %ju\n", n, cata(n));
}

>>9
Translating them into iterative functions, perhaps
subtle.

-O2

runs fine whatever it supposed to do