C语言学习笔记

计算机组成原理

计算机的组成

五个设备：

输入设备： 键盘,鼠标,麦克风，写字板....

输出设备： 显示器 打印机 耳机....

主存储器： 内存条 4G 8G 16G

计算器： 计算机里面负责计算，处理数据的。

控制器：控制整个程序的运行计算

2.CPU的组成:

内存单位：

程序员节：10月24号。电！  高电平 1  低电平 0

bit          位 存放一个 1或者0

Byte        字节        1B  =  8b

KB                        1KB = 1024B            2^10

MB         1MB = 1024KB                 2^10

GB          1GB = 1024MB    2^10

TB          1TB = 1024GB     2^10

进制

进制

十进制数：人容易理解！！

由0-9组成的。逢10进1. 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

二进制数： 计算机更容易理解！！

由0-1组成，逢2进1

八进制：

由0-7组成，逢8进1

0000 0001 0002 0003 0004 0005 0006 0007 0010 0011 0012 0013 0014 0015 0016 0017 0020

十六进制：

由0 1 2 3 4 5 6 7 8 9 a b c d e f组成的,逢16进1

0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000a 000b 000c 000d 000e 000f 0010 0011.... 001f 0020

进制之间 怎么转换？

十进制转其他进制：辗转相除，逆序取余。

其他进制转十进制：位权相加

二进制      十进制

1                        1     2^0

10                        2          2^1

100                        4          2^2

1000                8     2^3

10000                16    2^4

100000                32  

1000000                64

10000000        128

100000000        256

1000000000  512

二进制转8进制 拆3位

二进制转16进制 拆4位

在代码中区分各种进制

0x208   16进制

01010        8进制

520     10进制

原码、反码、补码。

一些概念

计算机只会做加法。

内存中一定只能存1或者0

机器数：一个10进制的数 转换成2进制  机器数。520:   1000001000 

符号位：以8位为例，为了能够表示负数，最高位当做符号位 0正数 1负数

原码：具有符号位的机器数。

1原:         0000 0001

-1原:        1000 0001

2原:        0000 0010

-2原:        1000 0010

如果假设计算机的内存中存放是一个数的原码。

1-1=-2 错误的计算。

反码：

正数的反码是原码本身。

负数的反码是符号位不变，其余个位取反。

1原:         0000 0001   反：0000 0001

-1原:        1000 0001   反：1111 1110

2原:        0000 0010   反：0000 0010

-2原:        1000 0010   反：1111 1101

如果假设计算机的内存中存放是一个数的反码。

2-2= -0 不太准确。

补码：

正数的补码还是原码.

负数的补码是反码+1

1原:         0000 0001   反：0000 0001  补：0000 0001

-1原:        1000 0001   反：1111 1110  补：1111 1111

2原:        0000 0010   反：0000 0010  补：0000 0010

-2原:        1000 0010   反：1111 1101  补：1111 1110

如果假设计算机的内存中存放是一个数的补码。

1-1= 0

2-2= 0

结论：计算机的内存里面存放的是数的补码。

编译器的使用

创建项目：

文件--- 新建项目 ---win32控制台应用程序

设置好项目名称，项目保存的盘符路径，下一步

空项目选中，取消安全检查。(VS是C++的编译器)  确定

创建文件：

源文件---添加新建项---C++文件

设置好文件名  .c  .cpp 添加。

VS布局：

各种窗口 都在视图里面。

这些窗口都是课题拖动。根据自己的习惯，自己更改。

代码：第一个C程序：

全英文 字母 括号 分号

注释：不是代码的一部分。只是代码的注释说明。

/*    

多行注释

*/ 

//  单行注释

主函数

int main()

{

//语句

}

C代码最小单位：语句。以分号结束。

 

编译运行：

鼠标  调试--开始执行(不调试)

键盘  ctrl+f5

 

基本数据类型

标识符

字母、数字、下划线组成。 2jiuxia2

不能用数字开头 

C语言里面标识符严格区分大小写

jiuxia  Jiuxia  jIuxia  JIUXIA

不能是C语言保留的关键字 32个

试一试：

while                   不是标识符   关键字

for                     不是标识符   关键字

jiuxia                   是

ye_2                   是

number1                是

2Number         不是标识符 不能以数字开头

student_6         是

___1                是

常量和变量

常量：不会变化的数据。

数值常量： 1 2 3 4 5 6 7 555 380 12.5 32.6 -8 -9

字符常量：'a'  'b'  '0'  '8'  '1'  '*'  'h'

字符串常量： 后面再讲

宏定义：#define

在程序中定义一个宏定义 #define PI 3.1415926548,在接下来的代码中凡是用到PI的地方全部都会替换成3.1415926548

宏定义不是一个语句，不需要分号结束.

宏定义是替换的过程，在预处理阶段完成。什么叫做预处理？往下讲。

变量：可以变化的量

人数

年龄

长度

....

整形 int

整形int

整形常量：1 2 3 4 5 6 7 8 9 0 -1 - 2 -138 -520 666

整形变量:         4B  32bit  -21亿 ---- +21亿

a)定义：int 标识符;

int age;   //定义了一个整形的变量--年龄

b)内幕：实际上，计算机去开辟4B内存，给这段内存取一个名字，age.

c)取值范围：4个字节   -21亿 ---- +21亿

短整型short int  直接写short 

a)定义：short 标识符;

short a;   //定义了一个短整形的变量 a

b)内幕：实际上，计算机去开辟2B内存，给这段内存取一个名字，a.

c)取值范围：2个字节   -32700~~+32700

长整形long int 直接写long

a)定义：long 标识符;

long a;   //定义了一个长整形的变量a

b)内幕：实际上，计算机去开辟4B内存，给这段内存取一个名字，a.

c)取值范围：4个字节    -21亿 ---- +21亿

字符型

字符型char

字符型常量：'a'  'b'  '0'  '8'  '1'  '*'  'h'

字符型变量: char

a)定义：char标识符;

char  c;   //定义了一个字符变量c

b)取值范围：1个字节   -127---+128

c)内幕1：实际上，计算机去开辟1B内存，给这段内存取一个名字，c

d)内幕2：字符是用ASCII码来存放。

 

 

几个概念

定义

定义一个变量，从无到有创建一个新的变量。

int number;

初始化

定义一个变量的同时，给这个变量一个初始值。

int number = 14;

赋值

定义变量之后，给一个变量赋值。

number = 25;

        number = 38;

number = 98;

引用

使用一个变量的值。

number * 2;

printf("%d\n", number);

 

字符型        char                        1B        -127---128

短整型        short                 2B        -32700---+32700

整形                int                         4B        -21亿---+21亿

长整形        long                        4B        -21亿---+21亿

长长整形 long long         8B 

注意：

数据类型本身是不占用内存的。而是说用这种类型去定义一个变量，这个变量的内存大小。

定义变量，注意内存溢出。比如 int number;表示全世界的人数。

sizeof()  计算一个变量 或者 一种类型的字节数大小

sizeof(short)  sizeof(int)  sizeof(long)

signed和unsigned

有符号(signed): 最高位为符号位，不参与计数，int  -21亿----+21亿

signed int a;  

                signed char c;

signed short b;

不指定signed 默认有符号的。

无符号(unsined): 不要符号位，最高位参与计数 unsigned int 0 - 42亿

unsigned int a1;

                unsigned char c1;

        unsigned short b1;

必须指定unsigned 才是无符号的。

 

 

浮点型

浮点型数据在内存的存放方式：

0(符号位) 00000000(实数)  00000000 00000000 0000000(幂)

单精度float

4B  -3.4*10^-38------ 3.4*10^38

双精度double

8B  -1.7*10^-308 ----- 1.7*10^308

长双精度long double

8B  -1.7*10^-308 ----- 1.7*10^308

程序的执行

代码我们写的。

计算机能够明白我们的意思！！！

预处理

把头文件展开，把宏定义替换.

main.c ----> main.i

汇编

汇编语言

main.i---->main.asm汇编语言 

编译

汇编语言变成机器语言 

main.asm---->mian.obj

链接

产生可执行文件

main.obj----->main.exe

#include <stdio.h>

#define PI 3.14

int main()

{

        double r, per; //定义圆的半径 圆的周长

        r = 3.2;  //给圆的半径赋值为 3.2

        per = 2 * PI*r; //计算圆的周长

        printf("周长为：%.2f\n", per); //打印周长

        getchar();

        return 0;

}

标准的输入输出

C语言编译系统，提供了一些标准的输入输出的函数。要使用这些函数，请在文件开始包含头文件stdio.h

scanf 从键盘格式化输入

%d  整数 

%f   浮点数

%c   字符

float a;

        char b;

        int c;

        //从键盘输入三个数保存在a b c变量

        scanf("%f %c %d", &a, &b, &c);

printf

格式化输出:

printf("jiuxia");

格式控制符:

int number = 35;

        char ch = 'B';

        float n = 3.14156;

        printf("十进制：%d\n", number); 

        printf("八进制：0%o\n", number);

        printf("十六进制：0x%x\n", number);

        printf("%5d\n", number);

        printf("%-5d\n", number);

        printf("%c\n", ch);

        printf("%d\n", ch);

        printf("%f\n", n);

        printf("%.2f\n", n);

        printf("%10.2f\n", n);

printf("%-10.2f\n", n);

 

转义字符：

 

getchar()  输入字符  getchar() 防止程序闪退。

ch = getchar(); //从键盘输入一个字符

        getchar(); //等待键盘的输入

putchar()  输出字符

putchar(ch);

 

运算符

表达式

操作数和运算符组成。1+2  3*5  a/6

单个操作数也是一个表达式。  1  3.14  6.28  NUM

表达式本身没有意义。更关心的是表达式的返回值。

算术表达式

逗号表达式

赋值表达式

关系表达式

逻辑表达式

.....

赋值运算符 =

数学：1+2=3  3*5=15

程序：=  赋值运算符 把一个数据赋值给一个变量

int a;

        int b;

        a = 5;

        b = a;

        b = a + 5;

b = a - b;

 

算术运算符                 

+加  -减  *乘  /除   %取模

a+b;a-b;a*b;a/b;a%b;

 

1.除 /

整数 int： 截尾  整数的除法去除小数位。

浮点数float double: 正常

5/3; 返回值1

 

2.取模%

只针对整数，浮点数不存在%这个运算。

5%3;  返回值2

#include <stdio.h>

 

int main()

{

        int a = 135;

 

        //把a 逆序输出   135   531

        int b = a / 100;  //b 1

        int c = a % 100 / 10; // c  3

        int d = a % 10;   //d 5

        printf("%d%d%d\n", d, c, b);

        return 0;

}

自增自减运算符  ++  --

++ 一个变量自己本身加1

-- 一个变量自己本身减1

 

1.以分号为一个语句。分号结束之后 不管是前置还是后置  变量本身都是要+1.

2.语句没有结束之前，前置++  先加1 后取值   后置++  先取值后加1

前置先加  后置后加

a+++--a-a--+a++;请大家不要写这种东西。毫无意义！！！！！

关系运算符

>大于  <小于  >=大于等于  <=小于等于  ==等于  !=不等于

关系运算符用描述两个量的大小关系。

逻辑值：条件的成立和不成立。真（1）  假（0）

2<3; 返回值1 

3!=4;返回值1

2>5; 返回值0

int a = 5;

        int b = 3;

        printf("%d\n", a > 4);                        //1

        printf("%d\n", a < b);                        //0

        printf("%d\n", a >= b);                         //1

        printf("%d\n", a != a - b);                //1

        printf("%d\n", a == a - b);                //0

        printf("%d\n", b >= a*b);                //0

printf("%d\n", b <= b / a);                 //0

 

逻辑运算符 &&与  ||或  !非

&&与  两者为真才为真。  并且

||或  两者为假才为假。  或者

 

表达式1 && 表达式2

表达式1为真 并且 表达式2为真   1

 

表达式1 || 表达式2

表达式1为真 或者 表达式2为真   1

 

注意：

短路！！！！

如果说第一个表达式能够确定整个表达式的返回值，第二个