How to pass an array of pointers, and to let the function find the size of array?

Question

I'm trying to pass an array of pointers to a function, without the need to define the size. Also the output is a warning "initialization makes pointer from integer without cast. Mostly interested in passing array of pointers rather than an array because I'm trying to understand how to deal with the instance when Data is a dynamically allocated memory using malloc

Why is this happening, and how can I pass an array of pointers as an argument, without the need to define its size?

Code:

#include <stdio.h>

void printData(int *data[]);


void main (int argc,char *argv[]){

    int *Data[] = {4, 8, 15, 16, 23, 42};
    printData(Data);

}

void printData(int *data[]){

    int **cur_data = data;
    int counter = sizeof(data)/sizeof(int);
    for(int i = 0; i<counter; i++){
        printf("%d. %d\n", i, *cur_data);
        cur_data++;
    }
}

Warning:

main.c: In function ‘main’:
main.c:9: warning: initialization makes pointer from integer without a cast
main.c:9: warning: initialization makes pointer from integer without a cast
main.c:9: warning: initialization makes pointer from integer without a cast
main.c:9: warning: initialization makes pointer from integer without a cast
main.c:9: warning: initialization makes pointer from integer without a cast
main.c:9: warning: initialization makes pointer from integer without a cast
gcc   main.o -o run

Run: 
0. 4

`int *Data[] = {4, ..., 42};` You are declaring an array of pointers to `int`, and filling it with `int`s... This doesn't have much chances to work. — Quentin, Aug 26 '14 at 11:42
Why do you want to calculate the length automatically. Why not send it as another argument or as first member of array? — Mohit Jain, Aug 26 '14 at 11:44
Always pass at least one pointer[0] that points to the size? — Martin James, Aug 26 '14 at 11:44
Define a struct that has the size as a member and pass that instead? — Martin James, Aug 26 '14 at 11:45
Use pointer arithmetic to store the size below the first pointer? — Martin James, Aug 26 '14 at 11:46
look at how `int main(int argc, char **argv) {}` does it: there are two ways: 1) a count as an extra argument 2) a sentinel value *in* the array. main() uses both methods. — joop, Aug 26 '14 at 12:09

David Ranieri · Accepted Answer · 2014-08-26T12:59:37.137

3

You can't, an array decays into a pointer when is passed to a function, pass counter as a parameter to printData:

#include <stdio.h>

void printData(int *data, int counter);

int main(void)
{
    int Data[] = {4, 8, 15, 16, 23, 42};
    int counter = sizeof(Data) / sizeof(int);

    printData(Data, counter);
    return 0;
}

void printData(int *data, int counter)
{
    for (int i = 0; i < counter; i++){
        printf("%d. %d\n", i, data[i]);
    }
}

Or you can store the counter into the first element of array:

#include <stdio.h>

void printData(int *data);

int main(void)
{
    int Data[] = {0, 4, 8, 15, 16, 23, 42};

    Data[0] = sizeof(Data) / sizeof(int) - 1;
    printData(Data + 1);
    return 0;
}

void printData(int *data)
{
    int counter = data[-1];

    for (int i = 0; i < counter; i++){
        printf("%d. %d\n", i, data[i]);
    }
}

edited Aug 26 '14 at 12:59

answered Aug 26 '14 at 11:48

David Ranieri

39,972
7
52
94

What about if you try to allocate memory dynamically for Data using malloc, then pass that as an argument? – Iancovici Aug 26 '14 at 11:53
1

@echad, makes no difference – David Ranieri Aug 26 '14 at 11:55
@echad: you will need to keep track of the number of elements you allocated, and pass that with the pointer. – John Bode Aug 26 '14 at 12:18

score 1 · Answer 2 · answered Aug 26 '14 at 11:47

1

Here's the corrected program, when you pass an array to a function, it becomes a pointer and loses its size information, so needs to pass separately

#include <stdio.h>

void printData(int *data, int size);


int main (int argc,char *argv[]){

    int Data[] = {4, 8, 15, 16, 23, 42};
    printData(Data, sizeof(Data));
    return 0;
}

void printData(int *data, int size){
    int *cur_data = data;
    int counter = size/sizeof(int);
    for(int i = 0; i<counter; i++){
        printf("%d. %d\n", i, *cur_data);
        cur_data++;
    }
}

and the output is:

answered Aug 26 '14 at 11:47

Dr. Debasish Jana

6,980
4
30
69

What about if you try to allocate memory dynamically for Data using malloc, then pass that as an argument? – Iancovici Aug 26 '14 at 11:54
even the sizeof a pointer is just 4 bytes on 32-bit system – Dr. Debasish Jana Aug 26 '14 at 11:57

score 1 · Answer 3 · answered Aug 26 '14 at 12:04

You declared array Data as an array of pointers but initialized it with integral constants instead of addresses.

int *Data[] = {4, 8, 15, 16, 23, 42};

So the compiler issues diagnostic messages.

You can do the task the following way that is by using a sentinal value that in this case is equal to NULL.

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

void printData( int *data[] );


int main(void) 
{
    int Values[] = { 4, 8, 15, 16, 23, 42 };
    const size_t N = sizeof( Values ) / sizeof( *Values );
    int *Data[N+1];
    size_t i;

    i = 0;
    for ( ; i < N; i++ )
    {
        Data[i] = malloc( sizeof( int ) );
        *Data[i] = Values[i];
    }
    Data[i] = NULL;

    printData( Data );

    for ( i = 0; i < N + 1; i++ ) free( Data[i] );

    return 0;
}

void printData( int *data[] )
{
    int **p = data;
    size_t i = 0;

    for( ; *p != NULL; ++p, ++i )
    {
        printf("%d. %d\n", i, **p );
    }
}

The output is

Take into account that function main shall have return type int

If you use a variable length array, then you don't need to use `malloc`, anyway there is no need to (m)allocate for each value, a single `malloc` is enought: http://ideone.com/YN90yO — David Ranieri, Aug 26 '14 at 12:30
@Alter Mann I used separate malloc under the expression that the original code initialize each element of the array.:) So initially I wanted to write something as int *Data = { malloc( sizeof( int ) ), malloc( sizeof( int ), /*...*? }; :) — Vlad from Moscow, Aug 26 '14 at 12:38

Sathish · Answer 4 · 2014-08-26T11:50:40.843

Where-

int *Data[];

where data is a array of pointer to an integer. This array pointer can point to 1D arrays or integer. But you are filling with integer data. For 1D array use

int Data[]={4, 8, 15, 16, 23, 42};

And there is no way to know the size of the array using pointer! Only way is pass the no of element to the function with address of an array!

Try these changes-

#include <stdio.h>

void printData(int *data,int element);


void main (int argc,char *argv[]){

    int Data[] = {4, 8, 15, 16, 23, 42};
    printData(Data,6);

}

void printData(int *data, int element){

    int *cur_data = data;
    int counter = (sizeof(data)*element)/sizeof(int);
    for(int i = 0; i<counter; i++){
        printf("%d. %d\n", i, *cur_data);
        cur_data++;
    }
}

No 2D array in here. An `int*` doesn't necessarily point to an array. — Quentin, Aug 26 '14 at 11:46

How to pass an array of pointers, and to let the function find the size of array?

4 Answers4