Why is this implicit conversion (between different pointer types) valid?

Question

I found myself in the following situation:

#include <stdio.h>

typedef struct T1 { int id; } T1;  
typedef struct T2 { int id; } T2;

void f(T1 *ptr) { printf("f called\n"); }

int main(void) 
{
    T2 obj; 
    T2 *ptr = &obj; 
    f(ptr); // shouldn't this be a compilation error ? 
    return 0;
}

of course, this is invalid C++, but in C, the program prints "f called". How is this valid ?

EDIT

(Just in case it's unclear) The program would still compile and run if T2 was "structurally" different, eg

typedef struct T2 { double cc[23]; } T2;

Answer 1

This is not valid, if you want to force standard compliant code it is important to compile with the correct flags for example both gcc and clang the following flags:

-std=c99 -pedantic-errors

will generate an error for diagnostics required by the C99 standard and similarly you could use -std=c11 for C11. This will generate the following error from gcc (see it live):

error: passing argument 1 of 'f' from incompatible pointer type

Compilers have extensions and allow features like implicit int due to legacy code and it is important to know the difference. See gcc document: Language Standards Supported by GCC for more details.

The quick way to see that this is actually invalid is to go to the Rationale for International Standard—Programming Languages—C which tell us in section 6.3.2.3 Pointers which deals with conversions that:

It is invalid to convert a pointer to an object of any type to a pointer to an object of a different type without an explicit cast.

The slightly longer path requires we go to the draft C99 standard section 6.5.2.2 Function calls which says (emphasis mine going forward):

If the expression that denotes the called function has a type that does include a prototype, the arguments are implicitly converted, as if by assignment,

and if we then go to section 6.5.16 Assignment operators which says:

One of the following shall hold

and for pointers we have:

• both operands are pointers to qualified or unqualified versions of compatible types, and the type pointed to by the left has all the qualifiers of the type pointed to by the right;
• one operand is a pointer to an object or incomplete type and the other is a pointer to a qualified or unqualified version of void, and the type pointed to by the left has all the qualifiers of the type pointed to by the right;
• the left operand is a pointer and the right is a null pointer constant;

we see that none of these cases hold and therefore the conversion is invalid.

Answer 2

When compiling, I get the following warning:

temp.c: In function ‘main’:

temp.c:20:5: warning: passing argument 1 of ‘f’ from incompatible pointer type [enabled by default]

temp.c:13:6: note: expected ‘struct T1 *’ but argument is of type ‘struct T2 *’

It's "valid" because they're both pointers, and hence can be converted, it's just not a good idea.

Answer 3

As per the C99 standard, section 6.5.2.2 [Function calls], paragraph 7, this is valid allowed in C, but not valid.

For example, in your code, if T1 and T2 are different structures having different elements, and the address of T2 is passed to f() and accepted as T1*, then this is absolutely wrong and the result is fatal. Just in case it got compiled [it should have produced warnings about the passing argument <number> of <a function> from incompatible pointer type], doesn't obviously mean it is right.

In your code, as you are not accessing the structure variables inside f(), due to the compilar optimization, the warnings might have been disappeared.

It reads

If the expression that denotes the called function has a type that does include a prototype, the arguments are implicitly converted, as if by assignment, to the types of the corresponding parameters, taking the type of each parameter to be the unqualified version of its declared type. The ellipsis notation in a function prototype declarator causes argument type conversion to stop after the last declared parameter. The default argument promotions are performed on trailing arguments.

Answer 4

As others have mentioned, in C this code requires a diagnostic (and apparently you got one, in the form of a gcc warning).

You can "fix" the code with a cast:

f( (T1 *)ptr );

In your sample program this is fine. However, in a more complicated program there would be a problem. Since T1 and T2 are not compatible types , then having f write through the pointer and then reading through ptr (or vice versa) would be a strict-aliasing violation.

You can work around the issue though, taking advantage of the fact that unions can be used for aliasing in C, and that there is special provision for union members being structs with a common initial sequence:

union
{
    T1 t1;
    T2 t2;
} obj;

f( &obj.t1 );                 // might write to ptr->id
printf("%d\n", obj.t2.id);    // OK, writes int that f wrote

Since the union example has to work, any sane compiler would just use a common layout for T1 and T2 and not do any strict-aliasing optimilzations here, so the code with the cast could be reasonably expected to "just work", as you see in your example run.