C语⾔数据类型和变量

数据类型

编译器要处理数据 那么就需要知道数据的存储大小和存储方式(即数据类型)，使⽤整型类型来描述整数，使⽤字符类型来描 述字符，使⽤浮点型类型来描述⼩数。

整数类型

     signed-表示有符号的，带有正负号，包含负值；

     unsigned-表示无符号的，不带有正负号，只能表⽰零和正整数。

字符

1. char    （C 语⾔规定， char 类型默认是否带有正负号，由当前系统决定。 这就是说， char                 不等同于 signed char ，它有可能是 signed char ，也有可能是 unsigned char 。)
2. signed char
3. unsigned char

整型

    1.短整型

•             short  int
•             signed  short  int
•             unsigned short  int

    2.整型

•             int       （ int 类型，默认是带有正负号的，也就是说 int 等同于 signed int 。）
•             signed  int
•             unsigned int 

    3.⻓整型

•             long  int
•            signed long int
•            unsigned long int

    4.更⻓的整型 (C99中引⼊)

•           long long int
•          signed long long int
•          unsigned long long int

 下表列出了关于标准整数类型的存储大小和值范围的细节：

注意，各种类型的存储大小与系统位数有关，但目前通用的以64位系统为主。

以下列出了32位系统与64位系统的存储大小的差别（windows 相同）：

 为了代码的可移植性，需要知道某种整数类型的极限值时，应该尽量使⽤这些常量。

• SCHAR_MIN ， SCHAR_MAX ：signed char 的最⼩值和最⼤值。
• SHRT_MIN ， SHRT_MAX ：short 的最⼩值和最⼤值。
• INT_MIN ， INT_MAX ：int 的最⼩值和最⼤值。
• LONG_MIN ， LONG_MAX ：long 的最⼩值和最⼤值。
• LLONG_MIN ， LLONG_MAX ：long long 的最⼩值和最⼤值。
• UCHAR_MAX ：unsigned char 的最⼤值。
• USHRT_MAX ：unsigned short 的最⼤值。
• UINT_MAX ：unsigned int 的最⼤值。
• ULONG_MAX ：unsigned long 的最⼤值。
• ULLONG_MAX ：unsigned long long 的最⼤值。

为了得到某个类型或某个变量在特定平台上的准确大小，您可以使用 sizeof 运算符。表达式 sizeof(type) 得到对象或类型的存储字节大小。 

#include <stdio.h>
#include <limits.h>
 
int main()
{
   printf("int 存储大小 : %lu \n", sizeof(int));
   printf("unsigned int 存储大小 : %lu \n", sizeof(unsigned int));
   printf("short 存储大小 : %lu \n", sizeof(short));
   printf("unsigned short 存储大小 : %lu \n", sizeof(unsigned short));
   printf("long 存储大小 : %lu \n", sizeof(long));
   printf("unsigned long 存储大小 : %lu \n", sizeof(unsigned long));
   printf("char 存储大小 : %lu \n", sizeof(char));
   printf("unsigned char 存储大小 : %lu \n", sizeof(unsigned char));
   printf("signed char 存储大小 : %lu \n", sizeof(signed char));
   return 0;
}

 浮点类型

浮点型

1. float
2. double
3. long double

下表列出了关于标准浮点类型的存储大小、值范围和精度的细节：

void 类型

void 类型指定没有可用的值。它通常用于以下三种情况下：

 函数返回为空：

        C 中有各种函数都不返回值，或者您可以说它们返回空。不返回值的函数的返回类型为空。例如 void exit (int status);

函数参数为空：

       C 中有各种函数不接受任何参数。不带参数的函数可以接受一个 void。例如 int rand(void);

指针指向 void：

      类型为 void * 的指针代表对象的地址，而不是类型。例如，内存分配函数 void *malloc( size_t size ); 返回指向 void 的指针，可以转换为任何数据类型。

                                

               现在不懂也没关系，我们后续会慢慢学习！

布尔类型

C 语⾔原来并没有为布尔值单独设置⼀个类型，⽽是使⽤整数 0 表⽰假，⾮零值表⽰真。 在 C99 中也引⼊了 布尔类型 ，是专⻔表⽰真假的。

 _Bool

布尔类型的使⽤得包含头⽂件

<stdbool.h>

布尔类型变量的取值是：true(1)或者false(0)

类型转换

类型转换是将一个数据类型的值转换为另一种数据类型的值。

C 语言中有两种类型转换：

隐式类型转换：隐式类型转换是在表达式中自动发生的，无需进行任何明确的指令或函数调用。它通常是将一种较小的类型自动转换为较大的类型，例如，将int类型转换为long类型或float类型转换为double类型。隐式类型转换也可能会导致数据精度丢失或数据截断。

int i = 10;
float f = 3.14;
double d = i + f; // 隐式将int类型转换为double类型

显式类型转换：显式类型转换需要使用强制类型转换运算符（type casting operator），它可以将一个数据类型的值强制转换为另一种数据类型的值。强制类型转换可以使程序员在必要时对数据类型进行更精确的控制，但也可能会导致数据丢失或截断。

double d = 1.234;
int i = (int)d; // 显式将double类型转换为int类型

变量

变量的创建

C语⾔中把经常变化的值称为变量，不变的值称为常量。

变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：

type variable_list;

1. type 表示变量的数据类型，可以是整型、浮点型、字符型、指针等，也可以是用户自定义的对象。
2. variable_list 可以由一个或多个变量的名称组成，多个变量之间用逗号（,英文中的逗号）分隔，变量由字母、数字和下划线组成，且以字母或下划线开头。

举例：

int age; //整型变量
char ch; //字符变量
double weight; //浮点型变量

 变量在创建的时候就给⼀个初始值，就叫初始化。

type variable_name = value;

value 是变量的初始值。

举例：

int x = 10;         // 整型变量 x 初始化为 10
float pi = 3.14;    // 浮点型变量 pi 初始化为 3.14
char ch = 'A';      // 字符型变量 ch 初始化为字符 'A'
extern int d = 3, f = 5;    // d 和 f 的声明与初始化
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z

后续初始化变量 

在变量定义后的代码中，可以使用赋值运算符 = 为变量赋予一个新的值。

type variable_name;    // 变量定义
variable_name = new_value;    // 变量初始化

实例如下：

int x;          // 整型变量x定义
x = 123;         // 变量x初始化为123
float pi;       // 浮点型变量pi定义
pi = 3.14;   // 变量pi初始化为3.14
char ch;        // 字符型变量ch定义
ch = 'A';       // 变量ch初始化为字符'A'

需要注意的是，变量在使用之前应该被初始化。未初始化的变量的值是未定义的，可能包含任意的垃圾值。因此，为了避免不确定的行为和错误，建议在使用变量之前进行初始化。

变量的分类

1. 全局变量：在⼤括号外部定义的变量就是全局变量 全局变量的使⽤范围更⼴，整个⼯程中想使⽤，都是有办法使⽤的。
2. 局部变量：在⼤括号内部定义的变量就是局部变量 局部变量的使⽤范围是⽐较局限，只能在⾃⼰所在的局部范围内使⽤的。

 

当局部变量与全局变量重名时，优先使用局部变量

#include <stdio.h>
int b = 123;//全局变量
int main()
{
	int b = 321;//局部变量
	printf("%d\n", b);
	return 0;
}

全局变量和局部变量在内存中的存储 

全局变量保存在内存的全局存储区中，占用静态的存储单元；

局部变量保存在栈中，只有在所在函数被调用时才动态地为变量分配存储单元。

C语言经过编译之后将内存分为以下几个区域：

• （1）栈（stack）：由编译器进行管理，自动分配和释放，存放函数调用过程中的各种参数（函数参数）、局部变量、返回值以及函数返回地址。操作方式类似数据结构中的栈。
• （2）堆（heap）：用于程序动态申请分配和释放空间。C语言中的malloc和free，C++中的new和delete均是在堆中进行的。正常情况下，程序员申请的空间在使用结束后应该释放，若程序员没有释放空间，则程序结束时系统自动回收。注意：这里的“堆”并不是数据结构中的“堆”。
• （3）全局（静态）存储区：分为DATA段和BSS段。DATA段（全局初始化区）存放初始化的全局变量和静态变量；BSS段（全局未初始化区）存放未初始化的全局变量和静态变量。程序运行结束时自动释放。其中BBS段在程序执行之前会被系统自动清0，所以未初始化的全局变量和静态变量在程序执行之前已经为0。
• （4）文字常量区：存放常量字符串。程序结束后由系统释放。
• （5）程序代码区：存放程序的二进制代码。

运算符 （也叫操作符）

算术操作符

运算符	描述	实例（设A=10,B=20）
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
--	自减运算符，整数值减少 1	A-- 将得到 9

双目操作符 

+ - * \ % ，有2个操作数的，位于操作符两端的就是它们的操作数，这种操作符也叫双⽬操作符。 

#include<stdio.h>
int main()
{
	int a = 10, b = 20;
	printf("a+b=%d\n", a + b);
	printf("a-b=%d\n", a - b);
	printf("a*b=%d\n", a * b);
	printf("b/a=%d\n", b / a);
	printf("a%b=%d\n", a % b);
}

a+b=30
a-b=-10
a*b=200
b/a=2
a%b=10 

1."/"的注意事项: 

#include <stdio.h>
int main()
{
    float x = 10 / 20;
    int y = 10 / 20;
    printf("%f\n", x); // 输出 0.000000
    printf("%d\n", y); // 输出 0
    return 0;
}

上⾯⽰例中，尽管变量 x 的类型是 float （浮点数），但是 10 / 20 得到的结果是 0.000000 ，⽽不是 0.5,实际上， 除号的两端如果是整数，执⾏的是整数除法，得到的结果也是整数 。

如果希望得到浮点数的结果，两个运算数必须⾄少有⼀个浮点数，这时 C 语⾔就会进⾏浮点数除法。

#include <stdio.h>
int main()
{
	float x = 10.0 / 20; // 或者写成 10 / 20.0
	printf("%f\n", x); // 输出 0.500000
	return 0;
}

2.运算符 % 表⽰求模运算，即返回两个整数相除的余值。这个运算符只能⽤于整数，不能⽤于浮点数。 

负数求模的规则是，结果的正负号由第⼀个运算数的正负号决定。

#include <stdio.h>
int main()
{
 printf("%d\n", 16 % -3); // 1
 printf("%d\n",-16 % -3); // -1
 printf("%d\n",-16 % 3); // -1
 return 0;
}

单目操作符 

像++、--、+(正)、-(负)只有⼀个操作数，被称为单⽬操作符。

1.  ++是⼀种⾃增的操作符，⼜分为前置++和后置++。

       前置++

int a = 10; 
int b = ++a;//++的操作数是a，是放在a的前⾯的，就是前置++ 
printf("a=%d b=%d\n",a , b); 

a=11 b=11 

  先+1，后使⽤；

a原来是10，先+1，后a变成了11，再使⽤就是赋值给b，b得到的也是11，所以计算机运行后，a和b都是11

      后置++

int a = 10; 
int b = a++;//++的操作数是a，是放在a的后⾯的，就是后置++ 
printf("a=%d b=%d\n",a , b); 

a=11 b=10 

先使⽤，后+1；

a原来是10，先使⽤，就是先赋值给b，b得到了10，然后再+1，然后a变成了11，所以计算结果为：a是11，b是10， 

2. --是⼀种⾃减的操作符，也分为前置--和后置--.  

前置--是和前置++同理的，只是把加1，换成了减1；

后置--是和后置++同理的，只是把加1，换成了减1；

3.+和-

• 运算符 + 对正负值没有影响，是⼀个完全可以省略的运算符，写了也不会报错。
• 运算符 - ⽤来改变⼀个值的正负号，负数的前⾯加上 - 就会得到正数，正数的前⾯加上 - 会得到负数。

 

赋值操作符：=和复合赋值 

 赋值操作符“ =”

c = b = a+3;//连续赋值，从右向左依次赋值的。

 C语⾔虽然⽀持这种连续赋值，但是写出的代码不容易理解，建议还是拆开来写。

复合赋值符

 注意事项：

1.两个符号之间不可以有空格

2.复合赋值运算符的优先级与赋值运算符的相同。表达式n+=1等价于n=n+1，作用是去变量n中的值增1再赋值给变量n，其他复合赋值运算符的运算规则以此类推。

3.如果赋值运算符两侧的类型不一致，在赋值前系统将自动先把右侧的值或通过表达式求得的数值按赋值号左边变量的类型进行转换。

4.赋值操作的优先级较低，仅高于逗号运算符。