How to write perfect C code

　　Several days ago, I was involved in an argument about choice of C or C++. What I ignored was "language is less important than coder".  a bad C# writer only write shit-like C# but a professional C programmer could design perfect C, Notwithstanding C# is much more powerful than C,
　　So how to write perfect C code? We just illustrate that by cJson, a famous pure-C tiny json formatter.

1. Power C pointer, make point operation awesome

The string-comparison of cjson like melody,  this ability might need you a lot experience:

    static int cJSON_strcasecmp(const char *s1,const char *s2)
    {
    if (!s1) return (s1==s2)?0:1;
    if (!s2) return 1;
    for(; tolower(*s1) == tolower(*s2); ++s1, ++s2)
        if(*s1 == 0)    return 0;
    return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2);
         }    

　　So how you write a same strcasecmp function? Try more C code.

2. Reasonable code indent

　 　Someone might tell you write code with same indent-style, "the wrap position, where to put a bracket..." However, most people are accustomed to reading left to right without pause. So a better code reader understand is more important than that so-call rule and style just like follows:

static const char *parse_value(cJSON *item,const char *value)
{
    if (!value)                        return 0;    /* Fail on null. */
    if (!strncmp(value,"null",4))    { item->type=cJSON_NULL;  return value+4; }
    if (!strncmp(value,"false",5))    { item->type=cJSON_False; return value+5; }
    if (!strncmp(value,"true",4))    { item->type=cJSON_True; item->valueint=1;    return value+4; }
    if (*value==‘\"‘)                { return parse_string(item,value); }
    if (*value==‘-‘ || (*value>=‘0‘ && *value<=‘9‘))    { return parse_number(item,value); }
    if (*value==‘[‘)                { return parse_array(item,value); }
    if (*value==‘{‘)                { return parse_object(item,value); }

    ep=value;return 0;    /* failure. */
}

　　Does Code below make it more easy to understand than standard indent style? As you can easily compare difference between each case of switch structure.

3. Chain-style function design

　　Chain-style function means you can invoke them with merge them into a chain, as A(B(C)).
　
　Linq (a chain-style code sugar ) greatly improve beauty of C#, could
make your code designed like: Select.Where.Orderby...  As standard C do
not offer extend-function. But you could still make the chain like
Order(Select(Where(Data))) .  Some little bit harder ,but much more
easier than other code style, just like code in cJson:

   value=skip(parse_value(child,skip(value+1)));    /* skip any spacing, get the value. *

The difficulty is the rope which connect modules into a chain. In
Linq, it‘s a interface called IEnumerable, a compiler-level state
machine. In cJson code behind, it‘s the position of processing pointer.

4. Hook me!

　
　Standard C do not have delegate, function override. But there are some
other powerful mechanism called hook, achieved by function pointer. You
could change a function pointer behaviour by assign a different function
with same parameters and return value. Example as follow:

    void cJSON_InitHooks(cJSON_Hooks* hooks)
{
    if (!hooks) { /* Reset hooks */
        cJSON_malloc = malloc;
        cJSON_free = free;
        return;
    }

    cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;
    cJSON_free     = (hooks->free_fn)?hooks->free_fn:free;
}

Awesome right? You can change memory allocation and free behaviour by using hook!

5. Offer default value of function parameters

　 　In order to make your user more convenient when using your perfect library, please offer them some override functions! C might not allow you define two same name function by different parameter table. But you could still do this:

/* Render a cJSON item/entity/structure to text. */
char *cJSON_Print(cJSON *item)                {return print_value(item,0,1);}
char *cJSON_PrintUnformatted(cJSON *item)    {return print_value(item,0,0);}

6. Improve algorithm!

　 　C style code is different than C# or Java, the languages with powerful libraries. Sometimes because of compatibility or performance, using STL or some 3rd libraries is not a good choice. So you need to achieved them by yourself. This does not means you should write "Stack.c" or  "Stack.h"  to define a full-functional stack. It‘s too heavy and unnecessary,right? But the core algorithm of stack will greatly affect your code style by merge an easy array-achieved stack by several simple code.
    The example in cJson is tree structure, as json is a
nature tree. The author merge tree algorithm into the code by recursive
and pointer without any trace. Perfect!
    
    Try more C code, try more perfect improvement, guy!