C语言入门·定义变量及类型转换

目录

定义变量

1、整型 int  、long int、long long int

2、字符型和字符串型 char

3、浮点型 float double

定义常量

局部变量和全局变量

混合运算

重要类型转换的问题

隐式转换：

强制类型转换：

sizeof运算符​​​​​​​

---

定义变量

在C语言里，bool型是在C99以后才有的类型，只能在c99以后的版本才可以使用，而且要使用bool型的话，必须添加头文件：   #include <stdbool.h>

 数据类型从小到大：

 bool，short，int，long，float，double，char

1、整型 int  、long int、long long int

整数类型的值都是整数。整数类型分为有符号型和无符号型。

int a,b;//声明两个个整型int(4B)变量，名为a,b
a= 5;//初始化
b = a + 5;
int c =15;//定义同时赋值
printf("%d,%d,%d\n",a,b,c);//1.输出整型变
//输出结果：5,10,15

2、字符型和字符串型 char

        char用于字符数据的处理。

        字符由单引号括起来，字符串由双引号括起来。
        字符只能是单个字符，字符串则可以含一个或多个字符。
        可以把一个字符型数据赋予一个字符变量，但不能把一个字符串赋予一个字符变量。
        '7'是一个字符型常量，"7"是一个字符串型常量，7是一个数字

字符：

char a = 'c';//注意这里需要是单引号
char ret = 98;//当输出选择%c时97会自动转换
printf("%c,%c\n",a,ret);//输出字符型变量
printf("%d\n",a);//如果选择是%d形式输出，会自动根据ASCII码进行转换
//输出结果：
c b
99

char b = 'a';
b = b - 32;
printf("%c\n",b);
//输出结果：A

字符串：

        在C语言里没有字符串变量，只有字符串常量；要进行字符串运算，则需要借助数组进行运算。

一个字符占1B,但是"CHINA"不是占5B,而是占6B;因为存储为​​​​​​​

C

H

I

N

A

\0

\0表示此字符串结束

3、浮点型 float double

浮点类型的值则有可能还有小数部分。

float打印输出默认小数点6位

带e是指数级，3e-3是3*10^-3，即0.00300

double 和long double提供了更大的取值范围和比float类型更高的精度。

定义常量

推荐define定义      
#define PI 数值    
一定要注意，这里没有分号结尾，而且define后面要定义的常量一定是大写

#include <stdio.h>
#define PI 3    //定义常量

int main()
{
    printf("%d",PI);//输出常变量
    return 0;
}
//输出结果：3

局部变量和全局变量

        局部变量的存储期限和函数有关，函数返回时收回分配

        静态局部变量：使用static来在函数内定义，但不像自动变量（被调用时就存在，退出函数时就消失）那样，静态局部变量始终存在着，也就是它的生存其目的为整个源程序。但是静态局部变量的作用域为定义它的内部。

        外部变量（全局变量）：声明是在任何函数体外的。和静态局部变量一样，始终存在着。作用域是文件作用域，跟随在全局变量声明之后的所有函数都可以访问(修改)它。

混合运算

整型数进行除法运算时，如果运算结果为小数，那么存储浮点数时一定要进行强制类型转换。需要注意换算前后大小的问题，小心发生溢出，从而导致出错。

#include <stdio.h>
#include<stdlib.h>
//混合运算，从长字节到短字节数据需要强制类型转换


int main() 
{ 
    int i =5;
    float f,g,h;
    short m;
    long I = 5;
    f = i / 2;   //和下面g对i进行强制类型转换进行对比,有/和//之分的是python
    h = i / 2.0;
    g = (float)i/2;
    m = (short)I/2;

    printf("i=%d,f=%f,g=%f,m=%d\n",i,f,g,m);
    printf("%0.9f,%0.9lf\n",h,h);//小数点后保留9位，此时double和float是一样的结果

    return 0; 
}  

//输出结果：i=5,f=2.000000,h=2.500000,g=2.500000,m=2
           2.500000000,2.500000000

重要类型转换的问题

隐式转换：

        可以将低级的转换为高级的。例如：short  int→ int

强制类型转换：

[强制转换表达式]        （类型名）表达式

这里括号里的类型名是要转换成的类型名。

void decompose (double x, long *int_part, double *fract_part)
{
    *int_part = (long) x;
    *fract_part = x - *int_part;
}

32位和64位系统

32位和64位系统是指计算机操作系统的位数。

位数代表处理器（CPU）在一次操作中能够处理的二进制数据位数。32位系统意味着操作系统能够处理32位的二进制数据。它可以访问和处理最大4GB的内存地址空间（2^32位存储单元），这也是其能够使用的最大内存容量。在32位系统下，每个程序的指令和数据都将被分为32位的部分进行处理。

64位系统意味着操作系统能够处理64位的二进制数据。它可以访问和处理更大的内存地址空间，最高可达18.4 million terabytes（TB）。64位系统能够更有效地利用大量的内存和处理器功能，提供更高的性能和更好的扩展性，并且可以更好地支持高度计算密集型的任务。

总的来说，64位系统相对于32位系统拥有更大的内存寻址能力和更高的性能。但需要注意的是，为了运行64位系统，计算机的处理器必须支持64位架构。不支持64位架构的处理器只能运行32位系统。因此，在选择操作系统时，需要考虑计算机硬件架构和需求。

sizeof运算符

是一种特殊的运算符，用来计算一种类型需要的存储空间的大小。

表达式：sizeof（类型名）。其值是一个无符号整数，代表存储属于类型名的值所需要的字节数。所以sizeof(float)是一个整数表达式。

​​​​​​​sizeof(char) = 1.只要是char类型的变量，sizeof()都等于1.

size0f(int)=4,

size0f(double)=8,

size0f(int*)=8

size0f(int**)=8

size0f(double*)=8

size0f(double**)=8

指针变量类型都是8位（因为我们都是64位系统）

在32位上，sizeof(int)=4。

#include <stdio.h>

int main()
{
	int a=100;
	int arr[10] ={1,2,3};
	char str[]="hello world";
	int len_a = sizeof(a);
	int len_arr = sizeof(arr);
	int len_str = sizeof(str);
 
	printf("len_a=%d,len_arr=%d,len_str=%d\n",len_a,len_arr,len_str);

	return 0;
}
/*
    当初始化a = 10;    int arr[10] ={1,2,3};  char str[]="hello";时
    输出为：len_a=4, len_arr=40, len_str=6
    当初始化a = 100;    int arr[10] ={1,2,3,4};  char str[]="hello world";时
    输出为：len_a=4,len_arr=40,len_str=12
    当初始化a = 100;    int arr[5] ={1,2,3};  char str[]="hello world";时
    输出为：输出为：len_a=4,    len_arr=20,    len_str=12

*/

因此，我认为

一个int型占4个字节，sizeof(int型变量） = 4；

第一个是一个int型数据，所以占据4个字节。

第二个是一个数组里面有三个int型数据，所以是3*4=12个字节。

第三个是hello这是5个字节，但因为它被双引号括起来了，系统自动在末尾不了一个'\0' 这个也占一个字节，所以就是5+1=6个字节

#include<stdio.h>

int main()
{
    int a = 10;
	char b = 'b';
	short c = 2;
	long d = 9;
	float e = 6.29f;
	double f = 95.0629;
	int arr[] = { 1,2,3 };
	char str[] = "hello";
	double *p=&f;
	int *i=&a;
	//分别对各个变量使用sizeof运算
	printf("a=%d,b=%d,c=%d,d=%d,e=%d,f=%d,arr=%d,str=%d point_p=%d,point_i=%d\n",
		sizeof(a), sizeof(b), sizeof(c), sizeof(d), sizeof(e), sizeof(f),
		sizeof(arr), sizeof(str), sizeof(p), sizeof(i));
 
	return 0;
}

//输出：a=4,b=1,c=2,d=8,e=4,f=8,arr=12,str=6 point_p=8,point_i=8

# include <stdio.h>
# include <string.h>


int main()
{
	printf("sizeof(char): %d\n", sizeof(char));
	printf("sizeof(short): %d\n", sizeof(short));
	printf("sizeof(int): %d\n", sizeof(int));
	printf("sizeof(long): %d\n", sizeof(long));
	printf("sizeof(long long): %d\n", sizeof(long long));
	printf("sizeof(float): %d\n", sizeof(float));
	printf("sizeof(double): %d\n", sizeof(double));
	return 0;
}
/*
    输出结果：
    sizeof(char): 1
    sizeof(short): 2
    sizeof(int): 4
    sizeof(long): 4
    sizeof(long long): 8
    sizeof(float): 4
    sizeof(double): 8

*/

​​​​​​​

类型	解释	对应占位符
byte	1B
float	浮点型，4B	%f
double	浮点型,8B	%lf
long double	浮点型，
boolean	布尔型，1B
char	字符型，1B	%c
short	2B	%hd
int	整型，  1B	%d
long  int	长整型 在32位系统中，占4B 在64位系统中占8B 需要在数字后+l或L,建议L	%ld
long long int