本科生自学C语言--bilibl比特鹏哥笔记（1）

自己学习C语言的笔记（侵权删

C语言初相识

应用软件 上层

——————————————

操作系统 下层

驱动层 底层（C语言主要用于

硬件

ANSI C：C语言的国际标准

二进制指令-》汇编指令-》B预言-》C语言

注记符 高级语言

ADD

编译：text.c>编译》链接》text.exe

语言为结构化的语言

拆分为

1、顺序结构

2、选择结构

3、循环结构

1、第一个代码

使用vs

1、打开vs

2、创建项目

3、创建源文件

.c 为源文件

.h 为头文件

4、写代码

//C语言代码中有主函数main

//有return 0；

返回0为整数

void main为古老写法

int为整形

//printf为库函数

为别人 制作好的函数需要引用头文件才能够使用

//std__标准

-i input

-o output

//main函数是程序的入口

//main函数有且只有一个

//两个main函数嵌套没必要

2、数据类型

类型用途申请不同空间，用于不同用途。

char //字符型3数据类型

int //整型数据类型

long //长整型

longlong //更长的整型

short //短整型

double //双精度浮点类型

float //单精度浮点

//每一种整型的大小多少

int main()
{
printf("%zu",sizeof(char));          
printf("%zu",sizeof(int));
printf("%zu",sizeof(long));
printf("%zu",sizeof(short));
printf("%zu",sizeof(double));
printf("%zu",sizeof(float));
printf("%zu",sizeof(long long));
}

1 4 4 2 8 4 8

计算机的单位

bit-最小单位

byte字节

kb

mb

gb

tb

pb

计算机中二进制中一个0或1代表一个比特位

连续的八个比特位为一个byte（字节

sizeof显示的是字节

一字节等于8比特

连续的1024个byte为1kb（kb-pb后运算都是如此）

C语言规定：sizeof(long) 》= sizeof(int)；

精度区别float与double

3、变量和常量

3、1变量

定义变量

局部变量 大括号里面定义的变量

全局变量 大括号外面定义的变量

全局变量和局部表变量相同时，遵从局部变量为先

变量的使用

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    int num = 0;
    int sum=0;
    int num2 = 1;//初始化
    scanf("%d,%d", &num, &num2);
    sum = num + num2;
    printf("%d", sum);
    return 0;
}

ps: scanf_s非标准C语言的使用，不建议使用 仅仅适用于vs;

变量可以什么时候用什么时候调用

//变量作用率

//全局变量作用率

到处都可以使用

哪里可以使用那里就是作用率

一个全局变量 //如果要从外部引用变量需要声明

extern int a;

//变量生命周期

生命周期：变量的适用范围

3、2常量

描述不变的量

·字面常量

30

3.14

‘w’ //字符常量

“abc”//字符串常量

·const修饰的常量

int main()
{
const int a=10;
//const 修饰的常变量无法直接被修改
//const 修饰的a本质是变量但是不能被修改，有常量的属性
a=20;
printf("%d",a);
}
//以下代码可以证明
int main()
{
    const int n = 10;
    int arr[n] = {0};
    return 0;
}
//因为报错所以即认为const修饰的啊a本质是变量

·define定义的标识符常量

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define MAX 100
#define STR "abcdef"
int main()
{
    printf("%d\n", MAX);
    int  a = MAX;
    printf("%d\n", a);
    printf("%s\n", STR);
}

·枚举常量

//枚举即一一列举

enum color
{
//枚举常量 这里就是符号而已不会开辟空间
//列出可能取值
RED;
GREEN;
BLUE;
};
int main()
{
    int num = 10;
    enum color c = RED;//变量本质向内存申请一段空间
    RED=20;//err
    return 0;
}

4、字符串+转义字符+注释

4、1 字符串

//cahr 字符类型 ​ //'w'字符常量 ​ //char ch="w"//字符串 ​ //双引号引起来的为字符串 ​ //C语言中没有字符串类型

//字符串的结束标志是\0

"hello\n"

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    char arr1[ ] = "abcdef";
    char arr2[ ] = { 'a','b','c','d','e'};
    printf("%s\n", arr1);
    printf("%s\n", arr2);
​
    return 0;
}

结果：abcdef abcde烫烫烫烫烫蘟bcdef

D:\yingyong\VS\xiangmu\TEXT\Debug\TEXT.exe (进程 23548)已退出，代码为 0。 要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。 按任意键关闭此窗口. . .

·字符串结束/0的重要性

/// 这里是指\0为 这个字符结束了

arr2没有/0打印时需要打到/0才结束打印

#define _CRT_SECURE_NO_WARNINGS
#include<string.h>
#include <stdio.h>
int main()
{
    char arr1[ ] = "abcdef";
    char arr2[ ] = { 'a','b','c','d','e'};
    //printf("%s\n", arr1);
    //printf("%s\n", arr2);;
    printf("%d\n", strlen("abc"));
    printf("%d\n", strlen(arr1));
    printf("%d\n", strlen(arr2));
    return 0;
}

结果：

3 6 22

D:\yingyong\VS\xiangmu\TEXT\Debug\TEXT.exe (进程 27856)已退出，代码为 0。 按任意键关闭此窗口. . .

///这里如果在arr2后添加/0，那结果将于arr1相同。

4、2 转义字符

转变字符的意思

n->\n(换行)

字符串中0->\0(字符串结束标志)

%d-打印整型

%c-打印字符

%s-打印字符串

%f-打印float

%lf打印double

%zu-打印sizeof

转义字符	释义
\?	书写多个连续问号时使用，防止被解析成三字母词
\'	用于表示字符常量 printf('\'');(打印一个单引号)
\''	用于表示字符常量 printf('\''');(打印两个单引号)
\\	转译\0为\\0 路径打印 printf("abc//0drf");
\a	警告字符 蜂鸣
\b	退格符
\f	进纸符
\n	换行符
\r	回车
\t	水平制表符
\v	垂直制表符
\ddd	1-3个8进制的数字 如、130X printf("%c\n",'\130');打印出来的数字为X 为ascll码对应的十进制数字88
\xdd	两个16进制的数字 \x30 0 printf("\x60");打印出来的ascll码对应的值为ascll码对应的值为十进制数字

4、3 注释

解释或者删去 （注解 解释）

C语言注释

/*
需要注释内容
*/

c++注释

//注释内容

5、选择语句和循环语句

c语言实现选择

1、if else语句

2、switch语句

C语言实现循环

1、for循环

2、while循环

3.do while循环

6、函数

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 int add(int a, int b)//int为返回类型
     //函数名  函数参数
     //函数体
{
    int s;
    s = a + b;
    return s;
}
int main()
{
    int a=0;
    int b=0;
    scanf("%d,%d",&a,&b);
    int sum=add(a, b);
    printf("%d\n", sum);
    return 0;
}

7、数组

一组相同类型元素集合

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
                //  0 1 2 3 4 5 6 7 8 9 数组的下标
               //下标为0开始
    printf("%d\n", arr[8]);
    int i = 0;
    while (i < 10)//用循环来访问下标
    {
        printf("%d ", arr[i]);
        i=i+1;
    }
    return 0;
}

插入一段作业讲解：

1、内置的 char short long longlong ......

非内置 struct(结构体)

2、局部变量作用率：局部变量所在局部范围内

3、局部变量和全局变量同时存在时，局部变量优先

·OJ:在线判题

· 1、IO型：需要写输入输出

· 2、接口型：写函数

4、字符的结束标志是\0

5、数组下标由0开始

‘0’的ascll码为48

‘\0’的ascll码值为0

6、数组会根据初始化内容进行一个大小判断

7、strlen(arr[1]);

//arrr[1]若为{"1","1","1"}则为未知

数组中不完全初始化，后全为0；

在数组中c99标准下可以使用

int m=0;

int arr[m];

//vs中不支持c99的变长数组；

8、操作符

C语言是非常灵活的

算数：+ - * / %

/商

%取余数

//除号为整数进行整数，浮点数（有一位即为浮点数运算结果不同

· 移位操作符：<< >>涉及二进制

·位操作符：& ^ |

·赋值操作符：= += -=

·算数：+ - * / %

/商

%取余数

//除号为整数进行整数，浮点数（有一位即为浮点数运算结果不同

· 移位操作符：<< >>涉及二进制

·位操作符：& ^ |

·赋值操作符：= += -=

//int a=0;//初始化

//a=20//赋值

a+=3//a=a+3;

a-=3//a=a-;

单目操作符-只有一个操作数

//a+b 双目操作符

//C语言中0表示为假；非零表示为真

！ 逻辑反操作

-- 负号即为负值

++ 为正值

sizeof() 计算类型和数值的字节大小

~ 对于一个二进制按位取反

-- 前置、后置

++ 前置 后置

后置：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    int a = 10;
    //int b = a++;//后置++，先使用后++
    int b=a; a=a+1;
    printf("%d\n", b);//10
    printf("%d\n", a);//11
    return 0;
}

前置：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
    int a = 10;
    //int b = a++;//后置++，先使用后++
    int b = ++a;
    printf("%d\n", b);//11
    printf("%d\n", a);//11
    return 0;
}

*间接访问操作符(解引用操作符)

( 类型)强制类型转换

//3.14子面浮点数，默认为double 类型

int a=(int)3.14;
printf("%d\n",a);//3

关系操作符：>= <= == ！=（不等于

int a=10;
if(a=3)//这里是把a赋值给3
//a==3才是判断a的值(测试)

逻辑操作符： &&（并且 ||（或者

条件操作符：exp1? exp2：exp3

exp分别为不同的条件

//三目操作符3

exp1	exp2	exp3
真	对	错
假	错	对

//对的结果为总的表达式结果

·逗号表达式

exp1,exp2,exp3,exp4…………expn

//从左到右依次计算，整个表达式的结果为最后一个表达式的结果

·下标引用[ ]

arr[3]

·函数调用

hanshu(x,y)//这里的小括号就是函数调用操作,x,y都是函数的操作数

· · 点操作符

· >> 操作符

9、常见关键字

//定义变量名不能和关键字冲突

auto 自动 //所有局促变量都是auto类型的，所以省略掉

break 跳出循环(while do while for )

case switch case

char (内置类型)

const (修饰 变量)

continue(用于循环)

defult(swich)

do(循环)

doube

else（分支语句

enum（自定义的类型）枚举

extern（声明外部符号

float

for

goto（跳转语句

if

int

long

register（寄存器

return（返回值

short

signed（有符号

sizeof（计算大小的

static(静态的)

struct（结构体)

switch

typedef(类型重命名)

union（联合体）

unsigned（无符号

void 无 函数参数（无返回值的函数）

volatile

while

变量的命名

1、有意义

2、由字母数字下划线组成（不能有数字开头

9、2关键字typedef

//类型定义 类型重命名

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
typedef unsigned int uint;//这里就等价的意思
int main()
{
    unsigned int num = 0;
    return 0;
}

9、3关键字static

//静态

1、修饰局部变量-静态局部变量

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void text()
{
    int a = 1;
    a++;
    printf("%d\t", a);
}
int main()
{
    int i = 0;
    while (i < 10)
    {
        text();
        i++;
    }
    return 0;
}

//2 2 2 2 2 2 2 2 2 2 D:\yingyong\VS\xiangmu\TEXT\Debug\TEXT.exe (进程 31448)已退出，代码为 0。 按任意键关闭此窗口. . .

//有static修饰

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void text()
{
     static int a = 1;
    a++;
    printf("%d\t", a);
}
int main()
{
    int i = 0;
    while (i < 10)
    {
        text();
        i++;
    }
    return 0;
}

//2 3 4 5 6 7 8 9 10 11 D:\yingyong\VS\xiangmu\TEXT\Debug\TEXT.exe (进程 27016)已退出，代码为 0。 按任意键关闭此窗口. . .

//这里static修饰局部变量时，局部变量出了作用域不被销毁，改变了变量的存储位置

内存的区域： 栈区：存放局部变量（进入创建，出去销毁

----------------------------------------

堆区：

----------------------------------------

静态区：程序不存在才销毁；static改变了存储位置

使其生命周期变长

---

2、修饰全局变量-静态全局变量（改变链接属性）

使用作用域变小，也储存在静态区域，可用于保护

static 修饰的全局变量 全局变量的外部链接属性变成了内部链接属性

其他源文件就不能再使用该变量

编译->链接

3、修饰函数-静态函数（改变外部链接属性）

函数具有外部连接属性

使用static之后全部使用

9、4关键词register

//寄存器

//电脑的存储设备：

寄存器（集成到cpu

高速缓存

内存

硬盘

//由上到下，速度慢，造价低

cpu:内存处理器

register int num =3;
//建议存放在寄存器中，速度快，还是编译器决定；

9、5关键词define

既可以给变量赋值也可以直接打印它的值

1、定义标识符常量

#define NUM = 10

2、define 定义宏

//其实就是替换

#include <stdio.h>
​
extern int add(int x, int y);
#define ADD(x,y) ((x)+(y))
//     宏名（参数）这里参数是无类型的 （宏体）
int main()
{
    int a = 10;
    int b = 20;
    int c = ADD(a, b);
    printf("%d", c);
    return 0;
}

10、指针//就是用来存放地址的

内存：计算机的程序运行都在内存中

使用内存内空间时，如何使用：每一个单元都有自己的地址

内存会划分成多个内存单元（一个内存单元为一个byte（字节

每个内存单元都有一个编号

地址线：1/0

如果有32根地址序列：管理2^32个字节

2^32/1024 byte=4194,304kb=4096mb=4gb

//这里内存打印使用16进制

int main()
{
    int a = 10;//向内存申请四个字节
    printf("%p\n", &a);
    //&a;//取地址操作符
    int* p = &a;
    //储存地址 p就是指针变量；
    return 0;
}

内存单元>地址>地址也被称为指针

//存放指针（地址）的变量就叫做指针变量

//int * 中的* 说明p是指针变量，int说明p指向的对象a为int类型

//*p 解引用操作符，意思就是通过p存放的地址，找到p指向的对象

int main()
{
    int a = 10;//向内存申请四个字节
    printf("%p\n", &a);
    //&a;//取地址操作符
    int* p = &a;
    //储存地址 p就是指针变量；
    *p = 20;
    printf("%d", a);
    return 0;
}

//不管是什么类型的指针都要创建指针变量

//指针变量的大小取决于一个地址存放的时候需要多大空间

//32位机器上的地址：32bit位-4byte（字节

//64位机器上的地址：64比特位-8byte（字节

指针变量的大小

11、结构体

//复杂对象的自定义类型》把单一类型整合在一起

//结构体对象.成员名

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
struct Stu
{
    //结构体成员
    char name[20];
    int age;
    char sex[10];
    char tele[10];
​
};
int main()
{
    struct Stu = { "zhangsan",20,"nan","12345678910" };
    printf("%s %d %s %s\n",s.name,s.age,s.sex,s.tel );
    return 0;
}

//括号类型

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
struct Stu
{
    //结构体成员
    char name[20];
    int age;
    char sex[10];
    char tele[12];
​
};
void print(struct Stu* ps)
{
    printf("%s,%d,%s,%s", (*ps).age, (*ps).name, (*ps).sex, (*ps).tele);
}
int main()
{
    struct Stu s = { "zhangsan",20,"nan","12345678910" };
    print(&s);
    return 0;
}

//结构体指针变量->成员名

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
struct Stu
{
    //结构体成员
    char name[20];
    int age;
    char sex[10];
    char tele[12];
​
};
void print(struct Stu* ps)
{
    printf("%s,%d,%s,%s", ps->name,ps->age,ps->sex,ps->tele);
}
int main()
{
    struct Stu s = { "zhangsan",20,"nan","12345678910" };
    print(&s);
    return 0;
}

插入一段作业讲解：

1、关键字不能自己创建

2、switch中不包括continue

3、define不是关键字