C语言

1
2
3
4
5
6
7

#include <stdio.h>

int main(void)
{
    puts("Hello, World");
    return 0;
}

1
2
3
4

gcc hello.c -o hello

// 我们还可以使用警告选项-Wall -Wextra -Werror，这有助于识别可能导致程序失败或产生意外结果的问题
gcc -Wall -Wextra -Werror -o hello hello.c 

1
2
3
4
5
6

#include <stdio.h>

main()
{
    printf("hello, world\n");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <ctype.h>
#include <stdio.h>

typedef struct 
{
    size_t space;
    size_t alnum;
    size_t punct;
} chartypes;

chartypes classify(FILE *f) 
{
    chartypes types = {
        0, 0, 0
    };
    int ch;

    while ((ch = fgetc(f)) != EOF) {
        types.space += !!isspace(ch);
        types.alnum += !!isalnum(ch);
        types.punct += !!ispunct(ch);
    }

    return types;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

int c = 'A';

isalpha(c);  /* Checks if c is alphabetic (A-Z, a-z), returns non-zero here. */
isalnum(c);  /* Checks if c is alphanumeric (A-Z, a-z, 0-9), returns non-zero here. */
iscntrl(c);  /* Checks is c is a control character (0x00-0x1F, 0x7F), returns zero here. */
isdigit(c);  /* Checks if c is a digit (0-9), returns zero here. */
isgraph(c);  /* Checks if c has a graphical representation (any printing character except space), returns non-zero here. */
islower(c);  /* Checks if c is a lower-case letter (a-z), returns zero here. */
isprint(c);  /* Checks if c is any printable character (including space), returns non-zero here. */
ispunct(c);  /* Checks if c is a punctuation character, returns zero here. */
isspace(c);  /* Checks if c is a white-space character, returns zero here. */
isupper(c);  /* Checks if c is an upper-case letter (A-Z), returns non-zero here. */
isxdigit(c); /* Checks if c is a hexadecimal digit (A-F, a-f, 0-9), returns non-zero here.*/

// C99
isblank(c); /* Checks if c is a blank character (space or tab), returns non-zero here. */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

int main(void)
{
    char a[100];
    int* b = ( int* )&a;
    *b = 1;

    static char c[100];
    b = ( int* )&c;
    *b = 2;

    _Thread_local char d[100];
    b = ( int* )&d;
    *b = 3;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

typedef union bufType bufType;
union bufType 
{
    char c[sizeof(int[25])];
    int i[25];
};

int main( void )
{
    bufType a = {
        .c = {
            0
        }
    }; // reserve a buffer and initialize
    int* b = a.i; // no cast necessary
    *b = 1;

    static bufType a = {
        .c = {
            0
        }
    };
    int* b = a.i;
    *b = 2;

    _Thread_local bufType a = {
        .c = {
            0
        }
    };
    int* b = a.i;
    *b = 3;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// 有效类型是 uint32_t
uint32_t a = 0.0;

// *pa的有效类型是 uint32_t
uint32_t* pa = &a;

// 目前 *q 并不是一个有效类型
void* q = malloc(sizeof uint32_t);

// 这里的 q 仍然不是一个有效类型，因为还没有数据写入
uint32_t* qb = q;

// *qb 目前是一个有效类型 uint32_t，因为一个 uint32_t 值被写入了
*qb = 37;

// r 指向的对象尽管已经初始化了，但还不是有效类型
void* r = calloc(1, sizeof uint32_t);

// 不是有效类型
uint32_t* rc = r;

// *rc 已经是一个有效类型 uint32_t 因为一个值从它那读取了
// 因为使用 calloc 初始化了，所以读操作是合理的
// 此时尽管我们没有写它的值，但是 *rc 已经是一个有效类型了
uint32_t c = *rc;

void* s = malloc(sizeof uint32_t);
// 因为有 uint32_t 类型复制到指定对象里，所以 *s 已经是有效类型了
memcpy(s, r, sizeof uint32_t);

1
2
3
4
5
6

void fun(uint32_t* u, float* f) 
{
    float a = *f, *u = 22;
    float b = *f;
    print("%g should equal %g\n", a, b);
}

1
2
3
4
5
6

void fun(uint32_t* u, float* f) 
{
    float a = *f, *u = 22;

    print("%g should equal %g\n", a, a);
}

1
2
3
4
5
6

float fval = 4;
uint32_t uval = 77;
fun(&uval, &fval);

// 输出:
4 should equal 4

1
2
3

float fval = 4;
uint32_t* up = (uint32_t*)&fval;
fun(up, &fval);

1
2
3
4
5
6
7
8
9

void fun(float* e, float* f) 
{
    float a = *f *e = 22;
    float b = *f;
    print("is %g equal to %g?\n", a, b);
}
float fval = 4;
float eval = 77;
fun(&eval, &fval);

1
2
3
4
5
6

void fan(float*restrict e, float*restrict f) 
{
    float a = *f *e = 22;
    float b = *f;
    print("is %g equal to %g?\n", a, b);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <inttypes.h>
#include <stdio.h>

int main(void) 
{
    uint32_t a = 57;
    // conversion from incompatible types needs a cast !
    unsigned char* ap = (unsigned char*)&a;

    for (size_t i = 0; i < sizeof a; ++i) {
        /* set each byte of a to 42 */
        ap[i] = 42;
    }
    printf("a now has value %" PRIu32 "\n", a);
}

1
2

void foo(int a[], int n);
void foo(int *a, int n);

1
2
3
4
5
6
7

int array[5] = {
    [2] = 5, [1] = 2, [4] = 9
}; /* array is {0, 2, 5, 0, 9} */

int array[] = {
    [3] = 8, [0] = 9
}; /* size is 4 */

1
2

size_t m = calc_length(); /* calculate array length at runtime */
int vla[m]; /* create array with calculated length */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <stdlib.h> /* for EXIT_SUCCESS */

#define ARRLEN (10)

int main(void)
{
    int array[ARRLEN]; /* Allocated but not initialised, as not defined static or global. */
    
    size_t i;
    for(i = 0; i < ARRLEN; ++i) {
        array[i] = 0;
    }

    return EXIT_SUCCESS;
}

1

sizeof(array) / sizeof(array[0])

1
2
3
4
5
6

array[4] = 5;
4[array] = 5;
*(4 + array) = 5;

// 获取值
val = 4[array];

1
2
3
4
5

type name[size1][size2]...[sizeN];

int arr[5][10][4];

// 初始化 3 维数组

1
2
3
4
5

#ifdef NDEBUG
# define assert(condition) ((void) 0)
#else
# define assert(condition) /* implementation defined */
#endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

int length2 (int *a, int count)
{
    int i, result = 0;

    /* Precondition: */
    /* NULL is an invalid vector */
    assert (a != NULL);

    /* Number of dimensions can not be negative.*/
    assert (count >= 0);

    /* Calculation */
    for (i = 0; i < count; ++i) {
        result = result + (a[i] * a[i]);
    }

    /* Postcondition: */
    /* Resulting length can not be negative. */
    assert (result >= 0);

    return result;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include <stdio.h>
/* Uncomment to disable `assert()` */
/* #define NDEBUG */
#include <assert.h>
int main(void)
{
    int x = -1;
    assert(x >= 0);
    printf("x = %d\n", x);

    return 0;
}

1

a.out: main.c:9: main: Assertion `x >= 0' failed.

1
2
3
4

#include <assert.h>
enum {N = 5};
_Static_assert(N == 5, "N does not equal 5");
static_assert(N > 10, "N is not greater than 10"); /* compiler error */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#define STATIC_MSG(msg, l) STATIC_MSG2(msg, l)
#define STATIC_MSG2(msg,l) on_line_##l##__##msg
#define STATIC_ASSERT(x, msg) extern char STATIC_MSG(msg, __LINE__) [(x)?1:-1]

enum 
{
    N = 5
};
STATIC_ASSERT(N == 5, N_must_equal_5);
STATIC_ASSERT(N > 5, N_must_be_greater_than_5); /* compile error */

1
2
3
4
5
6

#ifdef __STDC_NO_ATOMICS__
# error this implementation needs atomics•
#endif•
#include <stdatomic.h>

unsigned _Atomic counter = ATOMIC_VAR_INIT(0);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

static unsigned _Atomic active = ATOMIC_VAR_INIT(0);

int myThread(void* a) 
{
    ++active; // increment active race free

    // do something

    --active; // decrement active race free

    return 0;
}

1

type-specifier identifier : size;

1
2
3
4
5
6

struct encoderPosition 
{
    unsigned int encoderCounts : 23;
    unsigned int encoderTurns : 4;
    unsigned int _reserved : 5;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

struct FPGAInfo 
{
    union {
        struct bits {
            unsigned int bulb1On : 1;
            unsigned int bulb2On : 1;
            unsigned int bulb1Off : 1;
            unsigned int bulb2Off : 1;
            unsigned int jetOn : 1;
        };
    unsigned int data;
    };
};

1
2
3
4
5
6

FPGAInfo fInfo;
fInfo.data = 0xFF34F;

if (fInfo.bits.bulb1On) {
    printf("Bulb 1 is on\n");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

typedef union {
    struct bits {
#if defined(WIN32) || defined(LITTLE_ENDIAN)
        uint8_t commFailure :1;
        uint8_t hardwareFailure :1;
        uint8_t _reserved :6;
#else
        uint8_t _reserved :6;
        uint8_t hardwareFailure :1;
        uint8_t commFailure :1;
#endif
    };
    uint8_t data;
} hardwareStatus;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <stdio.h>
int main(void)
{
    /* define a small bit-field that can hold values from 0 .. 7 */
    struct {
        unsigned int uint3: 3;
    } small;

    /* extract the right 3 bits from a value */
    unsigned int value = 255 - 2; /* Binary 11111101 */
    small.uint3 = value; /* Binary 101 */
    printf("%d", small.uint3);

    /* This is in effect an infinite loop */
    for (small.uint3 = 0; small.uint3 < 8; small.uint3++) {
        printf("%d\n", small.uint3);
    }

    return 0;
}

1
2
3
4
5
6
7
8

struct C
{
short s; /* 2 bytes */
char c; /* 1 byte */
int bit1 : 1; /* 1 bit */
int nib : 4; /* 4 bits padded up to boundary of 8 bits. Thus 3 bits are padded */
int sept : 7; /* 7 Bits septet, padded up to boundary of 32 bits. */
};

1
2
3
4
5
6

struct A
{
    unsigned char c1 : 3;
    unsigned char c2 : 4;
    unsigned char c3 : 1;
};

1
2
3
4
5
6
7
8
9

struct B
{
    unsigned char c1 : 1;
    unsigned char : 2; /* Skips 2 bits in the layout */
    unsigned char c2 : 2;
    unsigned char : 0; /* Causes padding up to next container boundary */
    unsigned char c3 : 4;
    unsigned char c4 : 1;
};

1

int main(int argc, char *argv[])

1
2
3
4

/* ... */

// c99 及其之后
// ... 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 不好
if ( i == 2) //Bad-way
{
    doSomething;
}

// 好
if( 2 == i) //Good-way
{
    doSomething;
}

1
2
3
4

(const char [])
{
    "abc"
} == "abc"

1
2
3
4

(type)
{
    initializer-list 
}

1
2
3
4
5
6
7
8

#include <errno.h>•
int errno; /* implementation defined */•

#include <string.h>•
char *strerror(int errnum);•

#include <stdio.h>•
void perror(const char *s);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <stdio.h> /* Include this to use any of the following sections */•
FILE *fopen(const char *path, const char *mode); /* Open a stream on the file at path with
the specified mode */

FILE *freopen(const char *path, const char *mode, FILE *stream); /* Re-open an existing
stream on the file at path with the specified mode */

int fclose(FILE *stream); /* Close an opened stream */•
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); /* Read at most nmemb
elements of size bytes each from the stream and write them in ptr. Returns the number of
read elements. */

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream); /* Write nmemb
elements of size bytes each from ptr to the stream. Returns the number of written elements.
*/

int fseek(FILE *stream, long offset, int whence); /* Set the cursor of the stream to offset,
relative to the offset told by whence, and returns 0 if it succeeded. */

long ftell(FILE *stream); /* Return the offset of the current cursor position from the beginning
of the stream. */

void rewind(FILE *stream); /* Set the cursor position to the beginning of the file. */•
int fprintf(FILE *fout, const char *fmt, ...); /* Writes printf format string on fout */•
FILE *stdin; /* Standard input stream */•
FILE *stdout; /* Standard output stream */•
FILE *stderr; /* Standard error stream */

1
2
3
4
5
6

- `returnType (*name)(parameters);`
- `typedef returnType (*name)(parameters);`
- `typedef returnType Name(parameters);`
    Name *name;
- `typedef returnType Name(parameters);`
  `typedef Name *NamePtr;`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

/* all versions */•
for ([expression]; [expression]; [expression]) one_statement•
for ([expression]; [expression]; [expression]) { zero or several statements }•
while (expression) one_statement•
while (expression) { zero or several statements }•
do one_statement while (expression);•
do { one or more statements } while (expression);•

// since C99 in addition to the form above•
for (declaration; [expression]; [expression]) one_statement;•
for (declaration; [expression]; [expression]) { zero or several statements }

1
2
3
4
5
6
7
8

return val; /* Returns from the current function. val can be a value of any type that is converts to the function's return type. */

return; /* Returns from the current void-function. */•
break; /* Unconditionally jumps beyond the end ("breaks out") of an Iteration Statement (loop) or out of the innermost switch statement. */

continue; /* Unconditionally jumps to the beginning of an Iteration Statement (loop). */•
goto LBL; /* Jumps to label LBL. */•
LBL: statement /* any statement in the same function. */

1
2
3
4
5
6

void *aligned_alloc(size_t alignment, size_t size); /* Only since C11 */•
void *calloc(size_t nelements, size_t size);•
void free(void *ptr);•
void *malloc(size_t size);•
void *realloc(void *ptr, size_t size);•
void *alloca(size_t size); /* from alloca.h, not standard, not portable, dangerous. */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

thrd_t // Implementation-defined complete object type identifying a thread•
int thrd_create( thrd_t *thr, thrd_start_t func, void *arg ); // Creates a thread•
int thrd_equal( thrd_t thr0, thrd_t thr1 ); // Check if arguments refer to the same thread•
thr_t thrd_current(void); // Returns identifier of the thread that calls it•
int thrd_sleep( const struct timespec *duration, struct timespec *remaining ); // Suspend call
thread execution for at least a given time

void thrd_yield(void); // Permit other threads to run instead of the thread that calls it•
_Noreturn void thrd_exit( int res ); // Terminates the thread the thread that calls it•
int thrd_detatch( thrd_t thr; // Detaches a given thread from the current environment•
int thrd_join( thrd_t thr, int *res ); // Blocks the current thread until the given thread finishes

1
2
3
4

expr1 operator•
operator expr2•
expr1 operator expr2•
expr1 ? expr2 : expr3

1
2
3
4
5
6
7
8

<Data type> *<Variable name>;•
int *ptrToInt;•
void *ptrToVoid; /* C89+ */•
struct someStruct *ptrToStruct;•
int **ptrToPtrToInt;•
int arr[length]; int *ptrToFirstElem = arr; /* For <C99 'length' needs to be a compile time constant, for >=C11 it might need to be one. */

int *arrayOfPtrsToInt[length]; /* For <C99 'length' needs to be a compile time constant, for >=C11 it might need to be one. */

1
2
3

arc4random() (available on OS X and BSD)•
random() (available on Linux)•
drand48() (available on POSIX)

1
2
3
4
5

#include <CppUTest/CommandLineTestRunner.h>
#include <CppUTest/TestHarness.h>
TEST_GROUP(Foo_Group) {}
TEST(Foo_Group, Foo_TestOne) {}
/* Test runner may be provided options, such

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#ifndef __STDC_NO_THREADS__•
# include <threads.h>•
#endif•
void call_once(once_flag *flag, void (*func)(void));•
int cnd_broadcast(cnd_t *cond);•
void cnd_destroy(cnd_t *cond);•
int cnd_init(cnd_t *cond);•
int cnd_signal(cnd_t *cond);•
int cnd_timedwait(cnd_t *restrict cond, mtx_t *restrict mtx, const struct timespec *restrict ts);

int cnd_wait(cnd_t *cond, mtx_t *mtx);•
void mtx_destroy(mtx_t *mtx);•
int mtx_init(mtx_t *mtx, int type);•
int mtx_lock(mtx_t *mtx);•
int mtx_timedlock(mtx_t *restrict mtx, const struct timespec *restrict ts);•
int mtx_trylock(mtx_t *mtx);•
int mtx_unlock(mtx_t *mtx);•
int thrd_create(thrd_t *thr, thrd_start_t func, void *arg);•
thrd_t thrd_current(void);•
int thrd_detach(thrd_t thr);•
int thrd_equal(thrd_t thr0, thrd_t thr1);•
_Noreturn void thrd_exit(int res);•
int thrd_join(thrd_t thr, int *res);•
int thrd_sleep(const struct timespec *duration, struct timespec* remaining);•
void thrd_yield(void);•
int tss_create(tss_t *key, tss_dtor_t dtor);•
void tss_delete(tss_t key);•
void *tss_get(tss_t key);•
int tss_set(tss_t key, void *val);