C中数组的const和typedef

Question

In C, it's possible to typedef an array, using this construction :

typedef int table_t[N];

Here, table_t is now defined as an array of N int . Any variable declared such as table_t t; will now behave as a normal array of int .

The point of such construction is to be used as an argument type in a function, such as :

int doSomething(table_t t);

A relatively equivalent function prototype could have been :

int doSomething(int* t);

The merit of the first construction is that it enforces N as the size of the table. In many circumstances, it's safer to enforce this property, rather than relying on the programmer to properly figure out this condition.

Now it's all good, except that, in order to guarantee that the content of table will not be modified, it's necessary to use the const qualifier.

The following statement is relatively simple to understand :

int doSomething(const int* t);

Now, doSomething guarantee that it will not modify the content of the table passed as a pointer. Now, what about this almost equivalent construction ? :

int doSomething(const table_t t);

What is const here ? the content of the table, or the pointer to the table ? If it's the pointer which is const , is there another way (C90 compatible) to retain the ability to define the size of the table and to tell that its content will be const ?

Note that it's also necessary sometimes to modify the content of the table, so the const property cannot be embedded into the typedef definition.

[ Edit ] Thanks for the excellent answers received so far. To summarize :

• The initial assumption of typedef enforcing size N was completely wrong. It basically behaves the same as a normal pointer.
• The const property will also behave the same as if it was a pointer (in stark contrast with a typedef to a pointer type, as underlined by @random below)
• To enforce a size (which was not the initial question, but end up being quite important now...), see Jonathan's answer

Answer 1

First, you are mistaken, the function prototypes

int doSomething(table_t t);
int doSomething(int* t);

are exactly equivalent. For function parameters, the first array dimension is always rewritten as a pointer. So there is no guarantee for the size of the array that is received.

const -qualification on arrays always applies to the base type of the array, so the two declarations

const table_t a;
int const a[N];

are equivalent, and for functions parameters we have

int doSomething(const table_t t);
int doSomething(int const* t);

Answer 2

The content of the table will be constant. Easily checked with this code.

#include<stdio.h>

typedef int table_t[3];
void doSomething(const table_t t)
{
    t++;    //No error, it's a non-const pointer.
    t[1]=3; //Error, it's a pointer to const.

}

int main()
{
    table_t t={1,2,3};
    printf("%d %d %d %ld",t[0],t[1],t[2],sizeof(t));
    t[1]=5;
    doSomething(t);
    return 0;
}

Answer 3

The merit of the first construction is that it enforces N as the size of the table.

I'm not sure what you mean here. In what contexts would it "enforce" it? If you declare a function as

int doSomething(table_t t);

array size will not be enforced. I order to enforce the size, you'd have to go a different route

int doSomething(table_t *t); // equivalent to 'int (*t)[N]'

What is const here ?

As for const ... When const is applied to array type it "drops down" all the way to array elements. This means that const table_t is an array of constant int s, ie it is equivalent to const int [N] type. The end result of this is that the array becomes non-modifiable. In function parameter declaration context const table_t will be converted into const int * .

However, note one peculiar detail that is not immediately obvious in this case: the array type itself remains non-const-qualified. It is the individual elements that become const . In fact, it is impossible to const-qualify the array type itself in C. Any attempts to do so will make const-qualification to "sift down" to individual elements.

This peculiarity leads to rather unpleasant consequences in array const-correctness. For example, this code will not compile in C

table_t t;
const table_t *pt = &t;

even though it looks quite innocently from the const-correctness point of view and will compile for any non-array object type. C++ language updated its const-correctness rules to resolve this issue, while C continues to stick to its old ways.

Answer 4

Array types and pointer types are not 100% equivalent, even in this context where you do ultimately get a pointer type for the function parameter. Your mistake is in assuming that const would have acted the same way if it were a pointer type.

To expand on ARBY's example:

typedef int table_t[3];
typedef int *pointer_t;

void doSomething(const table_t t)
{
    t++;    //No error, it's a non-const pointer.
    t[1]=3; //Error, it's a pointer to const.
}

void doSomethingElse(const pointer_t t)
{
    t++;    //Error, it's a const pointer.
    t[1]=3; //No error, it's pointer to plain int
}

It does act similarly to const int * , but const pointer_t is instead equivalent to int * const .

(Also, disclaimer, user-defined names ending with _t are not allowed by POSIX, they're reserved for future expansion)

Answer 5

The standard 6.7.6.3 says:

A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to type''

Meaning that when you declare a function parameter as a const int array type, it decays into a pointer to const int (first element in array). Equivalent to const int* in this case.

Also note that because of the above mentioned rule, the array size specified adds no additional type safety! This is one big flaw in the C language, but that's how it is.

Still, it is good practice to declare the array with fixed width like you have, because static analysers or clever compilers may produce a diagnostic about different types.