void Pointer to a structure causes error 'dereferencing 'void *' pointer'

Question

I try to initialize a queueADT pointer called initAmigo. Apparently I never create one if the structure is not making the pointers for the (void *data)

Reasons why I can't put any data in void *data in node structure:

Asuumption 1: Take away void *data and say User_struct (from .h file)

Assumption 2: RegisteredData is not supposed to be a pointer because the parameter in que_Insert asks for a pointer)

Assumption 3: In AddUser function, que_insert( initAmigo , registeredData); The registeredData to be inserted in the void *data node was actually a pointer to a pointer to a structure

Having a queue reference a void * creates the following error:

amigonet.c: In function 'findUser':
amigonet.c:247:21: warning: dereferencing 'void *' pointer [enabled by default]
   if (currNode->data->name == name) {  //If front is the name being searched
                     ^
amigonet.c:247:21: error: request for member 'name' in something not a structure or union
amigonet.c:253:22: warning: dereferencing 'void *' pointer [enabled by default]
    if (currNode->data->name == name ) {

.c file just has to create a structure of a queue of Users (QueueADT initAmigo)

typedef struct node {
                                    //name of data userStruct (just for referencing)
    void* data;
    struct node *next;
}node;


struct queueStruct {
    struct node *front;                             /* pointer to front of queue */
    struct node *rear;                              /* pointer to rear of queue  */
    int (*cmprFunc)(const void*a,const void*b);     /* The compare                                          function used for insert */

};

typedef struct queueStruct *QueueADT;       //typedef inserted for pointers, 
                                                //name is QueueADT

#define _QUEUE_IMPL_
#include "queueADT.h"

/// create a queue that is either sorted by cmp or FIFO
//function with two void
QueueADT que_create( int (*cmp)(const void*a,const void*b) ) {

    QueueADT new;
    new = (QueueADT)malloc(sizeof(struct queueStruct));     //NOTE: NO POINTERS HERE
                                                            //use pointers in Single lines
    if (cmp == NULL) {
        new->front = NULL;
        new->rear = NULL;
        new->cmprFunc = NULL;

    } else {
        new->cmprFunc = cmp;
        new->front = NULL;
        new->rear = NULL;
    }
    return ( new );
}

//free the queue once the nodes have been cleared from the queue
void que_destroy( QueueADT queue ) {
    if ( queue->front == NULL ) {
        free(queue);
    } else {
        que_clear(queue);
        free(queue);
    }
}

//passes a real pointer for dynamic allocation
//set a temp to the front to be deleted, then front becomes the next and delete the temp

void que_clear( QueueADT queue ) {


    while (queue->front->next != NULL) {
        struct node *temp;
        temp = (struct node*)malloc(sizeof(struct node));
        temp = queue->front;
        queue->front= queue->front->next;

        free(temp);
        }
}


//if the cmpr function returns a positive then put in in before the b node in cmp(curr, temp)   
void que_insert( QueueADT queue, void *data ) {
    struct node *temp;
    temp = (struct node*)malloc(sizeof(struct node));
    temp->data= data;
    temp->next = NULL;
    node *currNode;             //simply a pointer
    currNode = queue->front;
    if ( queue->front != NULL ) {               //+1 or more in Q
            if ( queue->cmprFunc == NULL ) {        //if the cmp_func is FIFO

                queue->rear->next = temp;
                queue->rear= temp;
                queue->rear->next=NULL;
                if ( queue->front == queue->rear ) {
                    currNode->next = temp;
                    queue->rear = temp;
                    temp->next= NULL;
                    }
            } else {

                while ( currNode->next != NULL ){       //2 or more
                    if (( (*(queue->cmprFunc))(currNode->data, temp->data) >= 0 
                           && ( currNode == queue->front)) ) {
                            temp->next = currNode;
                            queue->front=temp;
                            break;
                            }
                    if (( (*(queue->cmprFunc))(currNode->next->data, temp->data) >= 0 ) ) {             

                            temp->next = currNode->next;
                            currNode->next = temp;
                            break;
                    } else  {
                        currNode = currNode->next;          //move past front and possibly rear
                        if (currNode->next == NULL )  {     //currNode is rear of queue
                            currNode->next = temp;
                            queue->rear = temp;
                            temp->next = NULL;
                            break;
                        }
                                            //exit_failure  
                    }
                }
                if ( queue->front == queue->rear ) {        //exactly 1 node in queue

                    if (( (*(queue->cmprFunc))(currNode->data, temp->data) >= 0 ) ) {

                            temp->next = queue->front;
                            queue->front = temp;
                        } else {

                            queue->front->next = temp;
                            queue->rear = temp;

                        }
                    }
            }
    } else {                                            
        queue->front = temp;
        queue->rear= queue->front;
        queue->front->next= queue->rear->next = NULL;

        }
    }


//removes the front
void *que_remove( QueueADT queue ) {
    if ( queue->front != NULL ) {       //if the size of queue is greater than 1
        node *currNode;                 // dont make new node, pointer
        currNode = queue->front;
        void *data = currNode->data;
        if ( queue->front == queue->rear ) { //if size of queue is 1
            free(currNode);
            queue->front = queue->rear = NULL; //set both to NULL
        } else {
            queue->front= currNode->next;
            free(currNode);
        }
        return data;    
    }
    return NULL;
}

bool que_empty( QueueADT queue ) {
    if ( queue->front == NULL ) {
        return true;
    } else {
        return false;
        }
}


QueueADT initAmigo; 

//struct queueStruct *initAmigo
//QueueADT initAmigo;

//make a Queue with front and rear
    //compare function with A-Z

struct Friends_struct {
    struct queueStruct *amigos_Queue;
};  


void create_amigonet() {
    //makes the same thing as que_Create 
    //(Friends)malloc(sizeof(struct Friend_struct));

    initAmigo = que_create(NULL);
    printf("%lu Founded size of an.c\n\n\n\n\n\n\n\n\n\n\n", sizeof(initAmigo));
}


//The add user will find a new user and make the name of the user to a amigonet
//add Usernode to queue initAmigo
//make sure set to first and display queue

void addUser( const char *name ) {
    //create Usernode and void *data (user w/ friends)
    //check to see if User already exists
    if ( findUser(name) != NULL) {
        return;
    }
    //create data for node, by initializing memorry for a userStruct
    struct User_struct *registeredData;
    registeredData = ( struct User_struct* )malloc(sizeof(struct User_struct));     //first user Data

    registeredData->name = name;

    //create a Friends
        //put this in file create F
    struct Friends_struct *initAmigos;
    initAmigos = (struct Friends_struct*)malloc(sizeof(struct Friends_struct));     //NOTE: NO POINTERS HERE
    //set Friends list to Null
    initAmigos->amigos_Queue = que_create( NULL );

    //put User with empty Friends struct
    registeredData->amigos = initAmigos;

    //void que_insert( QueueADT queue, void *data )
    que_insert( initAmigo , registeredData);
    printf("%s User was inerted \n", name);

}
//Find a user in the init Amgio
//start at front as temp, go to next until name found

User *findUser( const char *name ) {
    struct node *currNode;
    currNode =  initAmigo->front;
    printf("%lu Founded size of an.c\n\n\n\n\n\n\n\n\n\n\n", sizeof(initAmigo));
    if ( initAmigo->front == NULL ) {
        return NULL;
    } else {
        if (currNode->data->name == name) {  //If front is the name being searched
            return currNode->data;
        }
               //Loop after front 
        while ( currNode->next != NULL ) {
            currNode = currNode->next;
            if (currNode->data->name == name ) {
                return currNode->data;
            }
        }
        node *rear = currNode;
        if (rear->data->name == name ) {
            return rear->data;
        }
    }
    //User Not Founded
    return; 
}
#if 0
void addAmigo( User *user, User *amigo ) {

    //check to see if node exits within friends
    //go to use friends list
    //traverse the node, check data for amigo->name == data->name

    if (  user->amigos->amigos_Queue->front != NULL ) {
        node *currNode = user->amigos->amigos_Queue->front;
        if ( currNode->data->name == amigo->name ) {
            return ;
        } else {
            //loop to determine if User friend  queue front to rear has amigo already
            while ( currNode->next != NULL ) {
                currNode = currNode->next;
                if (currNode ->data->name == amigo->name) {
                    return;
                }
            }
        }
    }
    que_insert( user->amigos->amigos_Queue, amigo);
}


void removeAmigo( User *user, User *ex_amigo) {
    //Pre Condition: Amgio exists in user


    //go to user
    //set user as currNode


    //either create a function in queueADT remove
    // use a prev and curr and next and traverse, remove, connect
    //preconditions: front is not examigo
    //   rear is not examigo
    // amigo is friend of user

}


size_t separation( const User *user1, const User *user2 ) {

    return;
    //queue a DFS
    // queue a BFS
    //  
}
//search using a queue BFS
//search using a DFS

//number of users and their names
void dump_data() {
    if (initAmigo->front != NULL) {
        node *currNode = initAmigo->front;
        printf("%s: Amigos!\n", currNode->data->name);      //prints the name of the first node
        while ( currNode->next != NULL ) {
            currNode = currNode->next;
            printf("%s: Amigos!\n", currNode->data->name);
        }
    //while loop of each user set to currNodw

    //set a variable for currNodeAmigo and print the names of them inside ^^^
    }
}

void destroy_amigonet(){
    //clear Friend Queue and destroy for each User Friend
    //destroy initAmigo queue
}

The questions is as follows: Why does it say I am dereferncing a void *data when in que_Insert I put a structure of User_struct there? How do I insert a structure without the error? Was my problem in AddUser when I initialized void *Data in FindUser when I didn't cast a pointer with ->data->name? — arrowinfedex, Nov 07 '14 at 22:51

Nisse Engström · Accepted Answer · 2016-04-29T20:14:18.347

1

The problem looks like this:

typedef struct node {
  void* data;
  struct node *next;
}node;

...

struct node *currNode;

if (currNode->data->name == name) {  //If front is the name being searched
    return currNode->data;
}

The type of currNode->data is void *. This is an incomplete type, which means that it cannot be dereferenced. The compiler has no idea what to make of whatever it points at. You need to convert the void pointer, into a pointer to a meaningful type.

You have not defined the User type in the code you posted, but I'm guessing that you want something like this:

User *user = currNode->data;

if (user->name == name) {
    return user;
}

You will also have to make similar changes elsewhere in the same function.

edited Apr 29 '16 at 20:14

answered Nov 07 '14 at 23:40

Nisse Engström

4,738
23
27
42

I really like the void *data, however it was used for my last project and I can actually change it to the real name of the struct and change all the parameters with that. Would you way actually work or would it be creating another pointer to a pointer? – arrowinfedex Nov 08 '14 at 00:32
User is defined in the h file as `typedef struct User_struct {` `const char *name;` `Friends amigos;` `} User;` The AddUser function changed void *data to point at that structure, so I thought so. – arrowinfedex Nov 08 '14 at 04:01
@arrowinfedex: If you want the `que`-function to be generic (able to handle any kind of object), then you _need_ the `void *data` member. If you only care about one type of object, then using the correct type throughout would provide better type safety. It's your call. – Nisse Engström Nov 08 '14 at 08:08
I talked to my friend who was more specific and said I would need to cast the parameter for the void *data. Assuming I can use createAmigo(), the addUser would need que_Insert(queue, (*User_struct)registeredData) Does that sound right? – arrowinfedex Nov 10 '14 at 15:31
No. What you have is not a cast. Did you mean `(struct User_struct *)registeredData`? Then, no again, because `registeredData` _already_ has that type. What's the point of casting one type to the exact same type? You can pass the value un-casted, but when you retrieve the pointer from the queue again, make sure that you store it in a variable of the correct type (`struct User_struct *`). No casts are needed. (In C anyway. C++ has different rules). – Nisse Engström Nov 10 '14 at 16:39

void Pointer to a structure causes error 'dereferencing 'void *' pointer'

1 Answers1