Not-So-Magic - typeof(…) in C

typeof is a extension featured in many implementations of the C standard to get the type of an expression. It works similarly to sizeof, which runs the expression in an “unevaluated context” to understand the final type, and thusly produce a size. typeof stops before producing a byte size and instead just yields a type name, usable in all the places a type currently is in the C grammar.

There are many uses for typeof that have come up over the intervening decades since its first introduction in a few compilers, most notably GCC. It can, for example, help produce a type-safe generic printing function that even has room for user extension (see: https://slbkbs.org/tmp/fmt/fmt.h). It can also help write code that can use the expansion of a macro expression as the return type for a function, or used within a macro itself to correctly cast to the desired result of a specific computation’s type (for width and precision purposes). The use cases are vast and endless, and many people have been locking themselves into implementation-specific vendorship that have locked them out of other compilers (for example, Microsoft’s Visual C Compiler).

2 Implementation & Existing Practice

Every implementation in existence since C89 has an implementation of typeof. Some compilers (GCC, Clang, EDG, tcc, and many, many more) expose this with the implementation extension typeof. But, the Standard already requires typeof to exist. Notably, with underlined emphasis added,

Any implementation that can process sizeof("foo") is already doing sizeof(typeof("foo")) internally. This feature is the most “existing practice”-iest feature to be proposed to the C Standard, possibly in the entire history of the C standard.

3 Wording

⁵ EXAMPLE 1 Type of an expression

_Typeof(1) main () {
    return 0;
}
// equivalent to:
// int main() {
//   ...
// }

⁶ EXAMPLE 2 Equivalence of sizeof and typeof.

int main (int argc, char* argv[]) {
    // this program has no constraint violations
    _Static_assert(sizeof(_Typeof('p')) == sizeof(char));
    _Static_assert(sizeof(_Typeof('p')) == sizeof('p'));
    _Static_assert(sizeof(_Typeof("meow")) == sizeof(char[5]));
    _Static_assert(sizeof(_Typeof("meow")) == sizeof("meow"));
    _Static_assert(sizeof(_Typeof(argc)) == sizeof(int));
    _Static_assert(sizeof(_Typeof(argc)) == sizeof(argc));
    _Static_assert(sizeof(_Typeof(argv)) == sizeof(char**));
    _Static_assert(sizeof(_Typeof(argv)) == sizeof(argv));
    return 0;
}

⁷ EXAMPLE 3 Nested _Typeof(...).

int main (int argc, char*[]) {
    float val = 6.0f;
    // equivalent to a cast and return
    return (_Typeof(_Typeof(_Typeof(argc))))val;
    // return (int)val;
}

⁸ EXAMPLE 4 Variable Length Arrays and _Typeof.

#include <stddef.h>

size_t vla_size (int n) {
    typedef char vla_type[n + 3];
    vla_type b; // variable length array
    return sizeof(
        _Typeof(b)
    ); // execution-time sizeof, translation-time _Typeof
}

int main () {
    return (int)vla_size(10); // vla_size returns 13
}

Not-So-Magic - typeof(…) in C

1 Introduction & Motivation

2 Implementation & Existing Practice

3 Wording

§6.7.2.5 The Typeof specifier

Syntax

Constraints

Semantics