C 在数组中存储void方法的结果（转换无效）

我是c语言的初学者，我遇到了一个很难解决的问题。当我试图在数组中存储方法的结果时，我在

节点[I]=print\u postorder中得到了一个无效的转换错误

char nodes[]= "";
    int i;
    for(i=0; i< 7; i++){
        nodes [i]= print_postorder;
    }
    if(sizeof(nodes) > 0){
     printf("There are at least one node in the tree");
    }

发生问题的完整程序：

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

struct bin_tree {
    int data;
    struct bin_tree * right, * left;
};
typedef struct bin_tree node;

void insert(node ** tree, int val)
{
    node *temp = NULL;
    if(!(*tree))
    {
        temp = (node *)malloc(sizeof(node));
        temp->left = temp->right = NULL;
        temp->data = val;
        *tree = temp;
        return;
    }

    if(val < (*tree)->data)
    {
        insert(&(*tree)->left, val);
    }
    else if(val > (*tree)->data)
    {
        insert(&(*tree)->right, val);
    }

}

void print_preorder(node * tree)
{
    if (tree)
    {
        printf("%d\n",tree->data);
        print_preorder(tree->left);
        print_preorder(tree->right);
    }

}

void print_inorder(node * tree)
{
    if (tree)
    {
        print_inorder(tree->left);
        printf("%d\n",tree->data);
        print_inorder(tree->right);
    }
}

void print_postorder(node * tree)
{
    if (tree)
    {
        print_postorder(tree->left);
        print_postorder(tree->right);
        printf("%d\n",tree->data);
    }
}

void deltree(node * tree)
{
    if (tree)
    {
        deltree(tree->left);
        deltree(tree->right);
        free(tree);
    }
}

node* search(node ** tree, int val)
{
    if(!(*tree))
    {
        return NULL;
    }

    if(val < (*tree)->data)
    {
        search(&((*tree)->left), val);
    }
    else if(val > (*tree)->data)
    {
        search(&((*tree)->right), val);
    }
    else if(val == (*tree)->data)
    {
        return *tree;
    }
}

int main()
{
    node *root;
    node *tmp;


    root = NULL;
    /* Inserting nodes into tree */
    insert(&root, 9);
    insert(&root, 4);
    insert(&root, 15);
    insert(&root, 6);
    insert(&root, 12);
    insert(&root, 17);
    insert(&root, 2);

    /* Printing nodes of tree */
    printf("Pre Order Display\n");
    print_preorder(root);

    printf("In Order Display\n");
    print_inorder(root);

    printf("Post Order Display\n");
    print_postorder(root);

    char nodes[]= "";
    int i;
    for(i=0; i< 7; i++){
        nodes[i]= print_postorder;
    }

    if(sizeof(nodes) > 0){
        printf("There are at least one node in the tree");
    }

    /* Search node into tree */
    tmp = search(&root, 4);
    if (tmp)
    {
        printf("Searched node=%d\n", tmp->data);
    }
    else
    {
        printf("Data Not found in tree.\n");
    }

    /* Deleting all nodes of tree */
    deltree(root);

    return 0;
}

#包括
#包括
结构bin_树{
int数据；
结构bin_树*右，*左；
};
typedef结构bin_树节点；
无效插入（节点**树，int val）
{
节点*temp=NULL；
如果（！（*树））
{
temp=（node*）malloc（sizeof（node））；
临时->左=临时->右=空；
温度->数据=val；
*树=温度；
返回；
}
if（val<（*树）->数据）
{
插入（&（*树）->左，val）；
}
else if（val>（*树）->数据）
{
插入（&（*树）->右侧，val）；
}
}
无效打印\u预订单（节点*树）
{
如果（树）
{
printf（“%d\n”，树->数据）；
打印预订单（树->左）；
打印预订单（树->右）；
}
}
无效打印顺序（节点*树）
{
如果（树）
{
按顺序打印（树->左）；
printf（“%d\n”，树->数据）；
按顺序打印（树->右）；
}
}
作废打印\u后订单（节点*树）
{
如果（树）
{
打印邮政订单（树->左）；
打印邮政订单（树->右）；
printf（“%d\n”，树->数据）；
}
}
void deltree（节点*树）
{
如果（树）
{
deltree（树->左）；
deltree（树->右侧）；
自由（树）；
}
}
节点*搜索（节点**树，int val）
{
如果（！（*树））
{
返回NULL；
}
if（val<（*树）->数据）
{
搜索（&（（*树）->左），val；
}
else if（val>（*树）->数据）
{
搜索（&（（*树）->右），val；
}
else if（val==（*树）->数据）
{
返回*树；
}
}
int main（）
{
节点*根；
节点*tmp；
root=NULL；
/*将节点插入到树中*/
插入（&root，9）；
插入（&root，4）；
插入（&root，15）；
插入（&root，6）；
插入（&root，12）；
插入（&root，17）；
插入（&根，2）；
/*打印树的节点*/
printf（“预订单显示”）；
打印预订单（根）；
printf（“顺序显示\n”）；
按顺序打印（根）；
printf（“订单后显示”）；
打印后订单（根）；
字符节点[]=“”；
int i；
对于（i=0；i<7；i++）{
节点[i]=打印后订单；
}
if（sizeof（nodes）>0）{
printf（“树中至少有一个节点”）；
}
/*将节点搜索到树中*/
tmp=搜索（&root，4）；
如果（tmp）
{
printf（“搜索的节点=%d\n”，tmp->data）；
}
其他的
{
printf（“在树中找不到数据。\n”）；
}
/*删除树的所有节点*/
三角树（根）；
返回0；
}
返回类型为
void
的函数意味着它不返回任何内容。因此，将结果（即无）分配给任何变量是没有意义的

即使它确实返回了一个值，您实际上也没有调用该函数：

nodes[i]= print_postorder;

如果函数名后面没有括号，表达式实际上是函数的地址，而不是调用函数的结果

您希望
print\u postorder
返回树中的节点总数。要执行此操作，请将返回类型更改为
int
，并返回左右子树之和加1，如果子树为空，则返回0：

int print_postorder(node * tree)
{
    if (tree) {
        int left = print_postorder(tree->left);
        int right = print_postorder(tree->right);
        printf("%d\n",tree->data);
        return left + right + 1;
    } else {
        return 0;
    }
}

然后要检查节点的数量，去掉
node
和循环，只需调用函数一次

printf("Post Order Display\n");
int node_count = print_postorder(root);

if(node_count > 0){
    printf("There is at least one node in the tree");
}

char节点[]=“”创建单个字符的数组，并将该单个字符初始化为字符串终止符。至于生成错误，如何调用函数？C不支持方法。仅正常功能。
print\u postorder
不返回任何内容。您不能为某个对象分配任何内容。
nodes[i]=print\u posterorder
尝试使
nodes[i]
等于函数本身（！），而不是其返回值，但是
nodes
被定义为
char
的数组，而不是只有
node*
类型的参数不返回任何内容的函数。
printf("Post Order Display\n");
int node_count = print_postorder(root);

if(node_count > 0){
    printf("There is at least one node in the tree");
}