c 语言基础知识

1
2
3
4
5
6
7
8
9
10
11
12
// 可以灵活运用位运算，将多项属性存储在一个变量里。
// 二进制，每一位 1 表示一个选项。 ｜ 操作表示添加一项。 & ～ 结合使用去掉一项。
bool set_module_key(const string& value) {
    if (value.size() > 90) {
        m_ull_has_bit &= ~0x00000020;
        m_ui_error = 0;
        return false;
    }
    m_str_module_key = value;
    m_ull_has_bit |= 0x00000020;
    return true;
}

1
2
3
4
5
union Data {
    int i;
    float f;
    char str[20];
} data;

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef unsigned char u_char;

#define NGX_POOL_ALIGNMENT 16
#define ngx_align_ptr(p, a)                                                   \
    (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))

int main(int argc, char *argv[]) {
    ...
    char *p = (char *)malloc(1024);
    u_char *p10 = ngx_align_ptr(p, 4);
    u_char *p11 = ngx_align_ptr(p+1, 4);
    ...
}

1
2
3
#define max(x, y) (x) > (y) ? (x) : (y)
void func(int a) { printf("%d\n", a); }
func(max(a, ++b));

1
func((a) > (++b) ? (a) : (++b));

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

volatile int bbbb = 789;
volatile int aaaa = 123;

int main(int argc, char** argv) {
    aaaa += 456;
    bbbb = aaaa;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>

int main() {
    char array[] = "1234567890";
    const char* p = "1234567890";
    std::cout << "size: " << sizeof(p)
              << ",  str len: " << strlen(p) << std::endl;
    std::cout << "size: " << sizeof(array)
              << ", str len: " << strlen(array) << std::endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/* 判读字符是否字母。 */
int isalpha(int c);

/* 判读字母数字。 */
int isalnum(int c);

/* 大小写转换。 */
int tolower(int c);
int toupper(int c);

/* 判读字符是否为数字。 */
int isdigit(int c);

/* 字符串转换整数。 */
int atoi(const char* str);

/* 字符串转换指定格式的数字为十进制。 */
long int strtol (const char* str, char** endptr, int base);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* gcc test.c -o test && ./test */
#include <stdio.h>

char *_strcpy(char *dest, const char *src) {
    char *tmp = dest;
    while ((*dest++ = *src++) != '\0') {}
    return tmp;
}

int main() {
    char dest[100];
    const char *src = "1234567890";
    printf("return: %s\n", _strcpy(dest, src));
    return 0;
}

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
/* gcc test.c -o test && ./test */
#include <stdio.h>

int trim(char* s) {
    if (s == NULL) {
        return 0;
    }

    int num = 0;
    char* p = s;
    char* p2 = s;

    while (*p2 != '\0') {
        if (*p2 == ' ') {
            p2++;
            num++;
            continue;
        }
        *p++ = *p2++;
    }
    *p = '\0';

    return num;
}

int main() {
    char s[] = "1 2 3 4 5 6";
    int n = trim(s);
    printf("%s\n", s);
    return 0;
}

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
/* gcc test.c -o test && ./test */
#include <stdio.h>

int get_last_str_len(char* p) {
    char *p1, *p2, *cur;
    cur = p;

    while (*cur != '\0') {
        /* find not of. */
        while (*cur == ' ') {
            cur++;
        }
        p1 = cur;

        /* find of. */
        while (*cur != ' ' && *cur != '\0') {
            cur++;
        }
        p2 = (*cur != '\0') ? cur++ : cur;
    }

    return p2 - p1;
}

int main() {
    char s[] = "1 23    456 ";
    printf("%d\n", get_last_str_len(s));
    return 0;
}

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
typedef struct item_s {
    void* data;
    struct item_s* next;
} item_t;

void swap(item_t** head) {
    if (head == NULL || *head == NULL) {
        return;
    }

    item_t *pre, *cur, *next, *nnext;
    pre = cur = *head;
    next = cur->next;
    if (next != NULL) {
        m_head = next;
    }

    while (next != NULL) {
        nnext = next->next;
        next->next = cur;
        cur->next = nnext;
        pre->next = next;
        if (nnext == NULL) {
            break;
        }
        pre = cur;
        cur = nnext;
        next = cur->next;
    }
}