自学c语言

C 语言是一种通用的、面向过程式的计算机程序设计语言。

当前最新的 C 语言标准为 C18

前期准备

C 编译器  写在源文件中的源代码是人类可读的源。它需要"编译"，转为机器语言，这样 CPU 可以按给定指令执行程序。(.c-->.exe)

下载Dev-C++ 图标长这样哦别下载错了

编写代码

1 #include <stdio.h>
2 int main(){
3     printf("Hello World!");
4     //system("pause"); //暂停程序 不会一闪而过
5     return 0;
6 }     

保存为 hello.c 文件

进入代码目录

win+r cmd 打开命令提示符 cd到程序目录执行编译  gcc hello.c   会生成hello.exe 文件

想用vs code开发C语言点击这里

数据类型　　

1 基本类型：
　　它们是算术类型，包括两种类型：整数类型和浮点类型。
2 枚举类型：
　　它们也是算术类型，被用来定义在程序中只能赋予其一定的离散整数值的变量。
3 void 类型：
　　类型说明符 void 表明没有可用的值。
4 派生类型：
　　它们包括：指针类型、数组类型、结构类型、共用体类型和函数类型。

存储类

存储类定义 C 程序中变量/函数的可用范围和生命周期。说明符应放置类型之前

　　1.auto 

　　　　局部变量的默认存储类, 规定变量只能在函数内部使用

　　2.register 

　　　　定义存储在cpu寄存器中而不是 RAM(内存) 中的局部变量

　　3.static 

　　　　局部变量时进入和离开作用域不会进行创建和销毁

　　　　全局变量时会使变量的作用域限制在声明它的文件内

　　4.extern 

　　　　在一个文件中声明一个全局变量或函数

#include <stdio.h>
// 函数外定义变量 x 和 y
int x;
int y;
int add(){
    // 函数内声明变量 x 和 y 为外部变量
    extern int x;
    extern int y;
    // 给外部变量（全局变量）x 和 y 赋值
    x = 4;
    y = 2;
    return x+y;
}
int main()
{
    int result;
    result = add();
    //文件编码UTF8时中文乱码 应设为GBK
    printf("result 为：%d=%d+%d",result,x,y);
    return 0;
}

运算符

　　7个 算术运算符 关系运算 符逻辑运算 符位运算符 赋值运算符 杂项运算符

#include <stdio.h>
//不用第三个变量 A^B，异或交换值
// 这种利用位运算的交换方法只适用于整型变量，不能用于浮点型变量
int main()
{
    int A = 60;//二进制 0011 1100
    int B = 13;//二进制 0000 1101
    A = A^B;//A=0011 0001
    B = A^B;//B=0011 1100
    A = A^B;//A=0000 1101
    // A^=B^=A^=B; //简写
    printf("原A=60 B=13，现A=%d,B=%d",A,B);
    return 0;
}

enum(枚举)

　　一种基本数据类型  enum　枚举名　{枚举元素1,枚举元素2,……};

　　第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。

　　可以把第一个枚举成员的值定义为 1，第二个就为 2，以此类推　　

#include <stdio.h>
#include <stdlib.h>
// 枚举类型
int main()
{
    enum Colors { red=1, blue, green };
    enum Colors color;
    printf("%d是红色,%d是蓝色,%d是绿色,请输入数字选择喜欢的颜色",red,blue,green);
    scanf("%u",&color);
    switch(color){
        case red:
         printf("你喜欢红色\n");
         break;
        case blue:
         printf("你喜欢蓝色\n");
         break;
        case green:
         printf("你喜欢绿色\n");
         break;
        default:
         printf("没有你喜欢的颜色\n");
    }
    system("pause");
}

C指针

　　指针指向内存地址的变量，指针变量存放的是普通变量的内存地址

int  var = 20;   /* 实际变量的声明 */
int  *ip;        /* 指针变量的声明 */
ip = &var;  /* 在指针变量中存储 var 的地址 */

*和&都是一元运算符

&var 返回的是变量var在内存中的地址

*ip 返回的是指向的变量var(20)的值

普通指针和数组指针：

#include <stdio.h>
// 指针 &a=获取变量地址 *a=指针变量
int main()
{
    int var = 12;
    int *ip = NULL;

    ip = &var;

    printf("var 变量地址：%p \n",&var);
    printf("ip 变量存储的地址：%p \n",ip);
    printf("ip 变量地址：%p \n",&ip);
    printf("*ip 变量的值：%d \n",*ip);

    system("pause");

    // int var = {
    //     地址：000000000062FE14
    //     值：12
    // }
    // &var = var地址

    // int *ip = {
    //     值：NULL
    //     地址：000000000062FE10
    // }

    // ip = &var
    // *ip = var值 = 12
    // ip = &var = var地址

    //指针与数组
    const int MAX = 3;

    int arr[] = {10,100,200};
    int i,*ptr[MAX];
    for(i=0;i<MAX;i++){
        ptr[i] = &arr[i];
    }
    for(i=0;i<MAX;i++){
        printf("var[%d] 地址：%p || %p,值：%d \n",i,ptr[i],&arr[i],*ptr[i]);
    }

    system("pause");

    return 0;
}

函数指针：

#include <stdio.h>
// 函数指针
int max(int x,int y){
    return x>y?x:y;
}
int main()
{
    int (*p)(int,int) = &max; //&可以忽略
    int a,b,c,d;
    printf("请输入3个数字：");
    scanf("%d %d %d",&a,&b,&c);
    d = p(p(a,b),c);
    printf("最大数为：%d \n",d);

    system("pause");
}

字符串

　　C 语言中，字符串实际上是使用空字符 \0 结尾的一维字符数组。\0 是用于标记字符串的结束

#include <stdio.h>
#include <string.h>
// 字符串
int main()
{
    char arr[6] = {'h','e','l','l','o','\0'};
    printf("%s \n",arr);

    char str[] = "hello";
    printf("%s \n",str);

    char str1[] = "字符串1",str2[] = "字符串2",str3[5];

    // 操作字符串的函数 需要引入<string.h>标准库
    strcpy(str3,str1);//将str1复制到str3
    printf("str3=%s \n",str3);

    strcat(str3,str2);//将字符串str2链接到str3末尾
    printf("str3=%s \n",str3);

    int len = strlen(str3);//返回str3的长度
    printf("str3的长度为%d \n",len);

    int cmp = strcmp(str3,str1);//如果 str1,str3相同的，返回 0；str1<str3 返回小于 0；str1>str3 返回大于 0。
    printf("cmp=%d \n",cmp);

    char *chr,ch='1';//ch为一个字符
    // str3="字符串1字符串2"
    chr = strchr(str3,ch);//返回一个指针 字符ch 第一次出现的位置
    printf("chr=%s \n",chr);//返回 "1字符串2"

    char s[2] = "串";//汉字一般占2个字节（系统或编码方式不一样可能占3个字节）
    char *ss = strstr(str3,s);//返回一个指针，指向字符串 str3字符串 s 的第一次出现的位置
    printf("\'串\'出现在str3的位置为：%s \n",ss);

    system("pause");
}

结构体

　　用struct定义，自定义数据类型用来存储不同类型的数据成员

struct 结构名 {
    数据类型1;
    数据类型2;
    ...
} 变量1,变量2 ... ;

结构体变量的初始化，访问结构成员，结构作为函数参数，指向结构的指针 例子：

#include <stdio.h>
#include <string.h>
// 结构体
struct Books//生成结构体Books
{
    char title[50];
    char author[50];
    char subject[50];
    int book_id;
} book;//声明结构变量book

void printBook(struct Books book);
void setBook(struct Books *b,char title[],char author[],char subject[],int book_id);
int main()
{
    //初始化book变量
    strcpy(book.title,"百科全书");
    strcpy(book.author,"小明");
    strcpy(book.subject,"啥东西都有");
    book.book_id = 1;

    struct Books book1;//声明结构变量 book1

    setBook(&book1,"十万个为啥","小红","啥东西都有解释",2);    

    printBook(book);
    printf("\n");
    printBook(book1);

    system("pause");
}

//通过指向结构变量的指针 "->"访问并初始化结构变量
void setBook(struct Books *b,char title[],char author[],char subject[],int book_id)
{
    strcpy(b->title,title);
    strcpy(b->author,author);
    strcpy(b->subject,subject);
    b->book_id = book_id;
}

//结构作为参数
void printBook(struct Books book)
{
    printf("标题:%s \n",book.title);//book.title 访问结构成员
    printf("作者:%s \n",book.author);
    printf("主题:%s \n",book.subject);
    printf("ID:%d \n",book.book_id);
}

共用体

　　可以在相同的内存位置定义个带有多成员的共用体，只能有一个成员带有值

union 共用体名 {
    数据类型1;
    数据类型2;
    ...
} 变量1,变量2 ... ;

使用例子：

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

//共用体
int main()
{
    // 声明共用体
    union Data{
        int i;
        float f;
        char c[10];
    };

    // 定义共用体 变量
    union Data data;

    // 初始化共用体 数据成员
    data.i = 123;
    printf("i:%d \n",data.i);//正常输出 123

    data.f = 20.3;
    printf("f:%f \n",data.f);//正常输出 20.299999 

    strcpy(data.c,"1234567890");
    printf("c[10]:%s \n",data.c);//正常输出1234567890

    // 访问共用体数据成员
    printf("\ni:%d \n",data.i);//i内存位置被c[10]替换输出数据有问题 875770417
    printf("f:%f \n",data.f);//f内存位置被c[10]替换输出数据有问题 0.000000
    printf("c[10]:%s \n",data.c);//内存位置被替换为 正常输出1234567890

    system("pause");
}

位域

　　1000 1000 这是8位(bit) = 1字节(byte/B)　　

　　有些信息存储时，不需要占一个完整的字节(8位)，而只需占几个或1个二进制位(如：0000 0001 只需要最后1位)

　　所以c语言提供了一种数据结构，称为"位域"或"位段，可以设置变量用多少位

struct 位域结构名
{
 //type 只能为int(整型)，unsigned int(无符号整型)，signed int(有符号整型) 三种类型
 type [member_name] : width ;
 type [member_name] : width ;
 ...
};

这种结构在内存中占8个字节

但是我们a和b可能只存储 0或1 只需要1位，多余的空间就会浪费。 所以就需要用到位域

使用位域后，这个结构体就占用4字节(32位)。每个变量占1位 ，还剩余30位，可以分配给剩余结构体中变量

#include <stdio.h>

// 位域
int main()
{
    // unsigned int类型默认是2字节或4字节
    struct
    {
        unsigned int a:1;
        unsigned int b:1;
    } status;
    struct
    {
        unsigned int a;
        unsigned int b;
    } status1;

    printf("status size:%dB \n",sizeof(status));//status size:4B
    printf("status1 size:%dB \n",sizeof(status1));//status size:8B

    // status.a = 2;//因为a只分配了1位 2等于二进制0010 所以会报错
    status.a = 1;//1等于二进制0001
    printf("status.a:%d \n",status.a);

    system("pause");
}

typedef 和 #define

typedef:为类型取一个新的名字

#define:为各种数据类型定义别名

不同点

• typedef 仅限于为类型定义符号名称，#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。
• typedef 是由编译器执行解释的，#define 语句是由预编译器进行处理的。

#include <stdio.h>
// typedef 关键字为类型取一个新的名字
int main()
{
    typedef unsigned int BYTE;//定义unsigned int别名为 BYTE
    BYTE A;
    unsigned int a;

    #define zx int //定义int别名为zx
    #define PI 3.14 //定义常量
    zx b;

    A = 2;
    a = A;
    b = a;

    printf("%d == %d \n",A,a);
    printf("%d,PI=%f\n",b,PI);
    system("pause");
}

输入输出

C 语言把所有的设备都当作文件。所以设备（比如显示器）被处理的方式与文件相同。

#include <stdio.h>

// 输入输出
int main()
{
    int a;
    char s[50];

    // printf("Enter a value:");
    // scanf("%s",&s);//输入 从标准输入流 stdin 读取输入
    // printf("value = %s \n",s);//输出 写入到标准输出流 stdout 

    printf("Enter a char:");
    a = getchar();//屏幕读取下一个可用的字符，并把它返回为一个整数
    printf("you entered char:\n");
    putchar(a);//把字符输出到屏幕上，并返回相同的字符。
    printf("\n");

    // char str[100];
    // printf("Enter a string: \n");
    // gets(str);//从 stdin 读取一行到 s 所指向的缓冲区，直到一个终止符或 EOF
    // printf( "\nYou entered: ");
    // puts(str);//字符串 s 和一个尾随的换行符写入到 stdout

    system("pause");
}

文件读写

不管是文本文件还是二进制文件，都是代表了一系列的字节。

打开文件  FILE *fopen( const char * filename, const char * mode );

filename 是字符串，文件名， mode 是下列值中的一个

r	打开一个已有的文本文件，允许读取文件。
w	打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。如果文件存在，则该会被截断为零长度，重新写入。
a	打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。
r+	打开一个文本文件，允许读写文件。
w+	打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。
a+	打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。

处理二进制文件：

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

#include <stdio.h>

//文件的读写
int main()
{
    FILE *fp = NULL;

    // 写入文件
    fp = fopen("./13.txt","w");// "w" 打开一个文本文件，允许写入文件。如果文件不存在会创建一个新文件
    fputc(2,fp);    //把一个字符写入到流中
    fprintf(fp,"这是 创建的文件\n");    //把一个字符串写入到文件中
    fputs("这是 fputs 输入的内容\n",fp);    //把字符串 s 写入到 fp 所指向的输出流中 成功返回一个非负值，发生错误，返回 EOF
    fclose(fp);//关闭文件

    char buff[255];

    // 读取文件
    fp = fopen("./13.txt","r");//打开一个已有的文本文件，允许读取文件
    char c = fgetc((FILE *)fp);//从 fp 所指向的输入文件中读取一个字符
    printf("0:%d \n",c);

    fscanf(fp,"%s",buff);//读取字符串，但是在遇到第一个空格和换行符时，它会停止读取
    printf("1:%s \n",buff);

    fgets(buff,255,(FILE *)fp);//从 fp 所指向的输入流中读取 n - 1 个字符
    printf("2:%s \n",buff);

    fgets(buff,255,(FILE *)fp);
    printf("3:%s \n",buff);

    // 0:2
    // 1:这是
    // 2: 创建的文件

    // 3:这是 fputs 输入的内容

    fclose(fp);

    return 0;
}

预处理器

相当于文本替换工具，会在编译器实际编译之前执行

14.c

#include <stdio.h>

// 预处理器
#include "14.h" //包含一个源代码文件
int main()
{
    //定义宏
    #define PI 3.14 //把所有 PI 替换成3.14
    #define uInt unsigned int //把所有 uInt 替换成 unsigned int
    uInt a = 222;
    #undef PI //取消已定义的宏
    #define PI 3.1415926 //重新定义PI
    printf("%f,%d \n",PI,a);

    myFun();

    #ifndef MESSAGE //如果宏没有定义，则返回真
        #define MESSAGE "success"
    #endif
    printf("MESSAGE = %s \n",MESSAGE);

    return 0;
}
void myFun()
{
    printf("This is 14.h a=%d,arr=%s \n",a,arr);
}

14.h

int a = 4;
char arr[] = "hello word";
void myFun();

头文件

头文件是扩展名为 .h 的文件，包含了函数声明，宏定义，变量。被多个源文件中引用共享。有两种类型的头文件：程序员编写的，编译器自带。

#include <file.h>
#include "file.h"

强制类型转换

强制类型转换是把变量从一种类型转换为另一种数据类型

#include <stdio.h>

// 强制类型转换
int main()
{
    int a = 6;
    char b = 'b';
    float c = a + b;//a 强制转换为 6.000000 b 强制转换为 98（'b'的ASCII=98）
    printf("a=%d+b=%c,c=%f \n",a,b,c);
    system("pause");
}

内存管理

C分配和管理函数。这些函数在 <stdlib.h>头文件

void *calloc(int num, int size);//分配了 num*size 个字节长度的内存，每个字节值都初始化为0

void free(void *address);//释放 address 所指动态分配的内存空间

void *malloc(int num);//堆区分配指定大小的内存空间,不会初始化值

void *realloc(void *address, int newsize);//内存扩展到 newsize

使用malloc分配内存

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

int main()
{
    char name[100];
    char *desc;

    strcpy(name,"weilian tom");

    desc = (char *)malloc(200 * sizeof(char));//动态分配内存 它的值不会初始化
    printf("%p \n",desc);

    if(desc == NULL){
        fprintf(stderr,"Error - unable to allocate required memory\n");
    }else{
        strcpy(desc,"weilian tom is a famous professional clown actor \n");
    }
    // free(desc);//释放内存
    printf("name:%s\ndesc:%s \n",name,desc);

    system("pause");

}

命令行参数

执行程序时，在命令行传值给程序

传入的参数是由main函数处理的，argc是参数个数 argv是参数列表

#include <stdio.h>

// 命令行参数
int main(int argc, char *argv[])
{
    printf("有%d个参数 \n",argc);
    int i;
    for(i=0;i<argc;i++)
    {
        printf("第%d个参数是：%s \n",i+1,argv[i]);
    }
}

执行程序后 第一个参数总是程序名

时间格式化和定时器函数

#include <stdio.h>
#include <time.h>

// 标准库 time.h
void delayed(void (*fun)());
void parseTime();
int main()
{
    //time_t这是一个适合存储日历时间类型
    time_t curtime;//声明time_t格式变量
    printf("%d",curtime);

    time(&curtime);//计算当前日历时间，并把它编码成 time_t 格式

    printf("%s",ctime(&curtime));//ctime 返回表示当地时间的字符串

    delayed(&parseTime);

    return 0;
}

// 获取当前时间并格式化
void parseTime(){
    time_t ct;
    time(&ct);
    // 格式化时间
    struct tm *nowTime = localtime(&ct);// 返回本地时区的值来填充 tm 结构体

    //年tm_year 月tm_mon 日tm_mday 时tm_hour 分tm_min 秒tm_sec
    printf("%d-%d-%d %d:%d:%d \n",nowTime->tm_year+1900,nowTime->tm_mon+1,nowTime->tm_mday,nowTime->tm_hour,nowTime->tm_min,nowTime->tm_sec);
}
// 延时函数
void delayed(void (*fun)()){
    while (1)
    {
        static int t1,t2;
        if(t2-t1 > 1000){
            fun();
            t1 = t2;
        }
        t2 = clock();//返回程序执行起到现在使用的时间
    }
}

搜索

复制