What is the syntax for an array type?

Question

Is it type[]? For example, could I have

T<int[]>;

for some template T.

Answer 1

The syntax for declaring arrays is

<type> <variable>[<size>];

When using a template the declaration is, in example

template <class T>
  T var[4];

Answer 2

The type of an "array of type T" is T [dimension], which is what you could pass as template parameters. E.g.:

someTemplate<int [10]> t; // array type as template parameter
int a[5]; // array of 5 ints named 'a'

Arrays need to have a dimension which must be greater than 0. This means that e.g. U u[]; is illegal.

There are cases that might seem like exceptions, the first being parameters:

void f(T[]);

This is a special rule for parameters and f() is actually equivalent to the following:

void f(T*);

Then there is direct inialization of arrays:

int a[] = { 1, 2, 3, 4 };

Here the array size is implicitly given through the number of elements in the initializer, thus the type of a is int[4].

There are also incomplete array types without specificied bounds, but you can't directly create instances of these (see Johannes answer for more):

template<class T> struct X { typedef T type; };
X<int[]>::type a = { 1, 2, 3 };

If you are looking for dynamic arrays, prefer standard containers like std::vector<T> instead.

Answer 3

If possible, you might consider instead using dynamic arrays, and passing in a pointer as the templated type. Such as...

T<int*> myVar;

Answer 4

This started as a comment to Georg's answer, but it ran a bit long...

It seems that you may be missing some key abstraction in your mental model of arrays (at least C-style ones). Local arrays are allocated on the stack with a hard-coded size. If you have an array inside a class or struct, the space for the array is part of the object itself (whether on the stack or heap). Global arrays may even be represented directly in the size of the executable.

This means that any time you want to use an array, you must specify its size to the compiler. The only reason you can leave the brackets empty in a parameter list is because functions treat array parameters as pointers. The function would hardly be useful if it could only operate on one size of array.

Templates are no exception. If you want the size of the templated array to vary, you can add an extra template parameter. You still have to specify the size at compile time for any given instance, though.

Answer 5

There are two syntaxes to denote array types. The first is the type-id syntax and is used everywhere where the language expects a compile time type, which looks like:

T[constant-expression]
T[]

This specifies an array type that, in the first form, has a number of elements given by an integer constant expression (means it has to be known at compile time). In the second form, it specifies an array type with an unknown number of elements. Similar to class types that you declare without a body, such an array type is said to be incomplete, and you cannot create arrays of that type

// not valid: what size would it have?
int a[];

You can, however, specify that type. For example you may typedef it

typedef int unknown_int_array[];

In the same manner, you may specify it as a template type argument, so the answer to your question is yes you can pass such a type specifier to a template. Notice that i talk about specifiers here, because the form you use here is not the type itself.

The second way is using the new-type-id syntax which allows denoting runtime types by having non-constant bounds

T[expression]

This allows passing variables as element count, and also allows passing a zero. In such a case, a zero element array is created. That syntax is only usable with the new operator for supporting dynamic arrays.