Shitty program

Hi /prog/. I'm learning C, and wrote a program that takes a bunch of numbers and sorts them using a binary tree. I know it's not an efficient way to sort, I'm just learning binary trees. Could you look over it real quick and just give me some comments, like if there was something you would have done differently or something that's just stupid. Thanks a lot.

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

struct node_ {
        int value;
        struct node_ *left, *right;
};

typedef struct node_ node;

node *insert(node *parent, int newval)
{
        if (!parent) {
                node *n = malloc(sizeof(node));
                n->value = newval;
                return n;
        }
        else if (newval == parent->value)
                return parent;
        else if (newval < parent->value) {
                parent->left = insert(parent->left, newval);
                return parent;
        }
        else {
                parent->right = insert(parent->right, newval);
                return parent;
        }
}

void print(node *top)
{
        if (!top)
                return;

        print(top->left);
        printf("%d ", top->value);
        print(top->right);
}

int main(int argc, char *argv[])
{
        puts("enter values, 0 to stop");
       
        int next;
        scanf("%d", &next);
       
        node *root = 0;
       
        while (next) {
                root = insert(root, next);
                scanf("%d", &next);
        }

        print(root);
        puts("");

        return 0;
}

>>30
When you use an expression, allocations usually look like p = malloc(n * sizeof *p);.
Are you trolling?

Okay, okay, assuming you're not: I really hate that. When do you ever not know the type you're allocating? OTOH, if anyone else was reading your code they might not know (perhaps you're the type to write functions as long as your arm), and the call to malloc wouldn't help clear that up. There's no point in removing information like that.

I take the opposite approach: p = malloc(sizeof(Tp[n]));. I greatly prefer this because the syntax used parallels the stack allocation syntax, and the semantics are obvious when adding constants, factors, etc. void.h needs #define new(x) malloc(sizeof(x)).