41–50 of 147 posts
> a[b] is literally equivalent to *(a + b). You can thus write some absolute madness such as 41[yourarray + 1]. Wow. This has to be the best C obscurity that I've ever seen.
Notice how the list is sorted from actually obscure to less interesting.
I even took the time to write a pseudo disclaimer above this one :D
>a[b] is literally equivalent to *(a + b).
Is this obscure? I thought that's pretty much the first thing you learn about arrays in C? It's pointers, all the way down.
Although calling the preprocessor "functional" is being too pleasant. The C preprocessor was always a text substitution system, so macro as parameter is not that "obscure". Of course, I may have missed something subtle in the example. It's also not clear how to use that preprocessor example.
Here's what the example yields once preprocessed:
struct operator{
int priority;
const char *value;
};
struct operator operator_negate = {
.priority = 20,
.value = "!",
};
struct operator operator_different = {
.priority = 70,
.value = "!=",
};
struct operator operator_mod = {
.priority = 30,
.value = "%",
};All craziness but then: >a[b] is literally equivalent to *(a + b). Is this obscure? I thought that's pretty much the first thing you learn about arrays in C? It's pointers, all the way down.
All craziness but then: >a[b] is literally equivalent to *(a + b). Is this obscure? I thought that's pretty much the first thing you learn about arrays in C? It's pointers, all the way down.
Here is an obscure c feature: int main() { int a = 8; { int a = 4; /* a is only scoped to this block */ } printf("%d", a); /* prints 8 */ } It is also why C++ is not a strict superset of C
If you want to tell if your compiler is C or C++, run this program: #include int main() { printf("%d\n", sizeof('a')); } It's the second thing C++ mentions in its list of incompatibility with C (the first is "new keywords"). A more obscure difference is this program: int i; int i; int main() { return i; } It's legal C but not legal C++.
Earlier quoted context omitted.
int main() { return 4//**/2 ; }
Line comments have been part of the C language for a long, long time (added in C99); so much so that, especially when discussing the subject on the internet, more and more often they predate some of the younger participants.
A nice but I guess more of a linker feature is if you declare a function as __weak__, you can check it at runtime for == NULL to determine if the application was built with the function defined.
The preprocessor trick of passing function macros as parameters is not that obscure. I have seen it used and I've used it myself. It is very useful when you have a list of static "things" that you need to operate on. Say I have a static list of names and I would like to declare some struct type for each name. I also would like to create variables of these structs at some point, and I would always do so for the entire…
I would call that the X macro pattern, but the wiki article doesn't agree that it should pass the `fn` as the argument. Not sure if that's important.. https://en.wikipedia.org/wiki/X_Macro