黑马程序员——C语言总结之篇

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

数据类型、运算符

1.C语言中的数据类型：

char：字符类型，只能存放单个字符

int：整形，只能存放整数

float：单精度类型，可以存放小数与整数，精度没有double高

double：双精度类型，可以存放小数

struct：结构体类型，通过基本数据类类型进行组合形成的复合数据类型

enum：枚举类型，实际存放的是整形，每个值对应一个整数。第一个值为0，第二个为1，以此类推。

union：共用体类型，通过其他数据类型组合形成的数据类型，占用内存由组合类型中最大的决定。

2.运算符：

C语言中的表达式就通过组合运算符而形成的，在此不做过多介绍

流程控制

从程序流程控制角度来看，程序可以分为顺序结构、选择结构与循环结构三种基本结构。

1.顺序结构：

C程序的执行部分是由语句组成，程序的功能是由执行语句来实现。常用的执行语句就是简单的顺序语句，简单顺序语句可以分为以表达式语句、空语句、复合语句。每个程序都有main函数，程序执行始于main函数，终于main函数。除了分支结构与循环结构的控制，main函数执行简单语句都是从上往下执行。

实例示范：  

#include <stdio.h>
int main()
{
    //顺序结构演示
    int a;//①分配内存空间
    printf("输入：");//②打印提示信息
    scanf("%d",&a);//③输入一个整数，存到内存中
    printf("输出：%d\n",a);//④将内存中的数据进行打印输出
    return 0;//⑤退出程序
    //以上5步，严格按照先后顺序执行
}

结果输出：

输入：4
输出：4

2.选择结构：

选择结构用于判断给定的条件，根据判断的结果判断某些条件，根据判断的结果来控制程序的流程。控制语句有如下两种：

if语句：if、if....else....、if.....else if...else

switch...case语句：switch..case

详细请看代码注释。

实例示范：  

<pre name="code" class="objc"><pre name="code" class="objc">#include <stdio.h>
int main()
{
    //顺序结构演示
    int a;//①分配内存空间
    printf("输入：");//②打印提示信息
    scanf("%d",&a);//③输入一个整数，存到内存中
    //通过a的值，来判断要进哪个分支执行
    if (a>0) {
        printf("输出：a>0\n");
    }else if(a==0){
        printf("输出：a=0\n");
    }else{
        printf("输出：a<0\n");
    }
    return 0;
}

结果输出：

<pre name="code" class="objc">输入：1
输出：a>0
输入：0
输出：a=0
输入：-1
输出：a<0

实例示范：  

#include <stdio.h>
int main()
{
    //顺序结构演示
    int a;//①分配内存空间
    printf("输入：");//②打印提示信息
    scanf("%d",&a);//③输入一个整数，存到内存中
    //通过a的值，来判断要进哪个分支执行
    switch (a) {
        case 1://case后面只能跟常量或者常量表达式
            printf("输出：a＝1\n");
            break;
        case 2://每句case结束要加个break
            printf("输出：a＝2\n");
            break;
        case 3://如果case里面有很多语句，请用大括号“｛｝”括起来。
            printf("输出：a＝3\n");
            break;
        default:
            printf("输出：a!＝1且a!=2且a!=3\n");
            break;
    }
    return 0;
}

结果输出：

输入：1
输出：a＝1
输入：2
输出：a＝2
输入：3
输出：a＝3
输入：4
输出：a!＝1且a!=2且a!=3

3.循环结构：

循环结构可以减少源程序重复书写的工作量，用来描述重复执行某段算法的问题，这是程序设计中最能发挥计算机特长的程序结构 。该结构控制语句如下：

for语句：for(表达式1；条件表达式2；表达式3)｛.....｝，表达式2一定是条件表达式，3个表达式中间用分号隔开

do....while语句：do {.....}while(条件表达式);

while语句：while(条件表达式){......}

goto语句：先标记一个跳转的点A:.....，要跳转的位置写上goto A;

实例示范：  

#include <stdio.h>
int main()
{
    //循环结构演示
    int a;//分配内存空间
    system("clear");//演示前先清屏
    //---------------------------------
    //演示do..while的使用，验证输入合法性,先输入一次，后判断
    do
    {
        printf("请输入一个5～8的正整数:");
        scanf("%d",&a);
        system("clear");
        if(a<5||a>8)
            printf("输入错误，");
    }while(a<5||a>8);
    printf("输入的数为：%d\n",a);//验证通过

    //---------------------------------
    //演示for循环的使用，求1～a的整数和。
    int sum = 0;
    int i = 1;
    for (i=0; i < a; i++) {
        sum +=i;
    }
    printf("1+2+..+%d = %d\n",a,sum);
    
    //---------------------------------
    //演示while循环的使用，求a！(a的阶乘)
    sum = 1;
    i = 1;
    while (i<=a) {
        sum *=i;
        i++;
    }
    printf("1*2*...*%d = %d\n",a,sum);
    
    //---------------------------------
    //演示goto语句的使用
    printf("演示goto语句\n");
    goto A;                 //可以注释这句，看看效果
    printf("    *    \n");
    printf("   * *   \n");
    printf("  *   *  \n");
    printf("   * *   \n");
    printf("    *    \n");
A:  printf("标记goto跳转点，是否跳过图案打印\n");
    return 0;
}

结果输出：

注释goto A得到如下结果：

输入的数为：5
1+2+..+5 = 10
1*2*...*5 = 120
演示goto语句
    *    
   * *   
  *   *  
   * *   
    *    
标记goto跳转点，是否跳过图案打印

不注释goto A得到的结果：

输入的数为：6
1+2+..+6 = 15
1*2*...*6 = 720
演示goto语句
标记goto跳转点，是否跳过图案打印

输入的数不是5～8得到的结果：（可以继续输入值）

输入错误，请输入一个5～8的正整数:

数组与指针

1.数组：

所谓数组，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，然后用编号区分他们的变量的集合，这个名字称为数组名，编号称为下标。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。数组是在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组织起来的一种形式。这些按序排列的同类数据元素的集合称为数组。

定义：

int a[10];//声明一个可以存放10个整数的数组

读写访问

a[0] = 10;//将10写入数组的一个个元素位置

2.指针：

在计算机科学中，指针是编程语言中的一个对象，用于存储变量单元的地址，将存储变量单元地址的对象形象化的称为“指针”。

int a;//a是一个变量，其在内存中有一个对应的存储单元，而内存中每个存储单元都有对应的地址，所以a所在内存单元中也有对应的地址。

&a//就是查看a所在内存单元的地址

int *p = &a;//将a所在内存单元的地址保存到p中，p就称为指针。因为p存储a在内存单元的地址，所以可以通过p去内存中查找a。

int a[10];// a存储了a[0]的地址，(a=&a[0];)所以a也是一个指针。

实例示范： 

#include <stdio.h>
int main()
{
    int a[10];//定义一个数组
    //利用for循环给这10个数进行赋值
    for (int i =0; i <10; i++) {
        a[i] = i+10;
    }
    //打印这10个数看看
    for (int i =0; i <10; i++) {
        printf("a[%d] = %d\n",i,a[i]);
    }
    int *p;//定义一个指针
    int b = 100;//定义一个变量
    p = &b;//获取变量单元地址，并且保存到指针p中
    printf("p = %p存储的值为：%d\n",p,*p);//同过p存储的地址，找到b变量单元，取出b变量单元的值
    
    return 0;
}

结果输出：

a[0] = 10
a[1] = 11
a[2] = 12
a[3] = 13
a[4] = 14
a[5] = 15
a[6] = 16
a[7] = 17
a[8] = 18
a[9] = 19
p = 0x7fff5fbff7b4存储的值为：100

函数

许多程序设计语言中，可以将一段经常需要使用的代码封装起来，在需要使用时可以直接调用，这就是程序中的函数。

1.指针函数：

本质是一个函数，返回值为指针的函数。定义：类型 *函数名(参数表);----- int *fun(int a,int b);//可以参数一个[a,b]的数组，返回给调用者。

2.函数指针：

本质是一个指针，用与存放函数地址的指针，从该指针可以找到函数的入口，从而调用函数。定义：类型  (*函数名)(参数列表);----- int (*fun)(int  a,int  b);可以指向相同类型的函数。

函数实例示范：  

#include <stdio.h>
//判断一个数是不是素素，将代码封装成一个函数，等下多次调用
BOOL isSuSu(int n)
{
    if(n<2)
        return false;
    else if(n==2||n==3)
        return true;
    else
    {
        int temp = sqrt(n);
        for (int i = 2; i <=temp; i++) {
            if(n%i==0)
                return false;
        }
        return true;
    }
}

int main()
{
  //我们查找1～30里面的所有素素，我们遍历每一个数，判断他是不是素素
    for (int i = 1; i<=30; i++) {
        if(isSuSu(i))//每个数都要判断一次，直接调用函数判断就可以，这样写代码可读性高
            printf("%3d",i);
    }
    
    return 0;
}

结果输出：

  2  3  5  7 11 13 17 19 23 29

指针函数实例示范：

#include <stdio.h>
#include <stdlib.h>
int *array(int a,int b)//定义了指针函数，本质是一个函数，返回值为指针
{
    int temp = b-a;
    int *number = (int *) malloc(sizeof(int)*(temp));//动态分配内存，创建一个大小为b-a的数组
    for (int i = 0; i <temp; i++) {
        number[i] = b;
        b++;
    }
    return number;
                             
}
int main()
{
    int *n = array(5, 10);//定义一个指针，接收array函数返回的指针
    for (int i = 0 ; i <5; i++) {//打印接受到的值
        printf("n[%d] = %d\n",i,n[i]);
    }
    return 0;
}

结果输出：

n[0] = 10
n[1] = 11
n[2] = 12
n[3] = 13
n[4] = 14

函数指针实例示范：

#include <stdio.h>

typedef int (*Number) (int,int);//声明一个函数指针，是一个指向函数的指针
int Sum(int a,int b)
{
    return a+b;
}
int Min(int a,int b)
{
    return a<b?a:b;
}
int Max(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    Number p1 = Sum;//定义一个函数指针变量p1，p1指向函数Sum；既然是指针，那么保存的应该是地址
    Number p2 = Min;//定义一个函数指针变量p2，p2指向函数Min；保存Min的地址
    Number p3 = Max;//定义一个函数指针变量p3，p3指向函数Max；保存Max的地址
    int a =10,b=15;
    printf("通过p1指针调用Sum函数，p1(%d,%d) = %d\n",a,b,p1(a,b));
    printf("通过p2指针调用Min函数，p2(%d,%d) = %d\n",a,b,p2(a,b));
    printf("通过p3指针调用Max函数，p3(%d,%d) = %d\n",a,b,p3(a,b));
    return 0;
}

结果输出：

通过p1指针调用Sum函数，p1(10,15) = 25
通过p2指针调用Min函数，p2(10,15) = 10
通过p3指针调用Max函数，p3(10,15) = 15

文件操作

文件是指存储在计算机外部存储介质（磁盘、磁带等）上以字节为单位的一组相关数据集合。C语言中对文件进行操作必须首先打开文件，打开文件主要涉及到fopen函数。fopen函数的原型为： FILE* fopen(const char *path,const char *mode)，其中path为文件路径，mode为打开方式。

①对于path，默认为相对路径。若需绝对路径，则注意转义字符'\'，比如有文件test.txt存放在C盘根目录下，则文件路径参数值应为C:\\test.txt。

②对于mode，主要由r，w，a，+，b，t六个字符组合而成。

        r:只读方式，文件必须存在

        w:只写方式，若文件存在，则原有内容会被清除；若文件不存在，则会建立文件

        a:追加方式打开只写文件，只允许进行写操作，若文件存在，则添加的内容放在文件末尾；若不存在，则建立文件

        +:可读可写

        b:以二进制方式打开文件

        t:以文本方式打开文件(默认方式下以文本方式打开文件)

实例示范：

#include <string.h>
int main()
{
    FILE *file = fopen("test.txt","r+w");//本文件采用相对路径存储
    char *name = "My name is Hua_san";
    fwrite(name ,1, strlen(name), file);//将name写入文件，文件不存在，创建文件，文件存在，覆盖原内容
    fputs("\nHua_san\nLi_si", file);//在文件末尾增加内容，原来内容保留
    char str[100];//定义一个读取出来的缓冲
    rewind(file);//将文件内部的位置指针重新指向一个流（数据流/文件）的开头
    while (fgets(str, 100, file)!=NULL)//循环读取文件内容，如果读到文件末尾，读取内容为NULL时候，结束。
    {
        printf("%s",str);//打印出来每次读取的内容
    }
    printf("\n");//最后输出一个回车，不干扰源文件数据
    fclose(file);//关闭文件指针
    return 0;//退出程序
}

结果输出：

My name is Hua_san
Hua_san
Li_si