How to insert this array in sizeof() function?

Question

I asked a few questions here by now, and people don't like them, so I'll make it short.

I have tried to make a dynamically allocated array of int, and then I wanted to assign it a constant array just for test, and I couldn't do it.

When we want to create an array of chars we write: char *arr = "abc";

It didn't work like this: int *arr = {1,2,3};

but it did work when I did that: int *arr = (int[]) {1,2,3};

honestly I don't know how that cast did the job, and I was happy, until I tried to get the number of elements: int n = sizeof(arr)/sizeof(int);

1. How does the cast make it work?

2. How to pass that array to sizeof()?

Thank you.

Answer 1

How does the cast make it work?

A string literal is a specifically supported "syntactic sugar" in C. It is an unnamed static array of char with an appended '\0'. That's why you don't need to provide type information in an initialization like this. BTW, don't attempt to modify any of its elements, it is not defined.

char *arr = "abc";

For an array of any other type you need to help the compiler to determine the correct type. So you "extend" the expression to a compound literal. It is not a cast:

int *arr = (int[]){ 1, 2, 3, };

How to pass that array to sizeof()?

sizeof is an unary operator, like - (as a negative sign for numerical values) and ~.

Its operand is an object or a type. The latter needs to be in parentheses.

But because you declared arr to be a pointer to the first element of the array, you lost the information about the array's size. So you cannot use sizeof here to obtain the number of elements pointed to by arr.

The solution is to store this information separately.

If your software design allows, you can define the array as an actual array:

int arr[] = { 1, 2, 3, };

Now you can obtain the number of elements in this array:

size_t n = sizeof arr / sizeof arr[0];

Answer 2

sizeof is NOT a (runtime) function call. Rarely are "()" needed when sizeof used correctly.

char *p = "abc"; // pointer to 4 byte read-only array
int n = sizeof *p; // "sizeof' is compiler "facility". @ compile time *p can be measured

char p[] = "abc"; // mutable 4 byte array, initialised 'a','b','c','\0'
int n = sizeof p; // can be measured at compile time

char *p = NULL; // p could be assigned to point anywhere
p = "abc";
int n = strlen( p ); // runtime function call on a pointer to a null terminated string

int arr[] = { 1, 2, 3, 4, }; // compiler secretly includes code initialising array
int n = sizeof arr/sizeof arr[0]; // compiler "knows" these dimensions, so sizeof "works"

Last example will reduce to 4 x sizeof int / sizeof int then to 4x4/4 then to 4 Effectively, this definition is the same as int n = 4;, but calculated by the accurate compiler

Repeating: sizeof is NOT a runtime function call; it is a compile time "facility" (aka "operator")