Defect Report #053

Submission Date: 25 Mar 93
Submittor: Project Editor (P.J. Plauger)
Source: Larry Jones
Question 1
There's been a discussion on comp.std.c recently about accessing a pointer to a function with parameter type information through a pointer to a pointer to a function without parameter type information. For example:
int f(int); int (*fp1)(int); int (*fp2)(); int (**fpp)(); fp1 = f; fp2 = fp1; /* pointers to compatible types, assignment ok */ (*fp2)(3); /* function types are compatible, call is ok */ fpp = &fp1; /* pointer to compatible types, assignment ok */ (**fpp)(3); /* valid? */
The final call itself should be valid since the resulting function type is compatible with the type of the function being called, but there's still a problem: Subclause 6.3 Expressions, page 38, says:

An object shall have its stored value accessed only by an lvalue expression that has one of the following types:36
- the declared type of the object,
- a qualified version of the declared type of the object,
- a type that is the signed or unsigned type corresponding to the declared type of the object,
- a type that is the signed or unsigned type corresponding to a qualified version of the declared type of the object,
- an aggregate or union type that includes one of the aforementioned types among its members (including, recursively, a member of a subaggregate or contained union), or
- a character type.
[Footnote 36: The intent of this list is to specify those circumstances in which an object may or may not be aliased.]

This would appear to render the final call undefined since the stored value of fp1 is being accessed by an lvalue that does not match its declared type: (int (*)()) vs. (int (*)(int)).
I think that this example should be valid and that the above limitation is too strict. I think what we meant to say was ``a type compatible with the declared type of the object,'' which would allow ``reasonable'' type mismatches without allowing aliasing between wildly different types.
Correction
In subclause 6.3, page 38, lines 18-21, change:
An object shall have its stored value accessed only by an lvalue expression that has one of the following types:36
- the declared type of the object,
- a qualified version of the declared type of the object,
to:
An object shall have its stored value accessed only by an lvalue expression that has one of the following types:36
- a type compatible with the declared type of the object,
- a qualified version of a type compatible with the declared type of the object,
Previous Defect Report < - > Next Defect Report