how int arr[] is array of pointers to int but char arr[] is array of pointers to string?

Question

In C

int *arr[]

is clearly an array of pointers to int but for

char *arr[]

is array of pointers to strings, how is that so. Then how does compiler differentiate in this two. I read this question-

Char* array of chars, but int* not array of ints?

but with array of pointers to strings we are talking about big memory which compiler will have to create separately for strings and then to array of pointer do compiler treat variables separately somehow?

`char *arr[]` need not be arrays of pointers to strings because the contents may be `NULL` or pointers to data that are not null-terminated. It is an array of pointers to `char`. — MikeCAT, May 06 '21 at 14:27
@MikeCAT I don't get it what you mean by data that are not null-terminated.and yeah it should just create array of pointers to char and not to string — UV0, May 06 '21 at 14:30
C has no type called `string`. A string is an array of chars. Like any array, a pointer to a string is a pointer to its first element. — stark, May 06 '21 at 14:32
Actually, `char **array[]` would be an array of pointers to strings. `char *array[]` is an array of strings since, as others have pointed out, a string in C is just a `char*`. — Daniel Walker, May 31 '21 at 15:31

score 2 · Answer 1 · answered May 06 '21 at 14:31

int* and char* behave the same, only the latter is treated as a C string while the former is not. A C string is just a pointer to char, as in "one or more characters depending on the size of the allocated memory at the destination".

int *arr[] // Array of pointers to (at least one) int
char *arr[] // Array of pointers to (at least one) char (a.k.a. a "C string")

The compiler doesn't differentiate specifically, but all the default str-family functions only work with char*. By tradition and convention char* is how a C string is defined. It could very well have been int* under different circumstances, or even something else entirely such as how some operating systems use UTF-16 instead of 8-bit encoding.

In both cases int* x[] and char* y[] behave exactly the same.

score 0 · Answer 2 · edited May 31 '21 at 15:27

No, the compiler does not differentiate them in general.

Consider the declarations

int a[] = { 1, 2, 3 };
int * pa[] = { a, a + 1,  a + 2 };

and

char s[] = { '1', '2', '3' };
char * ps[] = { s, s + 1, s + 2 };

As you can see there is no principal difference.

Here is a demonstrative program.

#include <stdio.h>

int main(void) 
{
    int a[] = { 1, 2, 3 };
    int * pa[] = { a, a + 1,  a + 2 };
    
    for ( size_t i = 0; i < sizeof( pa ) / sizeof( *pa ); i++ )
    {
        printf( "%d ", *pa[i] );
    }
    putchar( '\n' );
    
    char s[] = { '1', '2', '3' };
    char * ps[] = { s, s + 1, s + 2 };

    for ( size_t i = 0; i < sizeof( ps ) / sizeof( *ps ); i++ )
    {
        printf( "%c ", *ps[i] );
    }
    putchar( '\n' );
    
    return 0;
}

The program output is

1 2 3 
1 2 3

The only difference is that the Standard declares string functions that expect an argument of the type char * that points to the first element of a string while specially for the type int * such functions are absent.

Accordingly some output functions are specially designed to output strings when their arguments have the type char * because strings have the sentinel value '\0' unlike arrays with the element type int.

score 0 · Answer 3 · answered May 06 '21 at 14:39

"Arrays" in C are essentially wrappers for pointers - they do have differences but for the sakes of this question you can think of them as pointers to the first element within them.

Secondly, pointers and arrays in C can be subscripted - which is to say that you can use square brackets ([]) to perform array-like access to them. Underneath the hood this is just some pointer arithmetic to get the desired element.

This means that both type* var and type var[] can be an "array" of type, but type* name can also just be a plain old pointer to some data of type type - looking at it without context you can't really tell.

So int *arr[] is either an array of int "arrays" or of pointers to individual ints

And char *arr[] is either an array of char "arrays" or of pointers to individual chars

Finally - the C compiler doesn't care about what they are provided that you syntactically use them correctly - you could access an int* as an array which isn't one and get garbage data but it's not the job of the C compiler to tell you not to.

how int *arr[] is array of pointers to int but char *arr[] is array of pointers to string?

3 Answers3

how int arr[] is array of pointers to int but char arr[] is array of pointers to string?