End of integer/structure array? - c

Question

Consider the following functions
void alloco(int **ppa)
{
int i;
printf("inside alloco %d\n",ppa); /*this function allocates and fills 20 * sizeof(int) bytes */
*ppa = (int *)malloc(20 * sizeof(int));
/*fill all 20 * sizeof(int) bytes */
}
int main()
{
int *app = NULL;
int i;
printf("inside main\n");
alloco(&app);
for(i=0;i<20;i++) /*ISSUE::how will i know to traverse only 20 indexes?*/
printf("app[%d] = %d \n", i, app[i]);
return(0);
}
Basically how will main() come to know number of bytes to traverse i.e memory allocated by alloco() function. Is there any delimiter like NULL in character arrays?

Answer 1

That is not possible, you need to keep that value somewhere, for example you could do this,
void alloco(int **ppa, int count)
{
int i;
printf("inside alloco %d\n",ppa);
*ppa = malloc(count * sizeof(int));
if (*ppa == NULL)
return;
for (i = 0 ; i < count ; ++i)
/* fill it here. */
}
int main()
{
int *app;
int i;
int count;
count = 20;
app = NULL;
printf("Inside main\n");
alloco(&app, count);
if (app == NULL)
return -1;
for (i = 0 ; i < count ; i++)
printf("app[%d] = %d \n", i, app[i]);
/* done with `app' */
free(app);
return 0;
}
Many other combinations could work, for example
int alloco(int **ppa)
{
int i;
printf("inside alloco %d\n",ppa);
*ppa = malloc(20 * sizeof(int));
if (*ppa == NULL)
return;
for (i = 0 ; i < count ; ++i)
/* fill it here. */
return 20;
}
int main()
{
int *app;
int i;
int count;
printf("Inside main\n");
app = NULL;
count = alloco(&app);
if (app == NULL)
return -1;
for (i = 0 ; i < count ; i++)
printf("app[%d] = %d \n", i, app[i]);
/* done with `app' */
free(app);
return 0;
}
But I personally don't like this because if there is going to be a fixed number of integers it's not a good idea to use malloc() just,
int main()
{
int app[20];
int i;
printf("Inside main\n");
for (i = 0 ; i < sizeof(app) / sizeof(app[0]) ; i++)
printf("app[%d] = %d \n", i, app[i]);
return 0;
}

Answer 2

Is there any delimiter like NULL in character arrays?
If you define one, yes.
This however only is possible if your use case does not need all possible integer values.
If for example you would only need positive values including 0 you can define the value of -1 to be the "End-of-Array" marker.
You then would allocate one more element to the array then you need and assign -1 to this additional very last array element.
Example:
#include <stdlib.h> /* for malloc */
#include <errno.h> /* for errno */
#define EOA (-1)
int array_allocate(int ** ppi)
{
int result = 0;
if (NULL = ppi)
{
result = -1;
errno = EINVAL;
}
else
{
size_t number_of_elements = ...; /* Assign some positive value here. */
*ppi = malloc((number_of_elements + 1) * sizeof ** ppi);
if (NULL == *ppi)
{
result = -1;
}
else
{
(*ppi)[number_of_elements] = EOA;
}
}
return result;
}
ssize_t array_number_of_elements(int * pi)
{
int result = 0;
if (NULL == pi)
{
result = -1;
errno = EINVAL;
}
else
{
int * pi_tmp = pi;
while (EOA != *pi_tmp)
{
++pi_tmp;
}
result = pi_tmp - pi;
}
return result;
}
Use it like this:
#include <stdlib.h> /* for size_t and ssize_t */
#include <stdio.h> /* for printf and perror */
int array_allocate(int **);
ssize_t array_number_of_elements(int *);
int main(void)
{
int result = EXIT_SUCCESS;
int * pi = NULL;
if (-1 == array_allocate(&pi))
{
result = EXIT_FAILURE;
perror("array_allocate() failed");
}
else
{
ssize_t result_number_of_elements = array_number_of_elements(pi);
if (-1 == result_number_of_elements)
{
result = EXIT_FAILURE;
perror("array_number_of_elements() failed");
}
else
{
size_t number_of_elements = result_number_of_elements;
printf("The number of array's elements is %zu.\n",
number_of_elements);
}
}
free(pi); /* Clean up. */
return result;
}

Answer 3

It takes becoming a 3-Star Programmer
You can easily allocate some fixed number of elements (less than the maximum) in an function without passing the number of elements between the caller function and the callee. However, it takes creating an array of pointers to pointers to type How/Why? Essentially, you are treating your array as a null-terminated string, initially allocating all pointers to type within the array to NULL and only allocating space for them as needed. (allocating with calloc makes this a snap) When the array is used back in the caller, it allows iterating over all filled values until your reach the first null-pointer.
Now granted,
simply passing a pointer to size as an additional argument to your
function makes much more sense [1]
and eliminates the need for a triple-star rating, but for the purpose of example, enjoy being a 3-Star Programmer for a while:
#include <stdio.h>
#include <stdlib.h>
#define INITSZ 21
void alloco (int ***ppa)
{
printf("inside %s\n", __func__);
int i = 0;
/* allocate 21 pointers-to-int */
if (!(*ppa = calloc (INITSZ, sizeof **ppa))) {
fprintf (stderr, "%s() error: virtual memory exhausted.\n", __func__);
exit (EXIT_FAILURE);
}
/* allocate/fill 20 values (or anything less than 21) */
for (i = 0; i < INITSZ - 1; i++) {
if (!((*ppa)[i] = calloc (1, sizeof ***ppa))) {
fprintf (stderr, "%s() error: virtual memory exhausted.\n", __func__);
exit (EXIT_FAILURE);
}
*((*ppa)[i]) = i * 2;
}
}
int main()
{
int **app = NULL;
int i = 0;
printf ("inside main\n");
alloco (&app);
/*ISSUE::how will i know to traverse only 20 indexes?*/
while (app[i]) {
printf("app[%d] = %d \n", i, *(app[i]));
i++;
}
return(0);
}
Use/Output
$ ./bin/alloc_array+1
inside main
inside alloco
app[0] = 0
app[1] = 2
app[2] = 4
app[3] = 6
app[4] = 8
app[5] = 10
app[6] = 12
app[7] = 14
app[8] = 16
app[9] = 18
app[10] = 20
app[11] = 22
app[12] = 24
app[13] = 26
app[14] = 28
app[15] = 30
app[16] = 32
app[17] = 34
app[18] = 36
app[19] = 38
footnote [1]: emphasis added to the quote for clarity that this solution was intended to show what was possible, not what was most efficient or most practical.