*
Function pointers. You can use a table of function pointers to implement, e.g., fast indirect-threaded code interpreters (FORTH) or byte-code dispatchers, or to simulate OO-like virtual methods.
Then there are hidden gems in the standard library, such as qsort(),bsearch(), strpbrk(), strcspn() [the latter two being useful for implementing a strtok() replacement].
A misfeature of C is that signed arithmetic overflow is undefined behavior (UB). So whenever you see an expression such as x+y, both being signed ints, it might potentially overflow and cause UB.
*
*
Function pointers. You can use a table of function pointers to implement, e.g., fast indirect-threaded code interpreters (FORTH) or byte-code dispatchers, or to simulate OO-like virtual methods.
Then there are hidden gems in the standard library, such as qsort(),bsearch(), strpbrk(), strcspn() [the latter two being useful for implementing a strtok() replacement].
A misfeature of C is that signed arithmetic overflow is undefined behavior (UB). So whenever you see an expression such as x+y, both being signed ints, it might potentially overflow and cause UB.
*
More of a trick of the GCC compiler, but you can give branch indication hints to the compiler (common in the Linux kernel)
What I like about this is that it also adds some expressiveness to some functions.
More of a trick of the GCC compiler, but you can give branch indication hints to the compiler (common in the Linux kernel)
#define likely(x) __builtin_expect((x),1)
#define unlikely(x) __builtin_expect((x),0)What I like about this is that it also adds some expressiveness to some functions.
void foo(int arg)
{
if (unlikely(arg == 0)) {
do_this();
return;
}
do_that();
...
}
*
|
*
The comma operator isn't widely used. It can certainly be abused,
but it can also be very useful. This use is the most common one:
for (int i=0; i<10; i++, doSomethingElse())
{
/* whatever */
}int j = (printf("Assigning variable j\n"), getValueFromSomewhere());*
|
initializing structure to zero
|
*
Multi-character constants:
EDIT: This technique is not portable, especially if you serialize the int. However, it can be extremely useful to create self-documenting enums. e.g.
int x = 'ABCD';x to 0x41424344 (or 0x44434241, depending on architecture).EDIT: This technique is not portable, especially if you serialize the int. However, it can be extremely useful to create self-documenting enums. e.g.
enum state {
stopped = 'STOP',
running = 'RUN!',
waiting = 'WAIT',
};
*
|
I never used bit fields but they sound cool for ultra-low-level stuff.
sizeof(cat) can be as small as sizeof(char). |
*
|
C has a standard but not all C compilers are fully compliant (I've not seen any fully compliant C99 compiler yet!).
That said, the tricks I prefer are those that are non-obvious and portable across platforms as they rely on the C semantic. They usually are about macros or bit arithmetic. For example: swapping two unsigned integer without using a temporary variable: |
*
|
Interlacing structures like Duff's Device:
|
*
I'm very fond of designated initializers, added in C99 (and supported in gcc for a long time):
#define FOO 16
#define BAR 3
myStructType_t myStuff[] = {
[FOO] = { foo1, foo2, foo3 },
[BAR] = { bar1, bar2, bar3 },
...
*
C99 has some awesome any-order structure initialization.
struct foo{
int x;
int y;
char* name;
};
void main(){
struct foo f = { .y = 23, .name = "awesome", .x = -38 };
}
*
|
anonymous structures and arrays is my favourite one. (cf. http://www.run.montefiore.ulg.ac.be/~martin/resources/kung-f00.html)
|
*
gcc has a number of extensions to the C language that I enjoy, which can be found here. Some of my favorites are function attributes.
One extremely useful example is the format attribute. This can be
used if you define a custom function that takes a printf format string.
If you enable this function attribute, gcc will do checks on your
arguments to ensure that your format string and arguments match up and
will generate warnings or errors as appropriate.
int my_printf (void *my_object, const char *my_format, ...)
__attribute__ ((format (printf, 2, 3)));
*
the (hidden) feature that "shocked" me when I first saw is about
printf. this feature allows you to use variables for formatting format
specifiers themselves. look for the code, you will see better:
#include <stdio.h>
int main() {
int a = 3;
float b = 6.412355;
printf("%.*f\n",a,b);
return 0;
}
*
Constant string concatenation
I was quite surprised not seeing it allready in the answers, as all compilers I know of support it, but many programmers seems to ignore it. Sometimes it's really handy and not only when writing macros.
Use case I have in my current code: I have a
I was quite surprised not seeing it allready in the answers, as all compilers I know of support it, but many programmers seems to ignore it. Sometimes it's really handy and not only when writing macros.
Use case I have in my current code: I have a
#define PATH "/some/path/" in a configuration file
(really it is setted by the makefile). Now I want to build the full
path including filenames to open ressources. It just goes to:fd = open(PATH "/file", flags);char buffer[256];
snprintf(buffer, 256, "%s/file", PATH);
fd = open(buffer, flags);- three times as long
- much less easy to read
- much slower
- less powerfull at it set to an arbitrary buffer size limit (but you would have to use even longer code to avoid that without constant strings contatenation).
- use more stack space
*
Struct assignment is cool. Many people don't seem to realize that
structs are values too, and can be assigned around, there is no need to
use
For example, consider some imaginary 2D graphics library, it might define a type to represent an (integer) screen coordinate:
memcpy(), when a simple assignment does the trick.For example, consider some imaginary 2D graphics library, it might define a type to represent an (integer) screen coordinate:
typedef struct {
int x;
int y;
} Point;Point point_new(int x, int y)
{
Point p;
p.x = x;
p.y = y;
return p;
}Point origin;
origin = point_new(0, 0);
*
C compilers implement one of several standards. However, having a
standard does not mean that all aspects of the language are defined. Duff's device,
for example, is a favorite 'hidden' feature that has become so popular
that modern compilers have special purpose recognition code to ensure
that optimization techniques do not clobber the desired effect of this
often used pattern.
In general hidden features or language tricks are discouraged as you are running on the razor edge of whichever C standard(s) your compiler uses. Many such tricks do not work from one compiler to another, and often these kinds of features will fail from one version of a compiler suite by a given manufacturer to another version.
Various tricks that have broken C code include:
In general hidden features or language tricks are discouraged as you are running on the razor edge of whichever C standard(s) your compiler uses. Many such tricks do not work from one compiler to another, and often these kinds of features will fail from one version of a compiler suite by a given manufacturer to another version.
Various tricks that have broken C code include:
- Relying on how the compiler lays out structs in memory.
- Assumptions on endianness of integers/floats.
- Assumptions on function ABIs.
- Assumptions on the direction that stack frames grow.
- Assumptions about order of execution within statements.
- Assumptions about order of execution of statements in function arguments.
- Assumptions on the bit size or precision of short, int, long, float and double types.
*
|
When using sscanf you can use %n to find out where you should continue to read:
Hi ROFL |
*
Compile-time assumption-checking using enums:
Stupid example, but can be really useful for libraries with compile-time configurable constants.
#define D 1
#define DD 2
enum CompileTimeCheck
{
MAKE_SURE_DD_IS_TWICE_D = 1/(2*(D) == (DD)),
MAKE_SURE_DD_IS_POW2 = 1/((((DD) - 1) & (DD)) == 0)
};
*
|
I discoverd recently 0 bitfields.
char) |
*
C99-style variable argument macros, aka
#define ERR(name, fmt, ...) fprintf(stderr, "ERROR " #name ": " fmt "\n", \
__VAR_ARGS__)ERR(errCantOpen, "File %s cannot be opened", filename);
*
Variable size automatic variables are also useful in some cases.
These were added i nC99 and have been supported in gcc for a long time.
You have to make sure extraPadding is a reasonable value before calling this routine, or you end up blowing the stack. You'd have to sanity check the arguments before calling malloc or any other memory allocation technique, so this isn't really unusual.
void foo(uint32_t extraPadding) {
uint8_t commBuffer[sizeof(myProtocol_t) + extraPadding];You have to make sure extraPadding is a reasonable value before calling this routine, or you end up blowing the stack. You'd have to sanity check the arguments before calling malloc or any other memory allocation technique, so this isn't really unusual.
*
|
In Visual Studio, it is possible for you to highlight your own defined types.
To do that, create a file called "usertype.dat" in the folder "Commom7/IDE". The contents of that file shall be the types you want to highlight. For example: //content of usertype.dat |
*
How about using while(0) inside a switch so you can use continue statements like break :-)
void sw(int s)
{
switch (s) while (0) {
case 0:
printf("zero\n");
continue;
case 1:
printf("one\n");
continue;
default:
printf("something else\n");
continue;
}
}
*
The often forgotten
%n specifier in printf
format string can be quite practical sometimes. %n returns the current
position of the imaginary cursor used when printf formats its output.int pos1, pos2;
char *string_of_unknown_length = "we don't care about the length of this";
printf("Write text of unknown %n(%s)%n text\n", &pos1, string_of_unknown_length, &pos2);
printf("%*s\\%*s/\n", pos1, " ", pos2-pos1-2, " ");
printf("%*s", pos1+1, " ");
for(int i=pos1+1; i<pos2-1; i++)
putc('-', stdout);
putc('\n', stdout);Write text of unknown (we don't care about the length of this) text
\ /
--------------------------------------
*
Use NaN for chained calculations / error return :
//#include <stdint.h>
static uint64_t iNaN = 0xFFF8000000000000;
const double NaN = *(double *)&iNaN; // quiet NaN
An inner function can return NaN as an error flag : it can safely be used in any calculation, and the result will always be NaN.
note : testing for NaN is tricksy, since NaN != NaN... use isnan(x), or roll your own.
x!=x is mathematically correct if x is NaN, but tends to get optimised out by some compilers
//#include <stdint.h>
static uint64_t iNaN = 0xFFF8000000000000;
const double NaN = *(double *)&iNaN; // quiet NaN
An inner function can return NaN as an error flag : it can safely be used in any calculation, and the result will always be NaN.
note : testing for NaN is tricksy, since NaN != NaN... use isnan(x), or roll your own.
x!=x is mathematically correct if x is NaN, but tends to get optimised out by some compilers
*
I like the typeof() operator. It works like sizeof() in that it is
resolved at compile time. Instead of returning the number of bytes, it
returns the type. This is useful when you need to declare a variable to
be the same type as some other variable, whatever type it may be.
typeof(foo) copy_of_foo; //declare bar to be a variable of the same type as foo
copy_of_foo = foo; //now copy_of_foo has a backup of foo, for any type
*
Object oriented C macros:
You need a constructor (init), a destructor (dispose), an equal (equal),
a copier (copy), and some prototype for instantiation (prototype).
With the declaration, you need to declare a constant prototype to copy and derive from. Then you can do
With the declaration, you need to declare a constant prototype to copy and derive from. Then you can do
C_OO_NEW.
I can post more examples if needed. LibPurple is a large object
oriented C code base with a callback system (if you want to see one in
use)#define C_copy(to, from) to->copy(to, from)
#define true 1
#define false 0
#define C_OO_PROTOTYPE(type)\
void type##_init (struct type##_struct *my);\
void type##_dispose (struct type##_struct *my);\
char type##_equal (struct type##_struct *my, struct type##_struct *yours); \
struct type##_struct * type##_copy (struct type##_struct *my, struct type##_struct *from); \
const type type##__prototype = {type##_init, type##_dispose, type##_equal, type##_copy
#define C_OO_OVERHEAD(type)\
void (*init) (struct type##_struct *my);\
void (*dispose) (struct type##_struct *my);\
char (*equal) (struct type##_struct *my, struct type##_struct *yours); \
struct type##_struct *(*copy) (struct type##_struct *my, struct type##_struct *from);
#define C_OO_IN(ret, type, function, ...) ret (* function ) (struct type##_struct *my, __VA_ARGS__);
#define C_OO_OUT(ret, type, function, ...) ret type##_##function (struct type##_struct *my, __VA_ARGS__);
#define C_OO_PNEW(type, instance)\
instance = ( type *) malloc(sizeof( type ));\
memcpy(instance, & type##__prototype, sizeof( type ));
#define C_OO_NEW(type, instance)\
type instance;\
memcpy(&instance, & type ## __prototype, sizeof(type));
#define C_OO_DELETE(instance)\
instance->dispose(instance);\
free(instance);
#define C_OO_INIT(type) void type##_init (struct type##_struct *my){return;}
#define C_OO_DISPOSE(type) void type##_dispose (struct type##_struct *my){return;}
#define C_OO_EQUAL(type) char type##_equal (struct type##_struct *my, struct type##_struct *yours){return 0;}
#define C_OO_COPY(type) struct type##_struct * type##_copy (struct type##_struct *my, struct type##_struct *from){return 0;}
*
Wrap malloc and realloc like this:
#ifdef _DEBUG
#define mmalloc(bytes) malloc(bytes);printf("malloc: %d\t<%s@%d>\n", bytes, __FILE__, __LINE__);
#define mrealloc(pointer, bytes) realloc(pointer, bytes);printf("realloc: %d\t<%s@%d>\n", bytes, __FILE__, __LINE__);
#else //_DEBUG
#define mmalloc(bytes) malloc(bytes)
#define mrealloc(pointer, bytes) realloc(pointer, bytes)#ifdef _DEBUG
#define mmalloc(bytes) malloc(bytes);printf("malloc: %d\t<%s@%d>\n", bytes, __FILE__, __LINE__);
#define mrealloc(pointer, bytes) realloc(pointer, bytes);printf("realloc: %d\t<%s@%d>\n", bytes, __FILE__, __LINE__);
#define BAILIFNOT(Node, Check) if(Node->type != Check) return 0;
#define NULLCHECK(var) if(var == NULL) setError(__FILE__, __LINE__, "Null exception", " var ", FATAL);
#define ASSERT(n) if( ! ( n ) ) { printf("<ASSERT FAILURE@%s:%d>", __FILE__, __LINE__); fflush(0); __asm("int $0x3"); }
#define TRACE(n) printf("trace: %s <%s@%d>\n", n, __FILE__, __LINE__);fflush(0);
#else //_DEBUG
#define mmalloc(bytes) malloc(bytes)
#define mrealloc(pointer, bytes) realloc(pointer, bytes)
#define BAILIFNOT(Node, Check) {}
#define NULLCHECK(var) {}
#define ASSERT(n) {}
#define TRACE(n) {}
#endif //_DEBUGmalloc: 12 <hash.c@298>
trace: nodeCreate <hash.c@302>
malloc: 5 <hash.c@308>
malloc: 16 <hash.c@316>
malloc: 256 <hash.c@320>
trace: dataLoadHead <hash.c@441>
malloc: 270 <hash.c@463>
malloc: 262144 <hash.c@467>
trace: dataLoadRecursive <hash.c@404>
*
Variable-sized structs, seen in common resolver libs among other places.
struct foo
{
int a;
int b;
char b[1]; // using [0] is no longer correct
// must come at end
};
char *str = "abcdef";
int len = strlen(str);
struct foo *bar = malloc(sizeof(foo) + len);
strcpy(bar.b, str); // try and stop me!
*
The size of function pointers is not standard. At least not in the
K&R book. Even though it talks about size of other types of pointers
but (I think)
Also
One error that I have seen is as follows (a simplified example):
Operator precedence in C governs order of association not order of evaluation. For example if you have three functions
sizeof of a function pointer is undefined behavior.Also
sizeof is a compile time operator, I see a lot of people asking if sizeof is a function or an operator in online forums. One error that I have seen is as follows (a simplified example):
int j;
int i;
j = sizeof(i++)i would not be executed as sizeof is evaluated at compile time. The programmer intended to hack both operations, increment on i and calculation of sizeof in one statement.Operator precedence in C governs order of association not order of evaluation. For example if you have three functions
f,g,h each returning an int, and their is an expression like:f() + g() * h()g and h would be multiplied before adding result of f.
This can lead to error if the functions share state and computation
depends on order of evaluation of these functions. This can lead to
portability issues.
*
Here's three nice ones in gcc:
__FILE__
__FUNCTION__
__LINE__
*
Say you have a struct with members of the same type:
struct Point {
float x;
float y;
float z;
};Point a;
int sum = 0, i = 0;
for( ; i < 3; i++)
sum += ((float*)a)[i];
*
register variables
I used to declare some variables with theregister
keyword to help speed things up. This would give a hint to the C
compiler to use a CPU register as local storage. This is most likely no
longer necessary as modern day C compilers do this automatically.
*
When comparing a variable to a literal, it is better to put the literal to the left of the
== operator, to make the sure the compiler gives an error when you mistakenly use the assignment operator instead.if (0 == count) {
...
}if (count = 0) by mistake).
*
Steve Webb has pointed out the
I was working on a device where there was no port available to pass logging information from device to the PC being used for debugging. One could use breakpoints to halt and know the state of the program using debugger but there was no information on system trace.
Since all calls to debug logs were effectively a single global macro, we changed that macro to dump file name and line number on to a global array. This array contained series of file names and line numbers showing which debug calls were invoked, giving a fair idea of execution trace (not the actual log message though). One could pause the execution by debugger, dump these bytes onto a local file and then map this information to the code base using scripts. This was made possible because we had strict coding guidelines, so we could make had to make changes to the logging mechanism in one file.
__LINE__ and __FILE__ macros. It reminds me of how in my previous job I had hacked them to have in-memory logging.I was working on a device where there was no port available to pass logging information from device to the PC being used for debugging. One could use breakpoints to halt and know the state of the program using debugger but there was no information on system trace.
Since all calls to debug logs were effectively a single global macro, we changed that macro to dump file name and line number on to a global array. This array contained series of file names and line numbers showing which debug calls were invoked, giving a fair idea of execution trace (not the actual log message though). One could pause the execution by debugger, dump these bytes onto a local file and then map this information to the code base using scripts. This was made possible because we had strict coding guidelines, so we could make had to make changes to the logging mechanism in one file.
*
|
intptr_t for declaring variables of type pointer. C99 specific and declared in stdint.h
|
*
Not really a hidden feature, but it looked to me like voodoo, the first time I saw something like this:
EDIT: I know there are other (better) ways to prevent those warnings. It just looked strange to me, the first time I saw this.
void callback(const char *msg, void *data)
{
// do something with msg, e.g.
printf("%s\n", msg);
return;
data = NULL;
}EDIT: I know there are other (better) ways to prevent those warnings. It just looked strange to me, the first time I saw this.
*
I only discovered this after 15+ years of C programming:
Skizz
struct SomeStruct
{
unsigned a : 5;
unsigned b : 1;
unsigned c : 7;
};xxxc cccc ccba aaaaSkizz
*
Conversion of types by using unusual typecasts. Though not hidden feature, its quite tricky.
Example:
If you needed to know how compiler stores float, just try this:
This works other side of expression as well:
Example:
If you needed to know how compiler stores float, just try this:
uint32_t Int;
float flt = 10.5; // say
Int = *(uint32_t *)&flt;
printf ("Float 10.5 is stored internally as %8X\n", Int);float flt = 10.5; // say
printf ("Float 10.5 is stored internally as %8X\n", *(uint32_t *)&flt);This works other side of expression as well:
*(float *)&Int = flt;typedef union
{
uint32_t Int;
float flt;
} FloatInt_type;
*
I got shown this in a bit of code once, and asked what it did:
hexDigit = "0123456789abcdef"[someNybble];
unsigned char bar[100];
unsigned char *foo = bar;
unsigned char blah = 42[foo];
*
For clearing the input buffer you can't use
fflush(stdin). The correct way is as follows: scanf("%*[^\n]%*c")
This will discard everything from the input buffer.
*
Lambda's (e.g. anonymous functions) in GCC:
#define lambda(return_type, function_body) \
({ return_type fn function_body fn })lambda (int, (int x, int y) { return x > y; })(1, 2)({ int fn (int x, int y) { return x > y } fn; })(1, 2)
*
|
I liked the variable sized structures you could make:
|
These all are copied from http://stackoverflow.com
![Warning /!\](https://help.ubuntu.com/moin_static193/light/img/icon_eek.png "Warning /!\"){kind=icon}
For some reason, a Windows 8.1 client (Qualcomm Atheros AR956x Wireless
Network Adapter) would not connect when require_ht=1. Event Viewer
noted "A response was not received from the router or access point."
However, this same client booted into Ubuntu worked fine, as well as Mac
OS X Yosemite, iPhone, and a android smartphone. 