转换为指向返回数组的函数的指针-是否允许？

Question

This question is somehow linked with this one .

My last revision shows that the paragraph stating that arrays returning functions can't be called may have some actual usage. Remember this one ($6.5.2.2.1):

The expression that denotes the called function shall have type pointer to function returning void or returning a complete object type other than an array type.

The limitations of functions returning arrays concerns only function 'declarators' and 'definitions'. However if we look at the cast operator, there is no rule disallowing 'function-types' which return arrays to be used as a 'type-name' in it.

Look at '$6.5.4.2':

6.5.4 Cast operators

Syntax

cast-expression:

  unary-expression ( type-name ) cast-expression 

Constraints

Unless the type name specifies a void type, the type name shall specify atomic, qualified, or unqualified scalar type , and the operand shall have scalar type.

Now if we look at '$6.2.5.21':

21 Arithmetic types and pointer types are collectively called scalar types . Array and structure types are collectively called aggregate types.

And then at '$6.2.5.20':

— A function type describes a function with specified return type. A function type is characterized by its return type and the number and types of its parameters. A function type is said to be derived from its return type, and if its return type is T , the function type is sometimes called ''function returning T ''. The construction of a function type from a return type is called ''function type derivation''.

— A pointer type may be derived from a function type or an object type, called the referenced type. A pointer type describes an object whose value provides a reference to an entity of the referenced type. A pointer type derived from the referenced type T is sometimes called ''pointer to T ''. The construction of a pointer type from a referenced type is called ''pointer type derivation''. A pointer type is a complete object type.

As I see there is no constraint which forbids something like this:

void *ptr;

(int (*)()[4])ptr;

Or is it?

Answer 1

I'm less sure of this than I was. See Jens Gustedt's comment and my incomplete analysis at the bottom of this answer.

It's commonly said that C does not permit functions that return arrays, but the only constraints that enforce this restriction are (quoting the N1570 C11 draft ):

6.5.2.2p1 (function calls):

The expression that denotes the called function shall have type pointer to function returning void or returning a complete object type other than an array type.

and 6.7.6.3p1 (function declarators):

A function declarator shall not specify a return type that is a function type or an array type.

(I searched for the word "Constraints" in section 6 of the standard. I don't think I missed anything. If I did, I'm confident someone will point it out.)

The type-name in a cast operator is not part of a function call and is not a declarator, so neither constraint applies.

As a result, I believe that this program:

int main(void) {
    if (0) {
        void *ptr;
        (int (*)()[4])ptr;
    }
}

is strictly conforming and must be accepted by a conforming implementation. (I added the if (0) to avoid any issues regarding the run-time semantics of the conversion; the behavior of converting a void* to a function pointer is undefined by omission.)

This means, I think, that a type-name denoting a function returning an array, or a function returning a function, is permitted as long as it's not used in a function call or function declarator. For example, it could be used in a generic selection, in a sizeof or _Alignof expression, and in several other contexts.

This is, of course, not useful, and it's probably just an oversight on the part of the committee.

I note that gcc (version 5.3.0 with -std=c11 -pedantic ) rejects the type-name with a message:

type name declared as function returning an array

This seems like a reasonable diagnostic, but strictly speaking it's non-conforming since no actual constraint is violated.

Veering off the topic of the question for a moment, gcc also complains:

 warning: ISO C forbids conversion of object pointer to function pointer type [-Wpedantic]

which is not strictly correct. ISO C doesn't forbid such a conversion; it merely does not define its behavior.

UPDATE :

Jens Gustedt's comment suggests that a type-name is a declarator , and that therefore a type-name referring to a function returning an array violates the constraint in 6.7.6.3p1. Let's take a look at that, following the grammar in N1570 Annex A and referring to the section numbers there.

The constraint refers to a "function declarator". Since there's no grammar production called function-declarator , it must be referring to a declarator that refers to a function type. If there's no declarator, then the constraint is not violated.

The type-name int (*)()[4] , if it's valid, refers to a pointer to function returning an array of 4 int s (thanks to cdecl ).

My analysis is incomplete. I'll have to come back to this later.