"Segmentation fault" when accesing dynamically allocated struct members [duplicate] - c

Question

This question already has an answer here:
Pointer losing its value + execv compilation warning
(1 answer)
Closed 7 years ago.
I have started to work on a program which implements a structure called "PhoneBook" having two members: "length" and "allocatedSpace", both of type "unsigned int". The structure is dynamically allocated. The two members of the structure are assigned in an external function called "InitializePhoneBook". Now, when I try to print the values of the two members of the structure inside the "main" function I get a "Segmentation fault" error.
PhoneBook.h
#ifndef PHONEBOOK_H
#define PHONEBOOK_H
struct PhoneBook
{
unsigned int length;
unsigned int allocatedSpace;
};
void InitializePhoneBook(struct PhoneBook *phoneBook);
void ClearPhoneBook(struct PhoneBook *phoneBook);
#endif
PhoneBook.c
#include <stdlib.h>
#include "PhoneBook.h"
void InitializePhoneBook(struct PhoneBook *phoneBook)
{
phoneBook = malloc(sizeof(struct PhoneBook) * 1);
phoneBook->length = 0;
phoneBook->allocatedSpace = 1000;
}
void ClearPhoneBook(struct PhoneBook *phoneBook)
{
free(phoneBook);
}
main.c
#include <stdio.h>
#include <stdlib.h>
#include "PhoneBook.h"
int main(void)
{
struct PhoneBook *phoneBook;
InitializePhoneBook(phoneBook);
printf("%d %d\n", phoneBook->length, phoneBook->allocatedSpace);
ClearPhoneBook(phoneBook);
return 0;
}
Running "./a.out" with "gdb" I get:
Program received signal SIGSEGV, Segmentation fault.
0x0000000000400621 in main () at ./main.c:12
12 printf("%u %u\n", phoneBook->length, phoneBook->allocatedSpace);

Answer 1

When you do malloc in InitializePhoneBook():
phoneBook = malloc(sizeof(struct PhoneBook) * 1);
It doesn't modify the pointer in main because the pointer you assign is local the function. Pass a pointer to pointer or rewrite the function return the malloced pointer.
void InitializePhoneBook(struct PhoneBook **phoneBook)
{
*phoneBook = malloc(sizeof(struct PhoneBook) * 1);
(*phoneBook)->length = 0;
(*phoneBook)->allocatedSpace = 1000;
}
call in main():
InitializePhoneBook(&phoneBook);
and change the prototype:
void InitializePhoneBook(struct PhoneBook **phoneBook);
Other issues I noticed:
You should also check the result of malloc for failure.
Use %u format specifier to print unsigned ints.

Answer 2

C is pass by value. Which means that the parameters are copied when calling a function. Your function InitializePhoneBook() will copy the non-initialised pointer, will assign to that copy the return value of malloc() and then forget that value when leaving the function. Your caller will continue with the un-initialized original.
Your function InitializePhoneBook() can be changed in 2 ways:
struct PhoneBook *InitializePhoneBook(void)
{
struct phoneBook *pb = malloc(sizeof(struct PhoneBook) * 1);
pb->length = 0;
pb->allocatedSpace = 1000;
return pb;
}
or
void InitializePhoneBook(struct PhoneBook **pPhoneBook)
{
*pPhoneBook = malloc(sizeof(struct PhoneBook) * 1);
(*pPhoneBook)->length = 0;
(*pPhoneBook)->allocatedSpace = 1000;
}
the call in main would have to be changed
struct PhoneBook *phoneBook = InitializePhoneBook();
or
struct PhoneBook *phoneBook;
InitializePhoneBook(&phoneBook);
respectively.

Answer 3

The scope of the malloced pointer remains inside the InitializePhoneBook function.
For that you must return the pointer to the main so change the prototype to:
struct PhoneBook *InitializePhoneBook(struct PhoneBook *);
and the last statement of the above function should be:
return phoneBook;
and inside main call it this way:
phoneBook=InitializePhoneBook(phoneBook);