Setting an Array of Integer Pointers - c

Question

I am trying to set an array of integer pointers. The programs is supposed to set the pointers at index i to point to an integer of value 2*i. The programs then should print out the pointees of the first 5 pointer elements, which should be 0,2,4,6,8.
For some reason I am getting a segmentation fault. Could anyone tell me why this happens and what I can do to fix it?
I attempted to replace the final line with " arr[index] = &i; ", which does not give me a segmentation fault but still gives me the wrong results.
Help would be greatly appreciated, just starting off array of pointers.
#include <stdio.h>
void setArr (int);
int * arr[10]; // array of 10 int pointers
int main(int argc, char *argv[])
{
int i;
setArr(0);
setArr(1);
setArr(2);
setArr(3);
setArr(4);
for(i=0; i<5;i++)
printf("arr [%d] = %d\n", i, *arr[i]); /* should be 0, 2, 4, 6, 8 */
return 0;
}
/* set arr[index], which is a pointer, to point to an integer of value 2*index */
void setArr (int index){
int i = 2 * index;
* arr[index] = i;
}

Answer 1

The problem is that you are not allocating memory for what each item in your array points to. The line
*arr[index] = i;
will set some random memory address (whatever was originally in arr[index]) to the value of i.
What you should do is:
void setArr(int index)
{
int *i = malloc(sizeof(int)); // allocate memory for the value
*i = 2 * index; // set the value
arr[index] = i; // make the array slot point at the value
}
but you need to make sure to free() the memory later. For example, before the return 0; statement in your main() function, put:
for (i = 0; i < 5; i++)
free(arr[i]);

Answer 2

You need to malloc space for your pointers inside the array.

Answer 3

This is taken from chapter 9 of Yashavant P. Kanetkar's Let Us "C" and should clarify why what you did earlier didn't work.
When we are using a two-dimensional array of characters we are at liberty to either initialize the strings where we are declaring the array, or receive the strings using scanf( ) function. However, when we are using an array of pointers to strings we can initialize the strings at the place where we are declaring the array, but we cannot receive the strings from keyboard using scanf( ). Thus, the following program would never work out.
main( )
{
char *names[6] ;
int i ;
for ( i = 0 ; i <= 5 ; i++ )
{
printf ( "\nEnter name " ) ;
scanf ( "%s", names[i] ) ;
}
}
The program doesn’t work because; when we are declaring the array it is containing garbage values. And it would be definitely wrong to send these garbage values to scanf( ) as the addresses where it should keep the strings received from the keyboard.
Solution
If we are bent upon receiving the strings from keyboard using scanf( ) and then storing their addresses in an array of pointers to strings we can do it in a slightly round about manner as shown below.
#include "alloc.h"
main( )
352 Let Us C
{
char *names[6] ;
char n[50] ;
int len, i ;
char *p ;
for ( i = 0 ; i <= 5 ; i++ )
{
printf ( "\nEnter name " ) ;
scanf ( "%s", n ) ;
len = strlen ( n ) ;
p = malloc ( len + 1 ) ;
strcpy ( p, n ) ;
names[i] = p ;
}
for ( i = 0 ; i <= 5 ; i++ )
printf ( "\n%s", names[i] ) ;
}
Here we have first received a name using scanf( ) in a string n[ ]. Then we have found out its length using strlen( ) and allocated space for making a copy of this name. This memory allocation has been done using a standard library function called malloc( ). This function requires the number of bytes to be allocated and returns the base address of the chunk of memory that it allocates. The address returned by this function is always of the type void *. Hence it has been converted into char * using a feature called typecasting. Typecasting is discussed in detail in Chapter 15. The prototype of this function has been declared in the file ‘alloc.h’. Hence we have #included this file.
But why did we not use array to allocate memory? This is because with arrays we have to commit to the size of the array at the time of writing the program. Moreover, there is no way to increase or decrease the array size during execution of the program. In other words, when we use arrays static memory allocation takes place.
Chapter 9: Puppetting On Strings 353
Unlike this, using malloc( ) we can allocate memory dynamically, during execution. The argument that we pass to malloc( ) can be a variable whose value can change during execution.
Once we have allocated the memory using malloc( ) we have copied the name received through the keyboard into this allocated space and finally stored the address of the allocated chunk in the appropriate element of names[ ], the array of pointers to strings.
This solution suffers in performance because we need to allocate memory and then do the copying