Why are arrays of undefined size only allowed in main()?

Question

The main method argument uses an undefined array argv[]

int main(int argc, char *argv[])
{
 .... Do stuff....
}

Why is it undefined arrays are only allowed in the main() method?

Answer 1

In fact this declaration

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

is equivalent to

int main(int argc, char **argv)

It is the host environment that supplies an array of strings and passes the pointer to the first string in the array as an argument for the parameter argv.

From the C Standard (5.1.2.2.1 Program startup)

— If the value of argc is greater than zero, the array members argv[0] through argv[argc-1] inclusive shall contain pointers to strings, which are given implementation-defined values by the host environment prior to program startup. The intent is to supply to the program information determined prior to program startup from elsewhere in the hosted environment. If the host environment is not capable of supplying strings with letters in both uppercase and lowercase, the implementation shall ensure that the strings are received in lowercase

As for the comment

The argv array has no size, how is this possible?

then a function parameter declared as an array of type T is adjusted to pointer to T.

So for example these function declarations

void f( int a[100] );
void f( int a[10] );
void f( int a[] );

declare the same one function and the all declarations are adjusted to the declaration

void f( int *a );

The same way when an argument of an array type is passed to a function then the array is implicitly converted to pointer to its first element.

So for example the function above can be called like

int a[100];
f( a );

or

int a[10];
f( a );

or

int *a;
f( a );

Answer 2

Nothing is special about main here. An array declaration such as char *argv[] or int example[] has incomplete type, which is valid in certain contexts but not others. However, in the declaration of arguments to a function, the final type cannot be an array type; the array notation acts as a stand-in for a pointer to the first member of an array of that type. The actual type of argv in main is char **.

Answer 3

Why is it undefined arrays are only allowed in the main() method?

By "undefined arrays" you appear to mean arrays with unspecified size. There are several different cases to consider.

1. Function parameters declared with array syntax in fact do not have array type after all, whether a bound is specified or not. Rather, such a parameter has a pointer type. It is not necessary to specify a bound (for the first dimension), and if one is specified then it is insignificant. This matches up with the automatic conversion from array to pointer ("decay") that would happen in the caller if the corresponding argument were an array, but in the called function the parameter is a pointer, a whole pointer, and nothing but a pointer.

   This applies to any function, not just main().

2. Any variable can be declared at file or block scope as an array without an explicit bound but with an initializer; in this case, the array bound is established implicitly as the minimum necessary to accommodate all elements initialized by the initializer.

   Example:

   int some_primes[] = { 2, 3, 5, 7, 11 };  // dimension 5
   

3. A file-scope (outside any function) variable or one that otherwise has linkage can be declared as an array without explicit bounds and without an intializer to establish the bound implicitly. The type of such a variable is "incomplete" until and unless another, compatible declaration of the same variable completes it by providing the bound, but many array operations can be performed on it at points in the source where it remains incomplete.

4. Only local variables of array type and without initializers must be declared with an explicit bound. ("Local variables" are those declared at block scope and with no linkage.) These are a fairly common case, though, so I suppose the need to declare a size for them was part of the inspiration for the question.

Answer 4

I'm a little confused about this question. argc is the number of commandline arguments passed into the executable. argv is an array of those arguments. Neither are undefined.

Both argc and argv are simply parameter names, and you can change them to whatever you'd like. They are simply called argc and argv by convention.