3 ms·
TIL: You can use typeof(expr) as a type in variable declarations. C has type inference! A plain old C macro like #define AUTO(var, expr) typeof(expr) var =
by yorwba 10y ago
TIL: You can use typeof(expr) as a type in variable declarations. C has type inference! A plain old C macro like
#define AUTO(var, expr) typeof(expr) var = expr
might be handy sometimes.
- smitherfield 10y ago`typeof()` is a common compiler extension, not standard C. (C++11 irritatingly standardized it as `decltype()`).
- lifthrasiir 10y ago> [...] irritatingly [...] Or correctly; it is so common and so different (and incomplete) across implementations, so a new name with the exact semantics has been invented [1]. [1] http://www.stroustrup.com/C++11FAQ.html#decltype http://www.stroustrup.com/C++11FAQ.html#decltype
- smitherfield 10y agoI understand the reasoning, I just think it's wrong. The point of a standard is to, well, standardize. And each new version of the standard breaks plenty of existing (and strictly standards-compliant!) code, often intentionally. Now a type deduction operator is never going to come to standard C because any proposal will get buried under endless bikeshedding about whether to call it `typeof()` or `decltype()`.
- mikeash 10y agoI'm not sure about C++, but C tries pretty hard not to break code that complies with a previous standard unless it's absolutely necessary, and they put some effort into avoiding breaking common extensions too. This is why, for example, the language-level boolean type introduced in C99 is `_Bool`, and then you can include a standard header that will typedef it to `bool`. Identifiers that begin with an underscore and an uppercase letter are reserved for the implementation, so no compliant code will be using _Bool anywhere for itself. And since old code won't include `stdbool.h`, there's no conflict if it happens to define its own `bool`. Given this, it seems like the best approach would be to call it `_Typeof` or similar, with a standard header that does `#define typeof(x) _Typeof(x)` to make it nicer to use.
- exDM69 10y ago> C has type inference! This is only one-way type deduction (similar to C++ `auto` keyword) which isn't really proper two-way type inference. It just copies the type of the right hand side to the left hand side. E.g. given the following code: x = less_than(a, b) ? (a+1) : b; A proper type inference algorithm can deduce the types of less_than ((int, int) -> bool) and a (int because a+1) and b (int because it must match the other side of the conditional) and x (int). C++ auto could only defer the type of x given the types of less_than, a and b. And by "proper type inference" I mean the text book Hindley-Milner unification algorithm from the 1970's, not a more modern variant with traits or type classes and whatnot.
- FrozenVoid 10y agoGCC and Clang(since 2016) have "__auto_type" extension for C which does a similar thing. https://gcc.gnu.org/onlinedocs/gcc/Typeof.html https://gcc.gnu.org/onlinedocs/gcc/Typeof.html
- mikeash 10y agoVery nice! I like using `auto` when writing C++ and miss it when writing Objective-C. I could use Objective-C++, of course, but that has its own problems. I'll have to keep this in mind.