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）

#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定义常量

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

#define MAX 10
#include <stdio.h>
int main()
{
    printf("%d",MAX);
}

2、const定义变量

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

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

#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：局部变量

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

案例

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

2：全局变量

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

案例

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表示字符常量和字符串常量

总结：（变量和常量）

#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个数是否能被整除的判断（非常的好用）

#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)

案例：

#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

//按位与运算符
#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

#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

//按位异或运算符

#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

原码，反码，补码

//按位取反

#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就是自增自减运算符

//自增，自减，这个非常的容易的混淆
#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、逗号运算符

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

#自左向右的计算
#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位赋给字符变量

案例：
字符和整型之间的转换（重点）

#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边都是相同的数据类型，可以直接进行运算，如果是不同的类型的话，那就自动的将数据类型转换成更加高级的数据类型

#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

案例：

#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 @ 2024-03-17 23:01 q_7 阅读(79) 评论(0) 收藏举报

刷新页面返回顶部

q_777