用于定义变量或者类型
类型 变量名；
char、short、int、long、 float、double、struct、union、enum、signed、unsigned、void
1、char 字符型，用char定义的变量是字符型变量，占1个字节
char ch='a'；=为赋值号
char ch1 = '1'； 正确
char ch2 = '1234' ；错误的2、short 短整型，使用short定义的变量是短整型变量，占2个字节
short int a=11; -32768----327673、int 整型，用int定义的变量是整型变量，在32位系统下占4个字节，在16平台下占2个字节
int a=44; -20亿----20亿4、long长整型，用long定义的变量是长整型的，在32位系统下占4个字节
long int a=66;5、foat单浮点型(实数），用float定义的变量是单浮点型的实数，占4个字节
float b=3.8f;6、double双浮点型(实数），用double定义的变量是双浮点型的广数，8个字节
double b=3.8;7、struct，这个关键字是与结构体类型相关的关键字，可以用它来定义结构体类型
8、union，这个关键字是与共用体(联合体）相关的关键字
9、enum，与枚举类型相关的关健字
10、signed，有符号（正负）的意思
在定义char、整型（short、int、long）数据的时候用signed修饰，代表咱们定义的数据是有符号的，可以保存正数，也可以保存负数
例：signed int a=10；
signed int b=-6; 注意：默认情况下signed可以省略即inta=-10：//默认n就有符号类型的数据
11、unsigned，无符号的意思
在定义char、整型（short、int、long)数据的时候用unsigned修饰，代表咱们定义的数据是无符号类型的数据只能保存正数和0。
unsigned int a=101;
unsigned int a=-101； ∥错误扩展：内存存储
char ch=‘a'；//占1字节，存储的是97
0110 0001
字节：内存的基本单位，8位为1个字节
计算机存储时，只能存储1和0的二进制组合，1和0都分别占1位
字符型数据在内存中存储的不是字符本身，而是存储其Asci码
整型变量存储的是其值的二进制 unsigned int a=97;
扩展：正数和负数在内存中到底是怎么存的
原码、反码、补码
规定：
正数的原码反码和补码相同 5
00000101
负数：-5
00000101
最高位为符号位最高位为1代表是个负数
12、void，空类型的关键字
char、int、foat都可以定义变量
void不能定义变量，没有void类型的变量
void是用来修饰函数的参数或者返回值，代表函数没有参数或没有返回值
例：
void fun(void)
{
}
代表fun函数没有返回值，fun函数没有参数
例2：
#include
int main()
{
char a='a';
short int b=10;
int c;
long int d;
float e;
double f;
printf("%d\n",sizeof(a));
printf("%d\n",sizeof(b));
printf("%d\n",sizeof(c));
printf("%d\n",sizeof(d));
printf("%d\n",sizeof(e));
printf("%d\n",sizeof(f));
return 0;
} register、static、const、auto、extem
1、reglster
reglster是寄存器的意思，用register修饰的变量是寄存器变量，
即：在编译的时候告诉编译器这个变量是寄存器变量，尽量将其存储空间分配在寄存器中。
注意：
（1）：定义的变量不一定真的存放在寄存器中。
（2）：cpu取数据的时候去寄存器中拿数据比去内存中拿数据要快
（3）：因为寄存器比较宝贵，所以不能定义寄存器数组
（4）：register只能修饰字符型及整型，不能修饰浮点型
register char ch;
register short int b;
register int c；
register float d； //错误的（5）：因为register修饰的变量可能存放在寄存器中不存放在内存中，所以不能对寄存器变量取地址。因为只有存放在内存中的数据才有地址。
register int a;
int*p;
p=&a； ∥错误的，a可能没有地址2、static
static是静态的意思
static可以修饰全局变量、局部变量、函数
3、const
const是常量的意思
用const修饰的变量是只读的，不能修改它的值
const int a=101； //在定义a的时候用const修饰，并赋初值为101从此以后，就不能再给a赋值了
a=111； //错误的
4、auto
int a；和int a是等价的，auto关键字现在基本不用
5、extern
是外部的意思，一般用于函数和全局变量的声明
1.1.3控制语句相关的关键字if、else、break、contiue、for、while、do、switch、case、goto、default
1.1.4其他关键字sizeof、typedef、volatile
1、slzeof
使用来测变量、数组的占用存储空间的大小(字节数）
例3:
int a=10；
int num；
num = sizeof(a)；2、typedef重命名相关的关键字
unsigned short int a=10;
U16
关键字，作用是给一个已有的类型，重新起个类型名，并没有创造一个新的类型
INT16 a;
U8 ch;
INT32 b;
大家知道，在c语言中没有INT16U8这些关键字
INT16 U8是用typedef定义出来的新的类型名，其实就是short int 及unsigned char 的别名
typedef起别名的方法：
1、用想起名的类型定义一个变量
shoft int a;
2、用新的类型名替代变量名
short int INT16;
3、在最前面加typedef
typedef short int INT16;
4、就可以用新的类型名定义变量了
INT16b；和short int b；//是一个效果
例4：
#include
//short int b;
//short int INT16;
typedef short int INT16;
int main(int argc,char *argv[])
{
short int a=101;
INT16c=111;
printf("a=%d\n",a);
printf("c=%d\n",c);
return 0；
} 3、volatile
易改变的意思
用volatile定义的变量，是易改变的，即告诉cpu每次用volatile变量的时候，重新去内存中取
保证用的是最新的值，而不是寄存器中的备份。
volatile关键字现在较少适用
volatile int a=10;扩展知识：
命名规则：
在c语言中给变量和函数起名的时候，由字母、数字、下划线构成
必须以字母或者下滑线开头
例5：
int a2； //正确的
int a_2; //正确的
int _b： //正确的
int 2b; //错误的
int $a2; //错误的注意：起名的时候要求见名知意
Linux风格
stu_num
驼峰风格
StuNum
大小写敏感
int Num;
int num;
C语言的程序结构
一个完整的C语言程序，是由一个、且只能有一个main()函数（又称主函数，必须有）
和若干个其他函数结合而成（可选)
main函数是程序的入口，即程序从main函数开始执行
char、shortint、int、long int、float、double
扩展：常量和变量
常量：在程序运行过程中，其值不可以改变的量
例：100 'a' "hello"
整型 100,125,-100,0
实型 3.14，0.125f，-3.789
字符型 ‘a’，‘b’，‘2’
字符串 “a”，“ab”，“1232”
变量：其值可以改变的量被称为变量
int a=100:
a=101；
1、字符数据
（1）字符常量：
直接常量：用单引号括起来，如：'a'、'D'、'0'等.
转义字符：以反斜杠“\”开头，后跟一个或几个字符、如'\n','\r'等，分别代表换行、横向跳格。
‘\\’表示的是 \ “%%’” “\”
（2）字符变量：
用char定义，每个字符变量被分配一个字节的内存空间
字符值以ASCI码的形式存放在变量的内存单元中：
注：chara;
a=x;
a变量中存放的是字符'x'的ASCⅡ：120
即a=120跟a='x'在本质上是一致的。
例6：
#include
int main()
{
chara='x';
char b=120;
printf("a=%c\n",a);
printf("b=%c\n",b);
} ASCII码表
例7
#include
int main()
{
unsigned int i;
for(i=0;i<=255;i++)
{
printf("%d %c",i, i);
if(%10==0)
printf("\n");
}
return 0;
} （3）字符串常量
是由双引号括起来的字符序列，如“CHINA”、”哈哈哈”
“C program”，“$12.5”等都是合法的字符串常量。
（4）字符串常量与字符常量的不同
‘a’为字符常量，”a”为字符串常量
每个字符串的结尾，编译器会自动的添加一个结束标志位'\0'，
即“a”包含两个字符‘a’和’\0’
2、整型数据
（1）整型常量：（按进制分）：
十进制：以正常数字1-9开头，如457789
八进制：以数字0开头，如 0123
十六进制：以0x开头，如 0xle
a=10,b=11,c=12,d=13,e=14,f=15
（2）整型变量：
有/无符号短整型（un/signed)short(int) 2个字节
有/无符号基本整型(un/signed)int 4个字节
有/无符号长整型(un/signed)long(int) 4个字节 （32位处理器）
3、实型数据（浮点型）
（1）实型常量
实型常量也称为实数或者浮点数
十进制形式：由数字和小数点组成：0.0、0.12、5.0
指数形式：123e3 代表123*10的三次方
123e-3 代表123*10的负三次方
不以f结尾的常量是double类型
以f结尾的常量（如3.14f）是float类型
（2）实型变量
单精度(float)和双精度(double）3.1415926753456
float型：占4字节，7位有效数字，指数-37到38
3333.333 33
double型：占8字节，16位有效数字，指数-307到308
格式化输出字符：
%d 十进制有符号整数 %u 十进制无符号整数
%x 以十六进制表示的整数 %o 以八进制表示的整数
%f float型浮点数 %lf double型浮点数
%e 指数形式的浮点数
%s 字符串 %c 单个字符
%p 指针的值
特殊应用：
%3d %03d %-3d %5.2f
%3d：要求宽度为3位，如果不足3位，前面空格补齐；如果足够3位，此语句无效
%03d：要求宽度为3位，如果不足3位，前面0补齐；如果足够3位，此语句无效
%-3d：要求宽度为3位，如果不足3位，后面空格补齐；如果足够3位，此语句无效
%.2f：小数点后只保留2位
#include
int main()
{
char a='x';
int b=101;
float c=3.14f;
double d=1.23;
int e=0x3d; //48+13
printf("a =%c\n",a);
printf("b=%d\n",b);
printf("c=%f\n",c);
printf("d=%lf\n",d);
printf("e=%x\n",e)；
printf("e=%d\n",e);
return 0;
} 概念：由若干个相同或不同类型数据构成的集合，这种数据类型被称为构造类型
例 int a[10]；
数组、结构体、共用体、枚举
数据有不同的类型，不同类型数据之间进行混合运算时必然涉及到类型的转换问题
转换的方法有两种：
(1)自动转换：遵循一定的规则，由编译系统自动完成
(2)强制类型转换：把表达式的运算结果强制转换成所需的数据类型
自动转换的原则：
1、占用内存字节数少（值域小）的类型，向占用内存字节数多（值域大)的类型转换，以保证精度不降低
2、转换方向：
1)当表达式中出现了char、short int、int类型中的一种或者多种，没有其他类型了
参加运算的成员全部变成int类型的参加运算，结果也是int类型的
例8:
#include
int main()
{
printf("%d\n",5/2);
return 0;
} 2)当表达式中出现了带小数点的实数，参加运算的成员全部变成double类型的参加运算，结果
也是double型。
例9：
#include
int main()
{
printf("%lf\n",5.0/2);
return 0;
} 3)当表达式中有有符号数也有无符号数，参加运算的成员变成无符号数参加运算结果也是无符号数。（表达式中无实数）
例10：
#include
{
int main()
int a=-8;
unsigned int b=7;
if(a+b>O)
{
printf("a+b>O\n");
}
else
{
printf(“a+b<=O\n");
}
printf(“%x\n",(a+b));
printf("%d\n",(a+b));
return 0;
} 4)在赋值语句中等号右边的类型自动转换为等号左边的类型
例11：
#include
int main()
{
int a;
float b=5.8f ; //5.8后面加f代表5.8是float类型,不加的话认为是double类型
a=b;
printf("a=%d\n",a);
return 0;
} 5)注意自动类型转换都是在运算的过程中进行临时性的转换，并不会影响自动类型转换的变量的
值和其类型
例12：
#include
int main()
{
int a;
float b=5.8f; //5.8后面加f代表5.8是float 类型,不加的话认为是double类型
a=b;
printf("a=%d\n", a);
printf（"b=%f\n"，b); //b的类型依然是float类型的,它的值依然是5.8
return 0;
} 强制转换：通过类型转换运算来实现
(类型说明符）（表达式)
功能：把表达式的运算结果强制转换成类型说明符所表示的类型
例如：(float)a；//把a的值转换为实型
(int)(x+y)；//把x+y的结果值转换为整型
注意：类型说明符必须加括号
例13：
#include
int main()
{
float x=0;
int i=0;
×=3.6f;
i=x;
i=(int)x;
printf("x=%f,i=%d\n",x,i);
return 0;
} 说明：无论是强制转换或是自动转换，都只是为了本次运算的需要，而对变量的数据长度进行的临时性转换，而不改变数据定义的类型以及它的值
1.3运算符 1.3.1运算符 用算术运算符将运算对象（也称 *** 作数）连接起来的、符合C语法规则的式子，称为C算术表达式，运算对象包括常量、变量、函数等。
例如：a*b/c-1.5+'a'
1、双目运算符：即参加运算的 *** 作数有两个
例：+ a+b
2、单目运算符：参加运算的 *** 作数只有一个
++自增运算符给变量值+1
-- 自减运算符给变量值-1
int a=10;
a++;
3、三目运算符：即参加运算的 *** 作数有3个
0?0:0
+ - * / % += -= /= %=
10%3 表达式的结果为1
复合运算符：
a+=3相当于a=a+3
a*=6+8 相当于a=a*(6+8）
(>、<、==、>=、<=、!=）
!=为不等于
一般用于判断条件是否满足或者循环语句
1、&& 逻辑与
两个条件都为真，则结果为真
if((a>b)&&(a
两个条件至少有一个为真，则结果为真
if((a>b)||(a
if(!(a>b))
{
}
1.3.6位运算符十进制转二进制：
例：123十进制转二进制
123/2=61 余1
61/2=30 余1
30/2=15 余0
15/2=7 余1
7/2=3 余1
3/2=1 余1
1/2=0 余1
123的二进制为111 1011正数在内存中以原码形式存放，负数在内存中以补码形式存放
正数的原码=反码=补码
原码：将一个整数，转换成二进制，就是其原码。
如单字节的5的原码为：0000 0101；-5的原码为 1000 0101。
反码：正数的反码就是其原码；负数的反码是将原码中，除符号位以外，每一位取反
如单字节的5的反码为：0000 0101；-5的反码为 1111 1010。
补码：正数的补码就是其原码；负数的反码+1就是补码。
如单字节的5的补码为：00000101:-5的原码为11111011
在计算机中，正数是直接用原码表示的，如单字节5，在计算机中就表示为：0000 0101
负数用补码表示，如单字节-5，在计算机中表示为1111 1011。
无论是正数还是负数！编译系统都是按照内存中存储的内容进行位运算。
1、& 按位与
任何值与0得0，与1保持不变
使某位清0
0101 1011 &
1011 0100
0001 0000
2、| 按位或
任何值或1得1，或0保持不变
0101 0011 |
1011 0100
1111 0111
3、～ 按位取反
1变0，0变1
0101 1101
1010 0010
4、^ 按位异或
相异得1，相同得0
1001 1100
0101 1010
1100 0110
5、位移
>>右移
<<左移
注意右移分：逻辑右移、算数右移
（1）右移
逻辑右移 高位补0，低位溢出
算数右移 高位补符号位，低位溢出(有符号数）
1000 1111
1111 0000
1111 1100
A)、逻辑右移
低位溢出、高位补0
0101 1010 >>3
0000 1011
B)、算数右移：
对有符号数来说
低位溢出、高位补符号位。
1010 1101>>3
1111 0101
0101 0011 >>3
0000 1010
总结右移：
1、逻辑右移 高位补0，低位溢出
注：无论是有符号数还是无符号数都是高位补0，低位溢出
2、算数右移 高位补符号位，低位溢出(有符号数）
注：对无符号数来说，高位补0，低位溢出
对有符号数来说，高位补符号位，低位溢出
在一个编译系统中到底是逻辑右移动，还是算数右移，取决于编译器
判断右移是逻辑右移还是算数右移
#include
int main()
{
printf(“%d\n",-1>>3);
return 0;
}
如果结果还是-1证明是算数右移 （2）左移
<< 高位溢出，低位补0
5<<1
0000 0101
0000 1010
0?0:0
A?B:C : 如果？前边的表达式成立，整个表达式的值，是?和：之间的表达式的结果，否则是之后的表达式的结果（A成立整个表达式的值是B，否则是C）
例14：
#include
int main()
{
int a;
a=(3<5)?(8):(9);
printf("a=%d\n",a);
return 0;
} 0，0
例15:
#include
int main()
{
int num;
num=(5,6);
printf("%d\n",num);
return 0;
} 注意逗号运算符的结果是，后边表达式的结果
1.3.9自增自减运算符i++ i--
运算符在变量的后面，在当前表达式中先用 i 的值，下条语句的时候 i 的值改变
例16：
#include
int main()
{
int i=3;
int num;
num=i++;
printf("num=%d,i=%d\n",num,i); //num=3,i=4
return 0;
} ++i先加，后用
例17：
#include
int main()
{
int i=3;
int num;
num=++i;
printf("num=%d,i=%d\n",num,; //num=4,i=4
return 0;
} 例18：
#include
int main()
{
int i=3;
int num;
num=(i++)+(i++)+(i++);
printf("num=%d\n,i=%d",num,i); //num=9 i=6
return 0;
} 例19：
#include
int main()
{
int i=3;
int num;
num=(++i)+(++i)+(++i);
printf("num=%d,i=%d\n",num); //num=18 i=6
return 0;
} 运算符优先级
在表达式中按照优先级先后进行运算，优先级高的先于优先级低的先运算。
优先级一样的按结合性来运算
int a;
a=2+5+3*4-6 //a=13
运算符结合性
左结合性：从左向右运算
int a;
a=2+3+9+10; //a=24
右结合性：从右向左运算
int a;
a=b=c=d=100; //a=100
优先级和结合性表：注意：建议当表达式比较复杂的时候，用（）括起来，括号的优先级最高，有先算括号里的。这样也防止写错表达式。
int a; a =(2+3)*6+(9*3)+10 //a=67
1.4控制语句 1.4.1选择控制语句1、if语句
形式：
1)if(条件表达式）
{ //复合语句，若干条语句的集合
语句1；
语句2：
}
如果条件成立执行大括号里的所有语句，不成立的话大括号里的语句不执行
例20：
#include
int main（）
{
int a=10;
if(a>5)
{
printf(“a>5\n");
}
return 0;
} 2) if (条件表达式)
{
}
else
{
}
if else语句的作用是，如果if的条件成立，执行if后面（）内的语句，否则执行else后的语句
例21：
#include
int main()
{
int a=10;
if(a>5)
{
printf("a>5\n");
}
else
{
printf("a<=5\n");
}
return 0;
} 注意if和else之间只能有一条语句，或者有一个复合语句，否则编译会出错
例22：
if()
语句1;
语句2;
else
语句3;
语句4;错误：if和else之间只能有一条语句，如果有多条语句的话加大括号
例23：
if()
{
语句1;
语句2;
}
else
{
语句3;
语句4;
}正确
3) if（条件表达式1)
{
}
else if(条件表达式2)
{
}
else if(条件表达式3）
{
}
else
{
}
在判断的时候，从上往下判断，一旦有成立的表达式，执行对应的复合语句，下边的就不再判断了，各个条件判断是互斥的。
例24：
#include
int main(void)
{
float score=0;
printf("请输入学生分数:\n");
scanf("%f",&score);
if(score<0 ||score >100)
{
printf("你所输入的信息有错\n");
return 0;
}
else if(score<60)
{
printf("E\n");
}
else if(score <70)
{
printf("D\n");
}
else if(score<80)
{
printf("C\n");
}
else if(score<90)
{
printf("B\n");
}
else
{
printf("A\n");
}
return 0;
} 2、switch 语句
switch(表达式）//表达式只能是字符型或整型的(short int int long int)
{
case 常量表达式1：
语句1：
break:
case 常量表达式2：
语句2；
break:
default：语句3：break;
}
注意：break的使用
#include
int main()
{
int n;
printf("请输入一个1～7的数:\n");
scanf("%d",&n);
switch(n)
{
case 1:
printf("星期一\n");
break;
case 2:
printf("星期二\n");
break;
case 3:
printf("星期三\n");
break;
case 4:
printf("星期四\n");
break;
case 5:
printf("星期五\n");
break;
case 6:
printf("星期六\n");
break;
case 7:
printf("星期天\n");
break;
default:
printf("您的输入有误,请输入1～7的数\n");
break;
}
return 0;
} 1、for循环
for( 表达式1；表达式2；表达式3 )
{ //复合语句，循环体
}
第一次进入循环的时候执行表达式1，表达式1只执行一次，
表达式2，是循环的条件，只有表达式2为真了，才执行循环体，也就是说
每次进入循环体之前要判断表达式2是否为真。
每次执行完循环体后，首先执行表达式3
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）