VS17 not initializing pointer

Question

My problem is that this code is not working in VS 2017 while in CLion it works. VS says:

Severity Code Description Project File Line Suppression State Error (active) E0144
a value of type void * cannot be used to initialize an entity of type queue_t*

therefor the program is not allocating the memory.

Further every pointer like the example above is not working.

Does somebody here know why that is the case, why VS thinks that this would be a void?

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

struct packet_t {
    double d;
    int i;
    long l;
    char *p;
    struct queue_t *queue;
};

struct queue_t {
    char *name;
    int size;
    int entries;
    double time;
    struct packet_t **packets;
    int read;
    int write;
    long lost;
    long total;
};


int decision = -1;
int isRunning = 1;

void logError(char message[]) {
    printf("ERROR: %s", message);
}

struct queue_t *queue_create(char *name, int size) {
    struct queue_t *q = malloc(sizeof(struct queue_t));

    if (!q) {
        logError("could not allocate memory!\n");
        return 0;
    }
    else {
        q->name = name;
        q->size = size;
        q->entries = 0;
        q->read = 0;
        q->write = 0;
        q->total = 0;
        q->lost = 0;

        q->packets = malloc(size * sizeof(struct packet_t *));

        if (!q->packets) {
            logError("could not allocate memory!\n");
            free(q);
            return 0;
        }

        struct packet_t **current;
        for (int i = 0; i < size; i++) {
            current = q->packets + i;
            *current = NULL;
        }
    }
    return q;
}

int packet_destroy(struct packet_t *packet) {
    //TODO test if deleted ?
    if (packet) {
        free(packet);
        return 1;
    }
    return 0;
}

long queue_store(struct queue_t *queue, struct packet_t *packet) {
    if (queue->entries < queue->size) {
        packet->queue = queue;
        *(queue->packets + queue->write) = packet;

        queue->write++;

        if (queue->write == queue->size) {
            queue->write = 0;
        }

        queue->total++;
        queue->entries++;

        return queue->total;
    }
    //cant save packet ->destroy
    packet_destroy(packet);
    queue->lost++;
    return 0;
}

struct packet_t *queue_retrieve(struct queue_t *queue) {
    if (queue->entries == 0) return NULL;

    struct packet_t **current = queue->packets + queue->read;
    struct packet_t *packet = *current;

    *current = NULL;
    if (packet->queue) {
        packet->queue = NULL;
    }
    queue->entries--;

    queue->read++;
    if (queue->read == queue->size) {
        queue->read = 0;
    }

    return packet;
}

struct packet_t *packet_create(int i, double d, long l, char *p) {
    struct packet_t *new = malloc(sizeof(struct packet_t));
    if (new) {
        new->i = i;
        new->d = d;
        new->l = l;
        new->p = p;
    }
    else {
        logError("failed to allocate memory");
    }

    return new;
}

int queue_destroy(struct queue_t *queue) {
    if (!queue) {
        logError("could not find queue!");
        return 0;
    }
    struct packet_t *p;

    for (int i = 0; i < queue->size; i++) {
        p = *(queue->packets + i);
        packet_destroy(p);
    }

    //TODO test if not needed as it's already free'd in packet_destroy
    free(queue->packets);
    free(queue);
    return 0;
}

long test_queue(int val) {
    int sum = 0, finalTime = 0;
    clock_t startTime, finalTicks;
    startTime = clock();

    while (finalTime < val) {
        struct queue_t *q = queue_create("test", 10);
        queue_destroy(
            sum++;
        finalTicks = (clock() - startTime);
        //        printf("ticks: %d\n", finalTicks);
        finalTime = (int)floor((finalTicks / (double)CLOCKS_PER_SEC));
        //        printf("time: %d\n", finalTime);
    }

    printf("Runtime: %d\n seconds", finalTime);
    printf("Added and removed %d queues\n", sum);
}

long test_packets(int val) {
    int finalTime = 0;
    struct queue_t *q = queue_create("test", 10);
    clock_t startTime, finalTicks;
    startTime = clock();

    while (finalTime < val) {
        struct packet_t *t = packet_create(finalTime, finalTime + 1, finalTime + 2, NULL);
        queue_store(q, t);
        packet_destroy(queue_retrieve(q));
        finalTicks = (clock() - startTime);
        //        printf("ticks: %d\n", finalTicks);
        finalTime = (int)floor((finalTicks / (double)CLOCKS_PER_SEC));
        //        printf("time: %d\n", finalTime);
    }

    printf("Runtime: %d\n", finalTime);
    printf("Successfully added %li entries\n", q->total);
    printf("Failed to add %li entries\n", q->lost);

    queue_destroy(q);
}

void resetDecision() {
    decision = -1;
    isRunning = 1;
}

void checkDecision() {
    while (decision != 0 && decision != 1 && decision != 2) {
        printf("Select option:\n (1) Run queue test \n (2) Run packet test \n(0) to cancel \n");
        scanf("%d", &decision);
    }
    if (decision == 0) {
        isRunning = 0;
    }
    else if (decision == 1) {
        int val = 0;
        while (val <= 0) {
            printf("Enter the time to test");
            scanf("%d", &val);
        }
        printf("Running test for %d seconds....\n", val);
        test_queue(val);
    }
    else if (decision == 2) {
        int val = 0;
        while (val <= 0) {
            printf("Enter the time to test");
            scanf("%d", &val);
        }
        printf("Running test for %d seconds....\n", val);
        test_packets(val);
    }

    if (decision != 0)
        resetDecision();
}

int main() {
    while (isRunning) {
        checkDecision();
    }
    return 0;
}

Answer 1

You are compiling your program as a C++ program. In C++ there is no implicit conversion from the type void * to pointer of other object type.

So you need to write using explicit casting like

struct queue_t *q = ( struct queue_t * )malloc(sizeof(struct queue_t));

Or you should consider your program as indeed a C++ program and use the operator new instead of the C function malloc.