Thread: malloc seg fault error

It only appears to work...

When you malloc ptr[1] you get a pointer to the memory you allocated
When you assign ptr[1] to string, you abandon the pointer to the allocated memory and assign it to the string array.
The pointer to the allocated memory is now lost... "leaked" in the vernacular, and that memory is locked to your program.

So ptr[1] = string ... does not do what you think it does. It doesn't make a copy of the string.
It becomes a pointer to the string array... so both string and ptr[1] aim at the same target.

You can do ptr[1][0] = 'p' or you can do string[0] = 'p' ... and it will have the same effect because they are now cross connected.

C is a language with absolutely no awareness of strings. What we do in their place is we manipuate arrays of characters. You absolutely cannot assign strings across the = sign like that... all you're doing is making a pointer assignment... not copying the string.

If you doubt me... print out the address of ptr[1] right after allocating memory, then again after assigning it to string... you will have two completely different addresses... If you also print out the address of string, you will discover that it's the same as ptr[1] ... You aren't copying text, you are accidentally mainpulating pointers, and leaking memory to do it.

Moreover; you are still not using free() to release your allocated memory and you are not returning an integer value from main... and yes, it does matter.

Code:

free(ptr[1]);

This gives me either memory dump or seg fault. How to free ptr, ptr[0] and ptr[1] safely?

OK memory leaked so it can't free it.

This works.

Code:

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

int main() {
  char* ptr=(char*)malloc(10*sizeof(char));
  ptr[0]='p';
  ptr[1]='i';
  ptr[2]='e';
  ptr[3]='\0';
  puts(ptr);
  free(ptr);
}

Thanks comm.

Opps....too late.....

Define 'works'. Your code may show the expected result but is wrong (and only works because it is so simple).

You have 'lost' (leaked the memory) the 10 x char block of memory you malloc'ed into ptr[1].

Char arrays have special 'naming'.
If you use the name of the char array, without an index (ie 'string' as opposed to 'string[0]' or 'string[9]') you are telling the complier to use the address of the first character in the 'string' array (ie 'string' == '&(string[0])')

When you malloc 10 chars into ptr[1], you tell the compiler to;
create a block of memory 10 chars wide
set ptr[1][0] to the address of the first char in this new array

So when you set ptr[1] == string [ ie ptr[1][0] == &(string[1][0]) ] you have lost the address of the first char (address) in this malloc'ed array (with no way to get it back).

That is a memory leak and calling 'free(ptr[1]) will cause an exception (as you can not free memory you did not malloc, calloc, etc)

Also 'string' is a local variable, so when the main function ends the complier deletes 'string'.
In your code this is not a problem as the program ends.
In most programs it would mean that ptr[1] now pointed at a block of memory that had been cleaned up (is not valid to use but may still hold the value 'ppple' for some undeterminate amount of time).
This is known as a 'dangling pointer'.

Code:

//alloc the pointers of our main array
char** ptr=(char**)malloc(2*sizeof(char*)); 
//alloc array to hold the actual text  
ptr[1]=(char*)malloc(10*sizeof(char));   
//print text into our array
strcpy(ptr[1], "apple"); //or sprintf(ptr[1], "apple"); etc
//use / modify our array