c语言基础知识要点

C语言程序的构成

与C++、Java相比，C语言其实很简单，但却非常重要。因为它是C++、Java的基础。不把C语言基础打扎实，很难成为程序员高手。

一、C语言的结构

先通过一个简单的例子，把C语言的基础打牢。

/* clang01_1.c */
#include <stdio.h>

int main(void)
{
    printf("这是劝学网的C语言教程。\n");

    return 0;
}

C语言的结构要掌握以下几点：

1. C语言的注释是/* ··· */，而不是//···，//是C++的单行注释，有的C语言版本也认可。
2. C语言区分大小写，每句以分号结尾。
3. C语言程序是从main函数开始的。函数的返回值如果缺省则为int，而不是void。
4. 函数必须用return来返回。即使void类型也不建议省略。
5. 使用函数时须包含相应的头文件。自定义的头文件用双引号，C语言自身的头文件用<···>

二、main()函数的写法与含义

main()的参数和返回值全部省略，这和上例含义相同。省略写法是一种很不好的习惯。

main()                       int main(void)
{                            {
    ···       等同于          ···
}                            }
    

main()的参数是一种不限个数的写法，argc代表参数的个数，真正的参数是放在argv[]数组里面的。注意：当数组当参数用时，数组被降格为指针。初学者先照着样子写，以后小雅会详细说明指针和数组的区别。

int main(int argc, char *argv[])                   int main(int argc, char **argv)
{                                                  {
    ···                       也可写成              ···
}                                                  }
    

三、头文件的意义

每个C程序通常分为两个文件。一个文件用于保存程序的声明（declaration），称为头文件。另一个文件用于保存程序的实现（implementation），称为定义（definition）文件。 C程序的头文件以“.h”为后缀，C 程序的定义文件以“.c”为后缀。

头文件的内容也可以直接写C程序中，但这是很不好的习惯。许多初学者用了头文件，却不明其理。在此略作说明。

1. 通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功 能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。
2. 头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中 的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的 负担。

关于头文件的内容，初学者还必须注意。

1. 头文件中可以和C程序一样引用其它头文件，可以写预处理块，但不能写语句命令。
2. 可以申明函数，但不可以定义函数。
3. 可以申明常量，但不可以定义变量。
4. 可以“定义”一个宏函数。注意：宏函数很象函数，但却不是函数。其实还是一个申明。
5. 结构的定义、自定义数据类型一般也放在头文件中。
6. #include <filename.h>，编译系统会到C语言固定目录去引用。#include "filename.h"，系统一般首先在当前目录查找，然后再去环境指定目录查找。

四、好的风格是成功的关键

版本申明、函数功能说明、注释等是C语言程序的一部分。不养成很好的习惯则不能成为C语言高手（专业人员）。

由于以上部分都是容易忽略的知识点，劝学网上有就直接转了。转自劝学网http://www.quanxue.cn/JC_CLanguage/CLang/CLang01.html

二、比较、逻辑、位运算符

只有类型相同（或C语言能自动转换）的表达式才能比较，如果类型不同就必须用函数转换。例如：判断一字符串的长度是否等于10，就要用strlen()将字符串的长度求出来变成了整型，才能和10比较。

比较运算符只有6个，即：等于(==)、不等于(!=)、大于(>)、小于(<)、大于等于(>=)、小于等于(<=)。比较运算符也叫关系运算符。

逻辑运算符只有3个，即：与AND(&&)、或OR(||)、非NOT(!)。

位运算符只有6个，即：与AND(&)、或OR(|)、非NOT(~)、异或XOR(^)、左移ShiftLeft(<<)、右移ShiftRight(>>)。

三、数组

1. 数组名也是一变量名，定义时须指定类型和长度。
2. 长度可以方括号中直接指定，也可以通过赋值来间接指定。
3. 数组可以在定义时直接赋值，也可以定义时不赋值，之后再赋值。
4. 当使用超出范围的值时，编译不出错，但运行会出错。（上例运行时出错后，选“忽略”后得到的结果）

数组的地址

弄清数组地址对使用数组有很大好处，另外，有的函数的参数是指针(如scanf函数)，如果要用数组的某一元素作参数，就必须知道其地址。

#include <stdio.h>

int main(void)
{

    int  i;
    int  iArr[7];
    char cArr[] = {'Q','U','A','N','X','U','E'};

    //输出iArr数组和cArr数组的地址
    printf("iArr=%p, cArr=%p\n\n", iArr, cArr);

    //输出iArr[i]数组和cArr[i]数组的地址
    for (i=0; i<7; i++) {
        printf("iArr[%d]=%p, cArr[%d]=%p\n", i, &iArr[i], i, &cArr[i]);
    }

    return 0;
}

1. 数组iArr是int类型，所以它的地址是按4字节递增。
2. 数组cArr是char类型，所以它的地址是按1字节递增。
3. 数组元素的地址是通过数组元素前面加“&”来取得。(如：&iArr[3])
4. 数组名单独使用时，代表该数组的首地址。（iArr等同于&iArr[0]）(注意：以后使用指针会经常用到这一点)

四、字符数组和字符串的重定义

字符数组就是字符串吗？有人说是，因为书上这么写，教师也这么教的。小雅不敢说书上或教师们错了，但至少可以说许多初学者都混淆了这两个概念。因此，在这此将这2个概念再明确一下。

1. 字符数组，完整地说叫字符类型的数组。字符数组不一定是字符串。
2. 字符串是最后一个字符为NULL字符的字符数组。字符串一定是字符数组。
3. 字符数组的长度是固定的，其中的任何一个字符都可以为NULL字符。
4. 字符串只能以NULL结尾，其后的字符便不属于该字符串。
5. strlen()等字符串函数对字符串完全适用，对不是字符串的字符数组不适用。

#include <stdio.h>
#include <string.h>

int main(void)
{
    //这是字符数组赋初值的方法
    char cArr[] = {'Q','U','A','N','X','U','E'};
    //这是字符串赋初值的方法
    char sArr[] ="quanxue";

    //用sizeof()求长度
    printf("cArr的长度=%d\n", sizeof(cArr));   //长度为7
    printf("sArr的长度=%d\n", sizeof(sArr));   //长度为8，最后一位是NULL

    //用printf的%s打印内容
    printf("cArr的内容=%s\n", cArr);   //不能正确显示
    printf("sArr的内容=%s\n", sArr);   //可以正确显示

    //用strlen()求长度
    printf("cArr的长度=%d\n", strlen(cArr));   //不正确的结果
    printf("sArr的长度=%d\n", strlen(sArr));   //NULL不在计算范围

    return 0;
}

从上面例子看来，还要注意以下几点：

1. char sArr[] = "quanxue";这种方式，编译时会自动在末尾增加一个NULL字符。
2. NULL字符也就是'\0'，在ASCII表中排在第一个，用16进制表示为0x00。
3. sizeof()运算符求的是字符数组的长度，而不是字符串长度。
4. strlen()函数求的是字符串长度，而不是字符数组。它不适用于字符串以外的类型。
5. char sArr[] = "quanxue";也可以写成char sArr[8] = "quanxue";（注意：是8而不是7）

字符数组和字符串数组的转化

字符数组中插入一个NULL字符，NULL字符前面（包括NULL字符）就成了字符串，一般NULL字符插在有效字符的最后。

#include <stdio.h>
#include <string.h>

int main(void)
{
    //因为最后有NULL，所以这就变成了字符串
    char cArr[] = {'Q', 'U', 'A', 'N', 'X', 'U', 'E', '\0'};
    //因为少定义了一位，最后无NULL，所以这就变成了字符数组
    char sArr[7] ="quanxue";
    //最后一个元素未赋值
    char tArr[16] ="www.quanxue.cn";

    //用sizeof()求长度
    printf("cArr: %2d ,%2d\n", strlen(cArr), sizeof(cArr));
    printf("sArr: %2d ,%2d\n", strlen(sArr), sizeof(sArr));
    printf("tArr: %2d ,%2d\n", strlen(tArr), sizeof(tArr));

    //将tArr的最后一个元素赋值，字符串就成了字符数组
    tArr[15] = '!';

    //作为字符数组，将显示16个字符
    for (i=0; i<16; i++) printf("%c", tArr[i]);  //字符数组的显示方法
    //作为字符串，将显示14个字符。
    printf("\n%s\n", tArr);     //字符串的显示方法

    return 0;
}

数组的输入输出『gets()，puts()』

getchar()和putchar()函数是单个字符的输入输出，gets()和puts()是字符串的输入输出，也是标准函数，在stdio.h中被定义。

五、指针

指针符号『*』和地址符号『&』

『&』符号是取变量的地址，『*』符号是取地址的内容(即：值)。两个操作正好相反。例如：“&i”就是取变量i的地址，“*(&i)”就是取“&i”这个地址的值，其实就是变量i。即然如此，为什么还要定义指针呢？原来，用『&』所取到的地址，自身只能用而不能修改。因此，直接把『&』取到的地址放到指针变量中去，既然指针变量也是变量，这个变量就可以任意存放其它地址。

#include <stdio.h>

int main(void)
{
    int i = 100, j=200;
    int *p;

    p = &i;     //变量i的地址赋给p
    printf("&i=%p   *(&i)=%d\n",  &i, *(&i));
    printf(" p=%p   *p   =%d\n\n", p,  *p);

    p = &j;     //变量j的地址赋给p
    printf("&j=%p   *(&j)=%d\n", &j, *(&j));
    printf(" p=%p   *p   =%d\n", p,  *p);

    return 0;
}

指针变量的赋值和指针的赋值

上例中p是指针变量，*p是p的指针，p存放的是某个变量的地址，*p存放的是某个变量的值。当*p的内容改变时，p所指的变量的内容也发生改变，因为是同一个地址的存贮单元的值发生改变。同理，当p所指的变量的值发生改变时，*p的内容也随之改变。

#include <stdio.h>

int main(void)
{
    int i = 100, j=200;
    int *p;

    p = &i;     //变量i的地址赋给p
    *p = 500;   //将500赋给p指针
    //变量i的内容也随之改变为500
    printf("&i=%p   *(&i)=%d\n",  &i, *(&i));
    printf(" p=%p   *p   =%d\n\n", p,  *p);

    p = &j;     //变量j的地址赋给p
    j++;        //将p指针的内容+1
    //指针*p的内容也随之改变201
    printf("&j=%p   *(&j)=%d\n", &j, *(&j));
    printf(" p=%p   *p   =%d\n", p,  *p);

    return 0;
}

被初始化的是指针变量还是指针

上面2例，指针变量都是用的p，初学者不要认为只能用p，既然是变量，只要不违反命名规则都可以。当指针变量被定义时立即赋值，这时被赋值的是指针变量还是指针呢？下面这段程序请大家千万注意！

#include <stdio.h>

int main(void)
{

    char str[] ="http://www.quanxue.cn/";
    char *ptr ="http://www.51minge.com/";
    char *point;

    point = str;  //将str数组的地址赋给指针变量point
    point[11] = 'Q', point[15] = 'X';
    printf("str=%s\n",str);

    ptr[13] = 'M', ptr[16] = 'G';  //这句是错误的，删除后结果如下

    printf("ptr=%s\n",ptr);

    return 0;

}

1. char str[] = "http://www.quanxue.cn/";中str是数组变量，当地址赋给point之后，point[11]就是str[11]，所以其内容可以改变。
2. char *ptr = "http://www.51minge.com/";中赋值的性质和上面的str不同。这并不是将"http://www.51minge.com/"赋给*ptr指针，而是先定义一个常量"http://www.51minge.com/"，这个常量是定义在“栈”里面，然后将这个常量的地址赋给ptr，而不是*ptr。常量是不能被修改的，因此ptr[13]也就出错了。这是初学者经常犯的错误。

    int i = 129;
    int num[] = {50, 25, 75, 100};

    int *pt1 = 125;    //错误1: 125作为地址赋给pt1，  这段内存是OS用的
    int *pt2 = i ;     //错误2: 129作为地址赋给pt2，  这段内存是OS用的
    int *pt3 = &i;     //正确:  变量i的地址赋给pt3，  因为i是基本类型，所以要加&符号
    int *pt4 = num;    //正确:  数组num的地址赋给pt4，因为num是数组，变量名就代表地址

    char *pt5 ;
   *pt5 ="ABCDE";     //错误3:  "ABCDE"是字符串，也是数组， 此处更是常量
    pt5 ="ABCDE";     //正确:   赋值时赋的是地址，因此只能赋给指针变量pt5

    int *pt6 ;
    pt6 =i;           //错误4:  129作为地址赋给pt6，  这段内存是OS用的
   *pt6 =i;           //错误5:  129赋给指针pt6，但pt6尚未分配地址，没有空间存放i的值

不赋值的指针和NULL

未赋值的指针变量是不能被使用的，其地址指向未不能使用的空间。建议定义时如果暂不使用，先赋NULL。为一个指针申请空间时，一定义要判断其是否为空，因为分配内存失败时返回NULL。不仅如此，甚至在使用指针时都应该判断一下是否为空。下面讲到的内存分配是重要内容，在下下章详细介绍。

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char *pchar;

    //下面这句出错，忽略之后继续
    printf("pchar=%p\n", pchar);  //未分配的指针不可用

    pchar = NULL;
    printf("pchar=%p\n\n", pchar);  //空指针可用于表达式中

    //pchar为空时，动态分配内存
    if (!pchar) {
        pchar = (char *)malloc(20);  //动态分配内存
        if (!pchar) {  //初学者不要忘记， 这是必要的判断
            printf("内存分配失败。");
            exit(-1);  //退出
        }
        gets(pchar);
        printf(" pchar=%p\n*pchar=%s\n", pchar, pchar);
        free(pchar);   //内存释放后，指针变量的地址不变
        if (pchar) {   //pchar并不为空
            printf("\n pchar=%p\n*pchar=%s\n", pchar, pchar);  //pchar成了“野指针”
        }
    }

    return 0;
}

六、指针、数组和字符串

一、数组和指针的关系

下面仍然是初学者容易搞错的地方。指针变量加n或减n，并不是地址加n或减n，而是当前所指的地址向后或向前跳n次所指的地址。

#include <stdio.h>

int main(void)
{
    int num[] = {50, 25, 75, 100};
    int *pt;

    pt = num + 1;   //故意将第2个元素地址赋给指针变量

    //显示指针变量所指的地址以及指针的值
    printf("pt  =%d, *pt    =%d\n\n", pt,   *pt);

    //当指针变量减1或加1时，所指的地址并不减1或加1，而是加减4，因为int是4个字节
    printf("pt-1=%d, *(pt-1)=%d\n", pt-1, *(pt-1));
    printf("pt  =%d, *pt    =%d\n", pt,   *pt);
    printf("pt+1=%d, *(pt+1)=%d\n", pt+1, *(pt+1));

    //显示pt当作数组用时的值。(注意：[-1]仍然是正确的)
    printf("\npt[0]=%d, pt[-1]=%d\n", pt[0], pt[-1]);

    return 0;
}

二、指针数组

char型的指针数组相当于二维字符数组，并不等于说指针数组可以直接转化为二为字符数组，相反字符数组可以直接转化为指针数组。因为二维字符数组的地址是连续的，而指针数组所指的元素不一定连续（如下的m1、m2、m3的地址可以不连续，长度也可以不一样）。

#include <stdio.h>

int main(void)
{
    char *m1 ="www.quanxue.cn";
    char *m2 ="www.51minge.com";
    char *m3 ="这儿是小雅的C语言教程";

    char *message[3];                  //|  #include <stdio.h>
    int i;                             //|
                                       //|  int main(void)
    message[0] = m1;                   //|  {
    message[1] = m2;                   //|      char *message[] = {"www.quanxue.cn",
    message[2] = m3;                   //|"www.51minge.com",
                                       //|"这儿是小雅的C语言教程"};
    for (i=0; i<3; i++) {              //|      for (i=0; i<3; i++) {
        printf("%s\n", message[i]);    //|          printf("%s\n", message[i]);
    }                                  //|      }
                                       //|
    return 0;                          //|      return 0;
}                                      //|  }

三、指向指针的指针

在第一章讲main()函数的参数时，已经见过指针的指针，这和指针数组有相同的作用，但还是有细小的区别。指针数组可以在定义时直接初始化，而指向指针的指针不行。正如二维数组一样，不指定第二维长度不能直接初始化一样。即不能char str[][]={"...", "...", ...}

#include <stdio.h>

int main(void)
{
    char *message[] = {"www.quanxue.cn","www.51minge.com","这儿是小雅的C语言教程"};
    char **p;       //指向指针的指针
    int i;

    p = message;    //指向指针的指针赋初值
    for (i=0; i<3; i++) {
        printf("%s\n", p[i]);
    }

    return 0;
}

四、指针的长度

让许多初学者遗憾的是，C语言没有提供数组长度的函数，但可以用sizeof()运算符先求数组的总长度，再求出数组类型的长度，二者相除便得到数组的长度。C语言更大的一个遗憾便是，sizeof()对指针变量求值时，结果总是4，这是因为指针变量的内容是地址，地址总是4个字节来表示。

因此有经验的编程人员，在用指针作参数时，一般总是同时多定义一个参数，来存放其长度。也就是指针和其长度同时传递过去。另外，数组长度如果事先知道，一般定义为常量。

#include <stdio.h>

int main(void)
{
    char *msg[] = {"www.quanxue.cn","www.51minge.com","这儿是小雅的C语言教程"};
    double dNum[] = {12.5, 24.55, 100.83};
    double *p = dNum;

    printf("dNum的size:%2d, 数组个数是:%d\n", sizeof(dNum), (int)sizeof(dNum)/sizeof(double));
    printf("   p的size:%2d, 数组个数是:%d\n", sizeof(p   ), (int)sizeof(p   )/sizeof(double));
    printf(" msg的size:%2d, 数组个数是:%d\n", sizeof(msg ), (int)sizeof(msg )/sizeof(char *));

    return 0;
}

七、为指针动态分配内存

C语言程序员要严防内存泄漏，这个“内存泄漏”就是由动态内存分配引起的。指针是C语言和其它语言的最大区别，也是很多人不能跨入C语言的一道门槛。既然指针是这么一个“危险”的坏东西，干吗不取消它呢？

其实指针本身并没有好坏，它只是一种操作地址的方法，学会了便可以发挥其它语言难以匹敌的功能，没学会的话，只能做其它语言的程序员，也同样发挥你的光和热。小雅本人也在C语言门外徘徊多年，至今仍属于初学者。

一、变量和数组可以通过指针来转换

“int *x”中的x究竟是不是数组？光看这一句小雅无法告诉你，因为它既可表示单个变量内容，也可表示数组。下面是小雅专门为你准备的例子，理解之后，对动态分配时长度计算有好处。

#include <stdio.h>

int main(void)
{
    int *num = NULL;
    int *x, y[] = {12, 22,32}, z = 100;

    //下面演示，指针既可充当变量、也可充当数组
    x=&z;      //整型变量的地址赋给x
    printf("*x=%d, x[0]=%d\n", *x, x[0]);

    x = y;     //数组的地址赋给x
    printf("*x=%d, x[ 0]=%d, x[ 1]=%d, x[2]=%d\n", *x, x[0], x[1], x[2]);

    x = y + 1; //数组的第二位地址赋给x
    printf("*x=%d, x[-1]=%d, x[ 0]=%d, x[1]=%d\n", *x, x[-1], x[0], x[1]);

    x = y + 2; //数组的第三位地址赋给x
    printf("*x=%d, x[-2]=%d, x[-1]=%d, x[0]=%d\n", *x, x[-2], x[-1], x[0]);

    return 0;
}

二、动态分配内存

前面讲到的指针，基本上将已经定义好的变量的地址赋给指针变量，现在要学的是向操作系统申请一块新的内存。申请到的内存，必须在某个地方手动释放，因此下面2个函数必须配对使用。malloc()和free()，都是标准函数，在stdlib.h中定义。

根据不同的电脑使用状况，申请内存有可能失败，失败时返回NULL，因此，动态申请内存时，一定要判断结果是否为空。malloc()的返回值类型是“void *”，因此，不要忘记类型转换。（许多人都省略了。）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char *p ;

    p = (char *)malloc(40 * sizeof(char)) ;
    if (p == NULL) {          //这个判断是必须的
        printf("内存分配出错！");
        exit(1);
    }
    strcpy(p,"这是劝学网C语言教程。\n");   //不要忘记给新内存赋值
    printf("%s", p);

    free(p);    //过河一定要拆桥
    p = NULL ;  //释放后的指针置空，这是非常好的习惯，防止野指针。

return 0;
}

三、隐蔽的内存泄漏

内存泄漏主要有以下几种情况：

1. 内存分配未成功，却使用了它。
2. 内存分配虽然成功，但是尚未初始化就引用它。
3. 内存分配成功并且已经初始化，但操作越过了内存的边界。
4. 忘记了释放内存，造成内存泄露。
5. 释放了内存却继续使用它。

下面的程序造成内存泄漏，想想错在何处？如何修改？

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *p, i;

    p = (int *)malloc(6 * sizeof(int)) ;
    if (p == NULL) {    //判断是否为空
        printf("内存分配出错！");
        exit(1);
    }

    for (i=0; i<6; i++) {
        p++;
        *p = i;
        printf("%2d", *p);

    }
    printf("\n");

    free(p);    //这句运行时出错

    return 0;
}

四、对动态内存的错误观念

有人对某一只在函数内使用的指针动态分配了内存，用完后不释放。其理由是：函数运行结束后，函数内的所有变量全部消亡。这是错误的。动态分配的内存是在“堆”里定义，并不随函数结束而消亡。

有人对某动态分配了内存的指针，用完后直接设置为NULL。其理由是：已经为NULL了，这就释放了。这也是错误的。指针可以任意赋值，而内存并没有释放；相反，内存释放后，指针也并不为NULL。

八、return和exit、assert的区别

return语句是结束当前函数。而exit是结束main()函数，即整个程序，一般都是在遇到非常错误时才调用exit()。assert()是一个宏定义，在assert.h中申明，用来在DEBUG方式诊断程序，当参数中的条件不成立时，中断main()函数。建议多多使用assert()。

九、变量和函数

在函数之外定义的变量是全局变量，在函数内定义的变量是这个函数的局部变量。局部就是只能在当前函数内使用，而全局变量可以在任何一个函数中使用。

注意：一般而言，全局变量总是在所有函数之前定义，但如果某全局变量定义在两个函数之间，则定义处后面的函数可以使用，而其前面函数不能使用。

有人说静态变量相当于全局变量，这句话其实不对。全局变量变成静态，就失去了静态的意义，因此，静态一般是加在局部变量上的。那么，究竟什么是静态的局部变量呢？静态变量随函数的定义而定义，如果已经存在就延用，但并不随函数的结束而消亡。在某一函数中定义的静态局部变量，不能在其它函数使用。

当很多人编写同一程序时，一般程序会被分割成几个文件。当几个人都定义了某一全局变量时，编译时不出错，Link时将出错。解决这个问题的办法：将其中一个定义原封不动，其余的定义前加上extend（即外部的定义）。

刚才所说是许多书上说的，小雅做了n次试验，证明上述编译时也不错，Link时也不错，也就是说extend完全是多余的。大概上面所说是几十年前的版本吧。事实上与extend同列在一起的还有auto、regist等变量修饰符。auto是区别B语言的，早就没用了，regist是将变量放到寄存器来运算，小雅认为基本没有这种需要。

拆成多个文件，多次定义全局变量时要注意：

1. 变量的数据类型要一致。
2. 有长度的数组和没定义长度的数组可以视为同一数据类型。
3. 数组和指针不能视为同一数据类型。