快速学习C语言一: Hello World

估计不会写C语言的同学也都听过C语言,从头开始快速学一下吧,以后肯定能用的上。 如果使用过其它类C的语言,如JAVA,C#等,学C的语法应该挺快的。

先快速学习并练习一些基本的语言要素,基本类型,表达式,函数,循环结构, 基本字符串操作, 基本指针操作,动态分配内存,使用结构表示复杂数据, 使用函数指针实现灵活逻辑。

虽然C是一个规模很小的语言,但也得自己多设计一些练习练手才能学会。

基本类型

我就记得char, int, 别的都不常用吧应该,用的时候再搜索。

表达式

和JAVA, C#差不多吧,不用学基本,各种算数运算符,关系运算符,逻辑运算符,逗号, 括号等的意思应该也差不多,表达式最终的结果也有类型和值。

函数

函数是最基本的抽象,基本没有什么语言没有函数的概念,它封装一系列操作, 最简单的Hello world,如下。

static void hello_world(){
    printf("hello, world\n");
}

 

我们的练习都是随手写的函数,不需要被外部调用,所以前面加个static,表示只在 本文件内可见。

printf输出一行的话,最后要加\n, 常见个格式化参数有%d,%c,%s,%p等,分别表示 输出int, char, 字符串, 指针。

分支,循环结构

和别的语言差不多,不过i的声明要放在函数开头,c89就是这样。

static void n_hello_world(int n){
    int i = 0;
    for (i = 0; i < n; i++) {
        printf("hello, world\n");
    }
}

 

字符串练习,获取一个字符串的长度

库函数strlen就是干这个的,不过我们自己可以写一个练手,c没有字符串类型, 用'\0'结尾的字符数组表示字符串,所以for循环从头滚到'\0'位置就好了。

// 字符串练习, 计算字符串长度
static int w_strlen(const char* str){
    int i;
    // 向后滚动指针,同时递增i,直到找到字符串结尾
    for (i = 0; *str != '\0'; str++, i++) {
        ;
    }
    return i;
}

 

const 修饰符表示这个参数不能在函数里进行更改,防止意外改动。char *就是传说中 字符串了。 写C程序得用好for语句,有各种惯用法,用好了可以写出很紧凑的程序,比如上面for语句 的第2个分号后的逗号表达式可以递增两个变量。

理解字符串的存储

第一种方式是在编译时分配的内存,是字符串常量,指针s1指向的内存不能更改。 第二种方式应该是在栈上分配的内存(不确定),可以通过指针修改其中的字符。

static void change_str_test(){
    // 常量不能修改
    // char* s1 = "hello"; // will core dump
    char s1[10] = "hello";
    *s1 = 'p';
    printf("%s\n", s1);
}

 

指针练习

指针可以进行加减的操作,每加一次就滚动过它指向的类型长度, 比如char指针就是 滚动1个字节。

// 指针练习, 反转字符串
static char* reverse(char* str){
    char* ret = str;
    // 滚到字符数组末尾的\0之前
    char* p = str + w_strlen(str) - 1;
    char c;

    // 两个指针,一个从前往后滚,一个从后往前滚,直到就要交错之前
    // 滚动的过程中交换两个指针指向的字符
    for ( ; p > str; --p, ++str) { 
        printf("debug[reverse]: %p %p %c %c\n", p, str, *p, *str);
        c = *p;
        *p = *str;
        *str = c;
    }

    return ret;
}

 

c = *p表示取出指针p指向的字符,赋值给变量c,*表示取值。

*p = *str相当于p[i] = str[i],右边的取出来的是值,左边的取出来的也是值, 值赋值给值,看起来有些诡异,但就是这样写的。反正p = *str肯定不对,因为p是 指针类型,*str是计算结果是字符类型。

动态分配内存

我记得TCPL前几章都没讲malloc,free等内存分配的函数,好多任务只需要在编译阶段 分配内存就够了,但比较大型复杂的程序应该都需要动态管理一些内存的。

C语言没有GC,要手工释放动态分配的内存,否则就会造成内存泄漏,所以一定要配平 资源,有malloc的地方,一定要想好它应该在哪里free。

目前我了解到的原则就有两种:

  • 谁分配,谁释放
  • 谁使用,谁释放

对了, malloc出来的内存要强转成你需要的指针类型,然后free时指针要滚到你动态 分配内存的起始点。

// 内存申请相关,连接两个字符串
static void concat_test(){
    char* a = "hello";
    char* b = "world";
    //结果字符串长度为两个字符窜长度加\0的位置
    int len = w_strlen(a) + w_strlen(b) + 1;
    // 动态分配内存
    char* p = (char *)malloc(sizeof(char) * len);
    char* result; 

    // 必须判断是否分配到内存
    if (p != NULL){
        // 保存动态分配内存的开始指针,free时必须从这里free
        result = p;

        //滚动p和a,直到a的末尾
        while (*a != '\0') {
            printf("debug[concat_test]:while a %p %c\n", a, *a);
            *p++ = *a++;
        }

        //滚动p和b,直到b的末尾
        while (*b != '\0') {
            printf("debug[concat_test]:while b %p %c\n", a, *a);
            *p++ = *b++;
        }

        // 末尾整个0
        *p= '\0';
        printf("concat_test: %s\n", result);

        //释放动态分配的内存
        free(result);
    }else{
        printf("malloc error"); 
    }
}

 

结构练习

C没有类,要表达复杂的数据,就得用结构了, 结构也可以用指针来指,如果是结构变量 的话,引用成员用.,如果是指向结构的指针,引用成员用->

别的好像没啥特别的,注意动态分配结构数组后,指针滚动的边界,别使用了界外的 内存。如果结构的成员指向的内存是动态分配的花,也记得free。

没有结构,估计写不出大程序,结构应该会用的很多。

//结构练习,人员统计系统
struct customer {
    char* name;
    int age;
};

static void customer_manager() {
    // 直接在栈上分配结构体
    struct customer wawa;
    struct customer* p_wawa;
    struct customer* p_customers;
    int n = 2;

    char name[] = "wawa";
    // char* name = "wawa"; //splint warning
    char name2[] = "tiancai";

    // 直接用结构名访问成员 
    wawa.name = name;
    wawa.age = 30;
    printf("%s is %d years old\n", wawa.name, wawa.age);

    // 用指针访问结构成员
    p_wawa = &wawa;
    p_wawa->age = 31;
    printf("%s is %d years old\n", wawa.name, wawa.age);

    // 为员工数组动态分配内存
    p_customers = (struct customer*)malloc(sizeof(struct customer) * n);
    if (p_customers != NULL) {
        // 设置数组第一项
        p_customers->name = name;
        p_customers->age = 10;

        // 设置数组第二项
        p_customers++;
        p_customers->name = name2;
        p_customers->age = 30;

        // 滚动数组外面,然后反向循环到数组开始
        p_customers++;
        while(n-- > 0){
            p_customers--;
            printf("%s is %d years old\n", p_customers->name, p_customers->age);
        }

        // 释放动态分配的内存,这时候p_customers已经位于起始位置了
        // 结构体里的name1, name2是在栈上分配的,不用释放
        free(p_customers);
    }
}

 

函数指针练习

好多语言都有高阶函数的特性,比如函数的参数或返回值还可以是个函数, C里也有函数指针可以达到类似的效果,用来做回调函数等。

但C的函数指针写起来比较诡异,不好记忆,不行就用typedef来重新命个名,写起来 简单一些。

下面用一个比较经典的冒泡排序来演示函数指针的使用,传递不同的比较函数可以 改变排序函数的行为,这是写复杂灵活逻辑的一种很方便的方式。

// 函数指针练习, 排序

// 正序排序的比较函数
static int cmp_default(int a, int b){
    return a - b;
}

// 反序排序的比较函数
static int cmp_reverse(int a, int b){
    return b - a; 
}

// int类型的冒泡排序算法,可传入一个比较函数指针
// 类似回调函数,该函数需要两个int参数且返回int
static void sort(int* arr, int n, int (*cmp)(int, int)){
    int i, j, t;
    int *p, *q;

    p = arr;

    for (i = 0; i < n; i++, p++) {
        q = p;
        for (j = i; j < n; j++, q++) {
            // 调用函数指针指向的函数和使用函数一样,貌似是简单写法
            if (cmp(*p, *q) > 0) {
                t = *p;
                *p = *q;
                *q = t;
            }
        }
    }
}

// 测试排序函数
static void sort_test(){
    int arr[] = {4, 5, 3, 1, 2};
    int i, n = 5;

    // 正向排序, 传入cmp_default函数的地址,貌似不需要&取地址
    sort(arr, 5, cmp_default);
    for (i = 0; i < n; i ++) {
        printf("%d%s", arr[i], i == n - 1 ? "" : ", "); 
    }
    printf("\n");

    //反向排序,同上
    sort(arr, 5, cmp_reverse);
    for (i = 0; i < n; i ++) {
        printf("%d%s", arr[i], i == n - 1 ? "" : ", "); 
    }
    printf("\n");
}

 

总结

这几年断断续续看了四五遍K&R的《TCPL》了,可一直都没写过C程序,现在开始多练习 练习吧。

posted @ 2014-07-13 21:51 蛙蛙王子 Views(...) Comments(...) Edit 收藏