Question

I’m currently attempting to learn the C side of C++.

I attempt to malloc a chunk of memory for a char array of 256 and then I assigned it a char* "Hello World!" but when I come to free the object I get an error.

Can anyone please explain to me the error.

#include <exception>
#include <stdexcept>
#include <iostream>

int main()
{
    void* charVoidPointer = malloc( sizeof(char) * 256 ) ;
    charVoidPointer = "Hello World";

    std::cout << (char *)charVoidPointer;
    free (charVoidPointer);
}

Answer 1

“Hello World” is statically allocated by the compiler. It is part of the program and exists at some place addressable by the program; call it address 12.

charVoidPointer initially points to some place allocated for you by malloc; call it address 98.

charVoidPointer = “Hello …” causes charVoidPointer to point to the data in your program; address 12. You lose track of address 98 previously contained in charVoidPointer.

And you can’t free memory not allocated by malloc.

To demonstrate more literally what I mean:

void* charVoidPointer = malloc(sizeof(char) * 256);
printf("the address of the memory allocated for us: %p\n", charVoidPointer);
charVoidPointer = "Hello World";
printf("no longer the address allocated for us; free will fail: %p\n",
       charVoidPointer);

What you meant was:

strcpy(charVoidPointer, "Hello World");

Edit: Example of addressing memory for other types

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

int main()
{
  // an array of 10 int
  int *p = (int*)malloc(sizeof(int) * 10);

  // setting element 0 using memcpy (works for everything)
  int src = 2;
  memcpy(p+0, &src, sizeof(int));

  // setting element 1 using array subscripts.  correctly adjusts for
  // size of element BECAUSE p is an int*.  We would have to consider
  // the size of the underlying data if it were a void*.
  p[1] = 3;

  // again, the +1 math works because we've given the compiler 
  // information about the underlying type.  void* wouldn't have
  // the correct information and the p+1 wouldn't yield the result
  // you expect.
  printf("%d, %d\n", p[0], *(p+1));

  free (p);
}

Experiment; Change the type from int to long, or double, or some complex type.