malloc - invalid conversion from void* to double*

Question

I want to write a function that creates a copy of a double array using pointers. This is my code so far:

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

double* copy (double *array, int size)
{
    double *v=malloc(sizeof(double)*size);
    for (int i=0; i<size; i++)
        *(v+i)=*(array+i);
    return v;
}

int main ()
{
    //double array[];
    int size;
    printf ("size= "); scanf ("%i",&size);
    double *array=malloc(sizeof(double)*size);
    for (int i=0; i<size; i++)
        scanf("%f",&array[i]);
    copy(array,size);
    free(array);
}

I have 2 compilation errors that I can't get rid of. I get

invalid conversion from void* to double*

when I try to allocate memory using malloc but I can't understand what I'm doing wrong.

Solution 1

You are using a C++ compiler.

double *array=malloc(sizeof(double)*size);

is valid in C. There is an implicit conversion from any object pointer type to void *.

In C++ it is not valid, there is no such implicit conversion, and you need a cast:

double *array= (double *) malloc(sizeof(double)*size);

Solution 2

You are compiling c code, with a c++ compiler.

When you are using a c++ compiler, you should write c++ code, so malloc() is not so common in c++, instead

double *data = new double[size];

would be good c++ code, if you need to free() the pointer, you need to

delete[] data;

You can of course use malloc() in c++, but it would be like this

double *data = static_cast<double *>(malloc(size * sizeof(double));

because void * in c++ is not converted to any pointer type automatically.

In c, however, there is no need for the cast, and in fact it makes the code unnecessarily ugly apart from hiding bugs from your program, cehck here Do I cast the result of malloc?.

Comments

[Red Alert]

we can static_cast to and from void pointer types in c++, at least

[Iharob Al Asimi]

@RedAlert isn't reinterpret_cast exactly equivalent to c type casts?

[Red Alert]

reinterpret_cast is a specialization of the very generic c-casting. When you use a c-style cast, the compiler picks what kind of cast to use. For instance, you can't say reinterpret_cast<double>(6), but you can say (double) 6. Furthermore, reinterpret_cast cannot cast away constness, while a c-style cast can (you need const_cast for this in c++). In the cast of void*, there is technically nothing to "reinterpret", since a void pointer does not reveal what type it is pointing to.

[hungryWolf]

using .cpp file extension in gcc also causes invalid conversion from void* to double* error in above scenario