如何修改链表的 header 文件以处理多种类型的数据？

Question

I made a header file for linked list like that. It works properly with any data_t , but whenever I use it, I always have to modify struct data_t in the header file.

How can I declare struct data_t in the main file?

Otherwhile, I have a linked list connecting to the other:

struct food_t{
        char fname[20];
        int time;
        food_t* f_next;
    };

struct person_t{
        char pname[20];
        food_t* food;
        person_t* p_next;
    };

How can I use functions in the.h file with both 2 linked lists?

Here is my header file:

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

struct data_t{
    char name[20];
    char food[20];
};

struct node_t{
    data_t data;
    node_t *pNext;
};

struct list_t{
    node_t *pHead;
    node_t *pTail; 
};

//make new node with input data
node_t *newNode(data_t data){
    node_t *ptr= (node_t *) malloc(sizeof(node_t));
    
    if(ptr==NULL){
        printf("\nCan not allocate memory!!!");
        return NULL;
    }
    else{
        ptr->data=data;
        ptr->pNext=NULL;
        return ptr;
    }
}

//initial list
void initList(list_t& ls){ 
    ls.pHead = ls.pTail = NULL;
}

//free list
void lsFree(list_t &ls){
    node_t *tmp;
    while((tmp=ls.pHead)!=NULL){        
        ls.pHead=ls.pHead->pNext;
        free(tmp);
    }
}

//check empty
bool isEmpty(list_t ls){
    if(ls.pHead==NULL)
        return true;
    else return false;
}

//get size
int getSize(list_t ls){
    if(isEmpty(ls)){
        return 0;
    }
    else{
        int size=0;
        node_t *ptr;
        ptr=ls.pHead;
        while(ptr!=NULL){
            size++;
            ptr=ptr->pNext;
        }
        return size;
    }
}

//Search node with input data
node_t *search(list_t ls, data_t data);

//get id of node. For root(head): root_id=0
int get_node_index(list_t ls, node_t *node){
    if(isEmpty(ls)){
        printf("List is empty!!!\n");
        return -1;
    }
    else
    {
        int index=0;
        node_t *ptr=ls.pHead;
        for(ptr; ptr!=node; ptr=ptr->pNext){ 
            index++;
        }
        return index;
    }
}

//find pointer of node
node_t *findNode(list_t ls, int id){
    node_t *ptr=ls.pHead;
    while(get_node_index(ls, ptr)!=id){
        ptr=ptr->pNext;
    }
    return ptr;
}

//add node to head
void addHead(list_t& ls, node_t *node){
    if(isEmpty(ls)){
        ls.pHead= ls.pTail= node;
    }
    else {
        node->pNext = ls.pHead; 
        ls.pHead= node;
    }
}

//del node from head
void delHead(list_t &ls){
    if(isEmpty(ls)){
        printf("List is empty!!!\n");
    }
    else
    {
        node_t *ptr;
        ptr=findNode(ls, 0); 
        ls.pHead= ls.pHead->pNext;
        free(ptr); 
    }
}

//add node to tail
void addTail(list_t &ls, node_t *node){
    if(isEmpty(ls)){
        ls.pHead=ls.pTail=node;
    }
    else{
        ls.pTail->pNext=node;
        ls.pTail=node;
    }
}

//del node from tail
void delTail(list_t &ls){
    if(isEmpty(ls)){
        printf("List is empty!!!");
    }
    else{
        int n= getSize(ls);
        node_t *ptr=findNode(ls, n-2);
        ls.pTail= ptr;
        free(ptr->pNext);
        ptr->pNext=NULL;
    }
}

//add node at id: new node will have this id
void insert_at_id(list_t &ls, int id, node_t *node){
    if(isEmpty(ls)){
        ls.pHead= ls.pTail= node;
    }
    else
    {
        node_t *ptr=findNode(ls, id-1);
        node->pNext= ptr->pNext;
        ptr->pNext=node;
    }   
}

//Del node at id 
void del_at_id(list_t &ls, int id){
    if(isEmpty(ls)){
        printf("List is empty!!!\n");
    }
    else if(id==0) delHead(ls);
    else
    {
        node_t *ptr=findNode(ls, id-1);
        node_t *tmp=ptr->pNext;
        ptr->pNext=tmp->pNext;
        if(tmp==ls.pTail) ptr=ls.pTail;
        free(tmp); 
    }
}

//Reverse list
void reverse_list(list_t &ls){
    int size=getSize(ls);
    node_t *tail= findNode(ls, size-1);
    node_t *head= findNode(ls, 0);
    for(int i=size-1; i>=0; i--){
        if(i>0){
            node_t *ptr=findNode(ls, i);
            node_t *ptr_before=findNode(ls, i-1);
            ptr->pNext=ptr_before;
        }
        else{
            node_t *ptr=findNode(ls, 0);
            ptr->pNext=NULL;
        }        
    }
    ls.pHead=tail;
    ls.pTail=head;
}

//Export to file
void lsOut(list_t ls, FILE *fout){
    if(isEmpty(ls)){
        printf("List is emptry!!!\n");
    }
    else{
        node_t *ptr=ls.pHead;
        while(ptr!= NULL){
            fwrite(ptr, sizeof(data_t),1, fout);
            ptr=ptr->pNext;
        }
    }
}


//Search and move to head
void move_to_head(list_t &ls, node_t *ptr){
    node_t *tmp=newNode(ptr->data);
    addHead(ls, tmp);
    del_at_id(ls, get_node_index(ls, ptr));
}

//Swap data 2 nodes
void swap(node_t *n1, node_t *n2){
    data_t tmp= n1->data;
    n1->data=n2->data;
    n2->data=tmp;
}

Answer 1

You can just use void* instead of data_t and use cast to deal with that. So since your data is a pointer, you can point to whatever you want. Take a look at this node_t structure:

struct node_t {
    void *data;
    node_t *pNext;
};

Let's ignore all the linked list logic for now and focus only on void *data . So:

• We can store an integer (777) pointer in data:

node_t n;
int *predata = (int*)malloc(sizeof(int));
*predata = 777;
n.data = predata;
printf("%d\n", *((int*)( n.data )));

• Or we can store and retrieve a string:

node_t n;
char *s = (char*)malloc(4);
sprintf(s, "abc");
n.data = s;
printf("%s\n", (char*)n.data); 

So based on this, you can actually use whatever you want as data but you need to make sure to do the proper casts. Note for implementing this way, you will need to do dynamic allocations for all data content you're using. So you're not using a 'list with any type'. You're working with a list of pointers.

Note : I think you're using C++. So you can take a look at C++ templates to solve your problem in a C++ way.