24

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.

Micha Wiedenmann
  • 19,979
  • 21
  • 92
  • 137
Diana
  • 1,417
  • 5
  • 25
  • 48

2 Answers2

54

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);
ouah
  • 142,963
  • 15
  • 272
  • 331
  • 1
    using __.cpp__ file extension in gcc also causes `invalid conversion from void* to double*` error in above scenario – hungryWolf Sep 20 '17 at 05:05
8

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?.

Community
  • 1
  • 1
Iharob Al Asimi
  • 52,653
  • 6
  • 59
  • 97
  • we can `static_cast` to and from void pointer types in c++, at least – Red Alert May 06 '15 at 21:46
  • @RedAlert isn't `reinterpret_cast` exactly equivalent to c type casts? – Iharob Al Asimi May 06 '15 at 22:00
  • 1
    `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(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. – Red Alert May 06 '15 at 22:24