“一元'*'的类型参数无效”错误

Question

I am trying to build a tree with nodes but I have a pointer problem

I want to build a node but when I try, my program throw me an error.

I tried removing the "*" but it gave me an other error and made no sense (return a struct instead of the address of a struct?:) but I don't know where's the error:

Here's my code:

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

typedef struct node node;

struct node{
    node *leftson;
    node *rightson;
    int val;
};

node * node_create( int value, node *left, node *right){
    malloc(sizeof(node));
    node n = {left, right, value};
    return (*n);
}

System returns: error: invalid type argument of unary '*' (have 'node {aka struct node}') return (*n);

Answer 1

Few problems:

1. You have memory leaks.
2. You are referring the variable outside its scope.

Right way is:

    node * node_create( int value, node *left, node *right){
        node *n = malloc(sizeof(node));

        n->leftson = left;
        n->rigthson = right;
        n->val = value;

        return n;
    }

Free the memory once done using and also add memory check after malloc .

Answer 2

The unary * operator is applied to a pointer to dereference it, ie get the object it points to. But n isn't a pointer, it's an instance of a struct node object, so you can't apply * to it.

Also, you don't do anything with the return value of malloc , so all it does is leak memory.

What you want to do is declare n as a pointer to struct node , assign the allocated memory to that pointer, set the values in the pointed-to structure, then return the pointer.

node * node_create( int value, node *left, node *right){
    node *n = malloc(sizeof(node));
    n->value = value;
    n->leftson = left;
    n->rightson = right;
    return n;
}

Answer 3

malloc(sizeof(node));

malloc attempts to allocate memory and return a pointer to that memory. The statement above does not do anything with that return value. You need to assign the result of malloc to a variable, as with node *p = malloc(sizeof *p); .

node n = {left, right, value};

This creates a local automatic object named n , which is not what you want. The function node_create is defined to return a pointer to a node , so you need to return a pointer to an object that the caller can use, and an automatic object is not suitable for that (because its memory reservation ends when the function returns).

Instead, after allocating memory and assigning its address to p as shown above, fill in the object at p with the desire values. You can use:

p->leftson  = left;
p->rightson = right;
p->value    = value;

return (*n);

*n does not make any sense if n is a node, not a pointer. And, if n is a pointer, *n would be the structure it points to. But node_create is defined to return a pointer, not a structure. So you want to return a pointer.

After the code above, you can return the required pointer with return p; .

Answer 4

The function node_create has the return type node * .

node * node_create( int value, node *left, node *right){

This means that the function need to return a pointer.

The variable n declared like

node n = {left, right, value};

is not a pointer. It has the type struct node . So applying the unary indirection operator * for an object that does not have a pointer type

return (*n);

does not make sense.

You could use the address operator & like

return (&n);

returning a pointer from the function. But in this case the returned pointer will be invalid because the pointed local variable n will not be alive after exiting the function.

You need is to allocate an object of the type struct node dynamically. And you are doing this. However you are not assigning the returned value of call of malloc to any variable and are not returning it from the function.

malloc(sizeof(node));

So there is a memory leak in the function. The address of the allocated memory is lost and the memory can not be freed.

What you need is the following

node * node_create( int value, node *left, node *right)
{
    node *n = malloc(sizeof(node));

    if ( n != NULL )
    {
        n->leftson  = left;
        n->rightson = right;
        n->val      = value;
    }

    return n;
}

Pay attention to that before assigning the arguments to the data members of the allocated object you have to check whether the object was allocated successfully.

    if ( n != NULL )

You can consider also an alternative function definition when the function has one parameter of the type pointer to struct node. For example

node * node_create( node *init )
{
    node *n = malloc(sizeof(node));

    if ( n != NULL )
    {
        *n = *init;
    }

    return n;
}

To call this function you should "pack" all values in an object of the structure type as for example

node { NULL, NULL, 10 };
node *new_node = node_create( &n );