Generic Function Of Stuct Declaration - c

Question

I have built a generic Binary Search Tree.
typedef struct Tree {
void* data;
struct Tree *left;
struct Tree *right;
}Tree;
And two functions that create a Tree with different data type variables.
Tree* GetNewTreeInt(){
Tree* newTree = (Tree*)malloc(sizeof(Tree));
*((int*)newTree->data);
newTree->left = newTree->right = NULL;
return newTree;
}
Tree* GetNewTreeChar(){
Tree* newTree = (Tree*)malloc(sizeof(Tree));
*((char*)newTree->data);
newTree->left = newTree->right = NULL;
return newTree;
}
I have tried to create a generic function that store the function by address
Tree* CreateTree();
int main() {
void* root;
scanf("%d", &choose);
if(choose==0){
Tree* CreateTree=GetNewTreeInt();
(Tree*)root=CreateTree();
}
But I keep getting the following error: called object type "Tree*" (aka 'struct Tree*') is not a function or function pointer

Answer 1

This:
Tree* CreateTree();
..declares a function CreateTree that returns a Tree*, without fully defining the function (no function body, just a prototype). Whereas this:
Tree* CreateTree=GetNewTreeInt();
declares a variable of type Tree* named CreateTree, and calls the GetNewTreeInt() function assigning its return value to CreateTree. This gives you your error since you've already declared a function with the same name.
If you want CreateTree to be a function pointer, and to point it at the GetNewTreeInt function, you need to declare it as (either globally or within main, not both):
Tree *(*CreateTree)();
..and then point it at GetNewTreeInt like this:
CreateTree = GetNewTreeInt;
..and then you can call the function through the pointer with just CreateTree() as with a normal function, eg.:
root = CreateTree();
If you want a typedef of the function pointer type, you can do that as follows:
typedef Tree *(*CreateTreeFuncType)();
...and declare CreateTree as:
CreateTreeFuncType CreateTree;
instead of using the function pointer syntax mentioned earlier.

Answer 2

It looks like you were trying to use a function pointer. To do that you would need to declare a function pointer to a function which return a Tree*, not a Tree* directly:
if(choose==0) {
Tree* (*CreateTree)(void);
CreateTree = &GetNewTreeInt;
}
However, your two functions are identical, since the line *((int*)newTree->data); has no side-effects. You could just create a function like this instead:
Tree* GetNewTreeInt(void){
Tree* newTree = (Tree*)malloc(sizeof(Tree));
newTree->left = newTree->right = NULL;
return newTree;
}
It's when you access tree->data that you need to cast the void * to a pointer of the type you know it contains. If you don't know what type of tree you have externally, you should add another field to your struct which signifies which type of data is stored. If you're only storing small data types like int and char I would recommend using a union instead of a void pointer, since a union will store the data inside the Tree in memory. Either way you'll still need something in your tree to indicate what type of data its storing.
typedef struct Tree {
// 0 means there is an int in tree->data.i,
// 1 means there is a char in tree->data.c
int type;
union {
int i;
char c;
} data;
struct Tree *left;
struct Tree *right;
} Tree;
Then your two functions become:
Tree* GetNewTreeInt(void){
Tree* newTree = (Tree*)malloc(sizeof(Tree));
newTree->type = 0;
newTree->data.i = 0; // Set an initial value
newTree->left = newTree->right = NULL;
return newTree;
}
Tree* GetNewTreeChar(void){
Tree* newTree = (Tree*)malloc(sizeof(Tree));
newTree->type = 1;
newTree->data.c = '\0'; // Set an initial value
newTree->left = newTree->right = NULL;
return newTree;
}
And you can use a function pointer just like this:
if(choose==0) {
Tree* (*CreateTree)(void);
CreateTree = &GetNewTreeInt;
Tree* tree = CreateTree();
tree->data.i = 7;
}
Each tree will have either a data.i or data.c, but not both, later when you're traversing your trees you can check their type to find out which:
if ( tree->type == 0 ) {
int data = tree->data.i;
} else if ( tree->type == 1 ) {
char data = tree->data.c;
}
EDIT
If you really want to use a void *, you can still add the int type to your struct, and when traversing you could do something like this:
if ( tree->type == 0 ) {
int data = *(int *)tree->data;
} else if ( tree->type == 1 ) {
char data = *(char *)tree->data;
}