c语言的基础

一:数据类型

1:整数类型

包括整型,长整型。短整型。区别在于,采用不同位数的二进制编码表示,占用不同的存储空间,表示不同的数值范围,32位操作系统

类型说明符
数的范围
字节数
int(整型)
-2147483648 到2147483647
4
unsigned int(无符号整型)
0~65535,即 0~(2-1)
4
short int(短整型)
-32768~32767,即 -2~(2-1)
2
unsigned short int(无符号短整型)
0~65535,即 0~(2-1)
2
long int(长整型)
-2147483648~2147483647,即 -2~(2-1)
4
unsigned long(无符号长整型)
0~4294967295,即0~(2-1)
4

原码

反码

补码

 

对应的是%d

2:实数类型

实数类型数据又称为实数,实型数据或浮点数,指的是带有小数部分的非整数数值

c语言提供了2种表示实数的类型,单精度型(float)和双精度型(double)

float占4个字节,double占8个字节,double比float的数据精确的多

float对应的%f,double对应的%lf

 

3:字符型(char)

分为单个字符和字符串

'aaa' 就是单个字符

"aaaa" 就是字符串

字符是以ASCII形式存储的,字符'A'的ASCII对应的十进制数65,a:表示97,之间相差32

 

二:常量和变量

1:常量

就是值不能改变的为常量

1:整型常量(int)

整型常量就是整数

可以用十进制,八进制,16进制

2:实型常量(就是float,或者double)

又被称为浮点数,2种表示方法

(1)小数形式,由数字0-9和小数点组成,必须要有小数点 4.5 -45.232

(2)指数形式,由十进制加阶码,阶码就是e,或者E,e(E)前面必须要有数字,后面必须是整数

合法的:

2.3E5,5.6E-3,

不合法的:

123(没有小数点),E4(E之前没有数字),23.-E3(负号的位置不对),2.7E(无阶码)

3:字符常量(char)

字符常量,是一对单引号表示的字符,‘5’就是字符常量

(1)只能用单引号标识,不能使用双引号

(2)字符常量只能是单个字符,不能是多个字符

(3)字符可以是字符集中的任意字符

大部分采用ASCII字符集

转义字符的含义

\n 换行 10(ASCII)
\t 制表 9
\b 退格 8
\0 空字符 0
\\ 反斜杠字符 92
\' 单引号字符 39
\'' 双引号字符 34
\ddd 1~3位八进制代表字符  
\xhh 1~2位十六进制代表的字符  

就是里面对应着某个数字

 

4:字符串常量(char)

字符串常量,字符串的结束符为\0看不到,但是是存在的,遇到这个\0就结束

"a"和'a'是2个不同的常量'a'字符a代表的是个数字,而"a"代表的是a和\0,所以的话,2个事不同的常量

使用strlen函数来计算字符串的长度(不计算到\0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int main()
{
    char arr1[] = "adada";    ###里面有\0   
    char arr2[] = {'a','b','c'};   ###主动存放变量,没有\0,就会打印其它的地方(就是存储空间),遇到\0就结束
    printf("%s\n",arr1);
    int len = strlen(arr1);
    printf("长度是%d\n",len);
    printf("%s\n",arr2);
    int len1 = strlen(arr2);
    printf("长度是%d\n",len1);
}   
 
 
#这个数组就是arr1[0] =  'a'等

 

5:define和const定义的常量(符号常量)

1、define定义常量

写在外面主函数的外面,并且必须是大写的

1
2
3
4
5
6
#define MAX 10
#include <stdio.h>
int main()
{
    printf("%d",MAX);
}
2、const定义变量

修饰的变量,本质是变量,但是不能直接去修改,所以是具有常量的属性的

可以用数组来判断,因为数组的话,里面必须是常来那个,不能是变量,写在主函数里面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
int main()
{
    const int a = 10;
    printf("%d",a);
 
}
 
#下面的写法是错误的
#include <stdio.h>
int main()
{
    const int a = 10;
    a = 20;
    printf("%d",a);
 
} 

利用数组证明:

 

6:枚举常量

 就是能够一一列举出来的常量

2:变量

1、变量的基础

变量的定义:就是可以改变的变量,可以更换的值

变量的标识符命名规则:由字母和下划线组成,开头不能是数字

不能使用关键字(int,或者由特殊意义的字符)

 

变量的命名的格式:

数据类型 变量名 = 变量的值1,值2

 

1:局部变量

局部变量,就是在{}里面所定义的变量,只能在里面生效,在其他位置没有用

案例

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
int main()
{
    {
    int a = 100;
    printf("%d\n",a);
    return 0;
    }
    //printf("%d",a);  ##{}嵌套的话,里面的定义的,就只能在里面使用   如果在第一层的{}里面定义的话,就能直接在里面使用
}  

2:全局变量

就是定义在{}外面的变量,就能在全局的使用这个值,不受限制

案例

1
2
3
4
5
6
7
8
9
int a = 100;
#include <stdio.h>
int main()
{
    {
    printf("%d\n",a);   #里面也能使用
    }
    printf("%d\n",a);   ##外面也能使用
}  

3:变量的作用域

局部变量的作用域:就是在那定义的就只能在这个范围内使用

全局变量的作用域:就是在全局定义的话,就能在全局的范围内使用

4:变量的生命周期

 局部变量的生命周期:就是代码执行到了那个范围的的话,就生效,离开了这个范围的话代码就自动的销毁

全局变量的生命周期:程序执行后,就生效,程序结束后,就销毁,就相等于全局变量的生命周期等于程序的生命周期

 

3:返回的值用什么来替代

%d  打印整型

%c  打印字符

%s  打印字符串

%f  打印float类型数据

%lf  打印double类型的数据

%zu  打印sizeof的返回值,就是占用的字节数

 

char表示字符常量和字符串常量

 

总结:(变量和常量)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<stdio.h>
int main()
{
    10; //这个就是整型常量
    20.5;
    'qwqw';   ///这个就是字符常量
    "qwasad";   ////这个就是字符串常来那个
    int a = 10;   //这个就是变量
    char b = 'a';   //定义了一个字符变量
    char c = "c";   //定义了一个字符串变量
    float d = 10.4;   //定义了一个浮点型的变量
    double e = 1010.3; // 定义了一个double类型的变量
    return 0;
}

  

三:运算符和表达式

1:运算符

单目,双目,三目运算,是按照对象来划分的,一个对象就是一个单目,2个对象就是双单目运算

1、双目运算符

+ - * / %类

优先级:取负 -  的优先级最高,其次就是* / % 最后是+ -,具有自左向右结合性

另外还有就是副符号只有()没有花括号和大括号,()这个优先级最高,如果有嵌套的话,先算里面的即可

/:就是2个整数进行相除,取整数,如果其中有一个是小数的话,则去实型

%:就是必须是2个整数进行取模,就是取余数,可以判断2个数是否能被整除的判断(非常的好用)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
int main()
{
    int a = 10,b=10,c=10;
    int d;
    d = a+b+c;
    int e;
    e = a+b/c;
    int f;
    f = a*b/c;
    printf("%d\n",d);
    printf("%d\n",e);
    printf("%d\n",f);
    return 0;
}
=,+=,-=,/=,%=,*=类

这些都是赋值运算符和复合值运算符,具有自右向左性,就是先把右边的值计算出来,然后把值赋给左边的

语法:

a+=x a=a+x
a-=x-y a=a-(x-y)
a*=x-y a=a*(x-y)
a/=x-y a=a/(x-y)
a%=x-y a=a%(x-y)

案例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<stdio.h>
int main()
{
    int a,b,c;
    a=b=c=3;
    a+=a*=a;  //经过计算知,9+9,由于是变量,所以的话,这个值会发生改变的
    b+=b*b;   ///3+9
    c+=c-=c/=c*=c;   ///0-0  
    int e;
    e = 10;
    printf("%d,%d,%d\n",a,b,c);
    printf("%d",e);
    return 0;
}  

2、位运算符

就是在c语言中使用二进制数位进行运算的

操作的对象只能是char,int类型。

 1、位逻辑运算符

(1):按位与运算符(&)

自左向右,优先级一般

记忆:11为1,否则为0

1
2
3
4
5
6
7
8
9
10
11
//按位与运算符
#include<stdio.h>
int main()
{
    int a = 15;   ///先算出二进制的结果来,最后得出10进制的结果
    int b = 1;    //10进制转换成二进制的话,先做减法,二进制转换成10进制的话做乘法
    int result;
    result = a&b;
    printf("a&b=%d\n",result);
    return 0;
}

(2):按位或运算符(|)

记忆:00为0,否则为1,遇到1就为1

1
2
3
4
5
6
7
8
9
10
#include<stdio.h>
int main()
{
    int a = 5;  // 00000101;
    int b = 127; // 01111111; 最后算出的结果就是127
    int result;
    result = a | b;
    printf("a|b=%d",result);
    return 0;
}  

(3):按位异或运算符(^)

 

记忆:相同为0,不同为1

1
2
3
4
5
6
7
8
9
10
11
12
//按位异或运算符
 
#include<stdio.h>
int main()
{
    int a = 3; // 00000011
    int b =5;  ///00000101  最后算出的结果就是6
    int result;
    result = a ^ b;
    printf("a^b=%d",result);
    return 0;
}  

(4):按位取反(~)

就是对操作数的各位取反,即1变0,0变1

原码,反码,补码

1
2
3
4
5
6
7
8
9
10
11
//按位取反
 
#include<stdio.h>
int main()
{
    int a = 5;   ///转换后就是二进制后取反,得到的10进制是个负数,所以的话,需要进行其绝对值的取反+1得到就是-6
    int result;
    result = ~5;
    printf("~a=%d",result);
    return 0 ;
}

  

 

2、移位运算符

(1):左移运算符

 

 

(2):右移运算符

 

 

3、位赋值运算符

 

 

 

 

 

3、单目运算符

i++,i--;++i,--i就是自增自减运算符

1
2
3
4
5
6
7
8
9
10
11
//自增,自减,这个非常的容易的混淆
#include<stdio.h>
int main()
{
    int a = 6;
    a=++a; // a=a+1=7+1   a=7   #先自增,然后赋值
    printf("%d\n",a);
    a=a++;  // 先赋值,然后自增 a=7 a=a+1=8
    printf("%d\n",a);
    return 0;
}  

4、逗号运算符

结合性自左向右,分隔符,相当于几个表达式的合并,从左往右算

1
2
3
4
5
6
7
8
9
10
#自左向右的计算
#include<stdio.h>
int main()
{
    int a = 1,b,c;
    a++,b=a++,c=++b;  //自左向右的计算
    // 赋值a =1 -->> a=2, b=2 ---->>>a=3 , c =3 ---->>>b+1 =3
    printf("%d,%d,%d\n",a,b,c);  ///所以最后就是a=b=c=3,注意都是变量,因为变量的规范就是变量名=变量值,可以随意的改变
    return 0;
}

  

四:数据类型转换

在进行运算的时候,必须现将2边的数据类型保持一致,才能进行运算,否则的话,不能进行运算,会出错

1:赋值运算类型转换

注意:

1、实型数据赋给整型变量,舍去实型数据的小数部分

2、将整型变量赋给实型变量时,其数值不变,以浮点数的形式存储,即增加小数的部分(小数部分的值为0)

3、字符型赋给整型变量时,由于字符型只占用一个字节,所以字符型的ASCII值放在整型变量的低8位中,对于无符号整型变量,其高位补0,对于有符号整型变量,高位补0或者1

4、整型数据赋给字符变量时,只把其低8位赋给字符变量

案例:
 字符和整型之间的转换(重点)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<stdio.h>
int main()
{
    int a,b=328,c; 
    float x,y=9.36;
    char ch1 = 'k',ch2;
    //将实型变量转换整型
    a = y;
    printf("a的值为:%d\n",a);
    //将整型变量转换成实型变量
    x = b;
    printf("x的值为:%f\n",x);  //默认小数点后6位
    //将字符型变量转换成整型变量---也就是将ASCII之间的转换
    c = ch1;
    printf("c的值为:%d\n",c);
    //将整型变量的转换成字符变量
    ch2 = b;
    printf("chr2的值为:%c",ch2);
    return 0;
}

   

2:自动类型转换

运算符左右2边都是相同的数据类型,可以直接进行运算,如果是不同的类型的话,那就自动的将数据类型转换成更加高级的数据类型

1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
int main()
{
    int a;
    float f;
    a = 7/3; //自动的去整数,舍去小数
    printf("a的值为:%d\n",a);
    f = 4/5.0;  //不同的数据类型,自动的转换成更加高级的数据类型
    printf("f的值为:%f\n",f);
    return 0;
}

 

3:强制类型转换 

 对操作的数据进行强制性的转换,人为的转换

注意

1、强制类型转换运算符和表达式都需要加上括号,单个变量可以不用加

2、在进行部分的强制类型数据的转换时,取整类数据并不是按照4舍5入来进行取的,a=2.8, (int)a=2

3、无论是自动转换还是强制类型转换,都是为了本次运算需要所改变变量的临时性转换,并不改变变量原来的数据类型和变量的值,a的数据类型仍然时单精度的类型,其值仍然时2.8

案例:

1
2
3
4
5
6
7
8
9
#include<stdio.h>
int main()
{
    float x=45.2353;
    x=(int)(x*100+0.5)/100.0;  //在运算之前必须现将2边的数据类型进行同步,才能进行运算即可
    //4524自动的转换为4524.0进行运算,然后保留2位小数,并且进行了4舍5入
    printf("x=%.2f\n",x);
    return 0;
}

  

  

 

posted @   q_7  阅读(50)  评论(0编辑  收藏  举报
努力加载评论中...
点击右上角即可分享
微信分享提示