04. C和数据

星光樱梦

已于 2024-09-29 19:26:55 修改

阅读量1k

点赞数 23

分类专栏： C语言程序设计文章标签： c语言

于 2024-09-29 19:25:01 首次发布

本文链接：https://blog.csdn.net/flurry_heart/article/details/142641937

版权

C语言程序设计专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、标识符

1.1、什么是标识符

标识符（identifier）是指用来标识某个实体的一个符号，在不同的应用环境下有不同的含义。在计算机编程语言中，标识符是用户编程时使用的名字，用来给变量、常量、函数等命名，以建立起名字与使用之间的关系。标识符通常由字母和数字以及其它字符构成。

在编程语言中，标识符就是程序员自己规定的代表一定含义的单词，比如变量名、常量名、函数名等。

1.2、标识符的命名规则

标识符只能由数字、字母（26个英文字母大小写）、下划线（_）组成；
标识符不能以数字开头；
不可以使用关键字作为标识符，但可以包含关键字；
标识符严格区分大小写；

#include <stdio.h>

int main(void)
{
    int useId = 1;
    int age = 10;
    int minNum = 3;
    int max_num = 30;

    return 0;
}

标识符的命名建议见名知意；

二、常量

2.1、什么是常量

常量指的是在计算机程序运行时，不会被程序修改的量；在 C语言中，常量主要分为以下几种类型：

字面常量
- 整型常量，可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀默认表示十进制。整型常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数，L 表示长整数，后缀可以大写也可以小写，U 和 L 的顺序任意。例如：100，200，-100，0，037，0x5A
- 浮点型常量，由整数部分、小数点、小数部分和指数部分组成，可以使用小数形式或者指数形式来表示浮点型常量。例如：3.14，0.125，-3.14，314159E-5
- 字符型常量，是括在单引号中的单个字符。字符常量可以是一个普通的字符，也可以是一个转义字符。例如：‘a’，‘A’，‘\n’
- 字符串常量，是括在双引号中的字符序列。在字符串常量中，我们可以使用 ‘\’ 实现换行。例如：“hello”，“a”，“123”
const 修饰的常变量，本质上是变量，但是不能直接修改，有常量的属性
#define 定义的标识符常量
枚举常量

2.2、字面常量

【1】、整型字面常量

#include <stdio.h>

int main(void)
{
    // 整型字面量
    int i1 = 100;
    int i2 = -100;
    int i3 = 037;
    int i4 = 0x5A;

    printf("%d\n",i1);
    printf("%d\n",i2);
    printf("%d\n",i3);
    printf("%d\n",i4);

    return 0;
}

【2】、浮点型字面常量

#include <stdio.h>

int main(void)
{
    // 浮点型字面量
    double d1 = 3.14;
    double d2 = -3.14;
    double d3 = 314159E-5;
    float f1 = 3.14f;

    printf("%lf\n",d1);
    printf("%lf\n",d2);
    printf("%lf\n",d3);
    printf("%f\n",f1);

    return 0;
}

【3】、字符型字面常量

#include <stdio.h>

int main(void)
{
    // 字符字面量
    char c1 = 'a';
    char c2 = 'A';
    char c3 = '\n';

    printf("%c\n",c1);
    printf("%c\n",c2);
    printf("%c\n",c3);

    return 0;
}

【4】、字符串字面常量

#include <stdio.h>

int main(void)
{
    // 字符串字面量
    char str1[] = "hello";
    char str2[] = "a";
    char str3[] = "123";
    char str4[] = "hello world";
    char str5[] = "hello \
world";

    printf("%s\n",str1);
    printf("%s\n",str2);
    printf("%s\n",str3);
    printf("%s\n",str4);
    printf("%s\n",str5);

    return 0;
}

2.3、const修饰的常变量

#include <stdio.h>

int main(void)
{
    // 使用const关键字定义常量
    const double pi = 3.14;

    // 常量赋值之后，不能更改
    //pi = 3.1415926;

    // 格式化输出，%lf输出双精度浮点型数据，默认保留6位小数
    printf("pi = %lf\n",pi);
    // .2f，保留两位小数
    printf("pi = %.2lf\n",pi);

    return 0;
}

2.4、define定义的标识符常量

#include <stdio.h>

// 宏定义常量
#define PI 3.1415926

int main(void)
{

    // 标识符常量不能改变
    // PI = 3.14;

    // 格式化输出，%lf输出双精度浮点型数据，默认保留6位小数
    printf("PI = %lf\n",PI);
    // .2f，保留两位小数
    printf("PI = %.2lf\n",PI);

    return 0;
}

2.5、枚举常量

#include <stdio.h>

/* 枚举常量  */
enum Color
{
    RED,
    GREEN,
    BLUE
};

int main(void)
{
    enum Color color = BLUE;

    return 0;
}

2.6、const和define定义常量的区别

const 定义的常量带类型，define 不带类型；
const 是在编译、运行的时候起作用，而 define 是在编译的预处理阶段起作用的；
define 只是简单的替换，没有类型检查；
const 常量可以进行调试的，而 define 是不能进行调试的，主要是因为在预编译阶段 define 定义的常量就已经替换掉了，调试的时候没有了；
const 不能重定义，不可以定义两个一样的，而 define 通过 undef 可以取消某个符号的定义，在重新定义；
define 可以配合 #indef、#ifndef、#endif 来使用，可以让代码更加灵活；

#include <stdio.h>

#define A   1
#define B   A+3
#define C   A/B*3

int main(void)
{
    // C其实是A/A+3*3
    printf("%d\n",C);
  
    return 0;
}

三、变量

3.1、变量的概念

变量就是在程序的执行过程中，其值可能发生改变的量（数据）；变量是内存中的一个存储区域（不同的数据类型，占用的空间大小也不一样），该区域的数据可以在同一类型范围内不断的改变，变量是程序中最基本的存储单元，包含 变量类型、变量名 和 存储的值。

3.2、变量的作用

变量的作用就是在内存中保存数据；我们可以使用变量名来访问这块区域的数据；

3.3、变量的定义

变量的定义：

[存储类型] 数据类型 变量名;

int a;

变量的 存储类型 可以是 auto、register、static 和 extern；
- auto 说明变量只能再某个程序范围内使用，通常再函数体内或函数中的复合语句里。（默认是随机值）。在函数体的某段程序内说明 auto 存储类型的变量可以省略关键字 auto。
- register 称为寄存器型，register 变量是想将变量放入 CPU 的寄存器中，这样可以加快程序的运行速度。如果申请不到就使用一般内存，同 auto。
- static 变量称为静态存储类型的变量，既可以在函数体内，也可在函数体外声明。（默认是 0）。
- extern 称为外部参照引用型，使用 extern 说明的变量可以被其它文件中的函数所引用。
变量的 数据类型 可以是基本数据类型，也可以是自定义的数据类型

register 变量必须是能被 CPU 所接受的类型。这通常意味着 register 变量必须是一个单个的值，并且长度应该小于或等于整型的长度。

我们不能使用 & 来获取 register 变量的地址；

3.4、变量的赋值

变量的赋值：

变量名 = 变量值;

a = 10;

变量可以在声明的同时赋值：

数据类型 变量名 = 变量值;

int a = 10;

数据类型：为空间中存储的数据，加入类型（限制）
变量名：为空间起的名字
数据值：存在空间里面的数值

#include <stdio.h>

int main(void)
{
    // 定义变量
    // 数据类型 变量名 = 数据值;
    int a = 10,b = 20;

    // 格式化输出，%d输出整型数据
    printf("a = %d,b = %d\n",a,b);

    return 0;
}

在 C 语言中每个变量必须 先声明，再初始化，后使用；

在同一个作用域中，变量名不能重复声明，但变量可以重新赋值；

一行上可以同时声明多个变量，使用 “,” 隔开；

3.5、变量的作用域和生命周期

所谓的变量的作用域就是变量的有效范围；变量的作用域为其定义所在的一对{}内，即出了大括号就不认识了；

局部变量的作用域：是变量所在的局部范围；
全局变量的作用域：是整个工程；

变量的生命周期指的是变量的创建到变量销毁之间的一个时间段。

局部变量的生命周期：进入局部范围生命开始，出局部范围生命结束；
全局变量的生命周期：整个程序的生命周期；

3.6、变量的分类

3.6.1、按数据类型分类

在这里插入图片描述

3.6.2、按变量定义位置分类

在这里插入图片描述

在一个函数内部定义的变量，只在本函数范围内有效。在复合语句内定义的变量，只在本复合语句范围内有效；

函数的形参也属于局部变量，作用范围仅限于函数内部的所有语句块；

如果一个变量在所有函数外部定义，那么这个变量就是全局变量。全局变量是可以在程序中的任何位置进行访问的变量；

当局部变量和全局变量名字冲突的情况下，局部优先。

四、数据类型

C语言的数据类型分为 基本数据类型、构造数据类型、指针类型 和 空类型。

4.1、基本数据类型

C 通过识别一些基本的数据类型来区分和使用这些不同的数据类型。K&C 给出了 7 个与类型相关的关键字。C90 标准添加了 2 个关键字，C99 标准又添加了 3 个关键字。

最初 K&C 给出的关键字	C90标准添加的关键字	C99标准添加的关键字
int	signed	_Bool
long	void	_Complex
short		_Imaginary
unsigned
char
float
double

在 C 语言中，用 int 关键字来表示 基本的整数类型。后 3 个关键字（long、short 和 unsigned）和 C90 新增的 signed 用于提供基本整数类型的变式，例如 unsigned short int 和 long long int。char 关键字用于指定字母和 其它字符（如，#、$、%等）。另外，char 类型也可以表示较小的整数。float、double 和 long double 表示 带小数的数。 _Bool 类型表示布尔值（true 或 false），_Complex 和 _Imaginary 分别表示复数和虚数。

4.1.1、整型类型

整形用于表示没有小数部分的数值，允许是负数。计算机以二进制数字存储整数。C 语言中提供了以下几个类型：short、int、long、long long；C 语言的整型常量默认是 int 型，如果要显示地声明 long 型常量需后加 ‘l’ 或 ‘L’ ，声明 long long 型常量需后加 ‘ll’ 或 ‘LL’。

数据类型	占用空间
[signed] short [int]（有符号短整型）	2 字节，取值范围：-32768~32767
unsigned short [int]（无符号短整型）	2 字节，取值范围：0~65535
[signed] int（有符号整型）	通常 4 字节，取值范围：-2147483648~-2147483647
unsigned int（无符号整型）	通常 4 字节，取值范围：0~4294967295
[signed] long [int]（长整型）	4 字节（32位）或 8 字节（64位）
unsigned long [int]（无符号长整型）	4 字节（32位）或 8 字节（64位）
[signed] long long [int]（长长整型）	8 字节
unsigned long long [int]（无符号长长整型）	8 字节

可以使用 printf() 函数打印 int 类型的值。%d 指明了在一行中打印整数的位置。%d 称为转换说明，它指定了 printf() 应使用什么格式显示一个值。格式说明字符串中的每一个 %d 都与待打印变量列表中相应的 int 值匹配，这个值可以是 int 类型的变量、int 类型的常量或其它任何值位 int 类型的表达式。

打印 unsigned int 类型的值，使用 %u 转换说明，打印 long 类型的值，试着用 %ld 转换说明，打印 short 类型的值，使用 %hd 抓转换说明。h 和 l 前缀都可以和 u 一起使用，用于表示无符号类型。

#include <stdio.h>

int main(void)
{
    short int s = 10;       // int可以省略
    int i = 10;             // int可以省略
    long int l = 10;        // int可以省略
    long long int ll = 10;  // int可以省略
    signed int a = -10;     // 定义一个有符号整数，signed可以省略
    unsigned int b = 10;    // 定义一个无符号整数

    printf("%hd\n",s);      // 输出短整型数据
    printf("%d\n",i);       // 输出一个整型数据
    printf("%ld\n",l);      // 输出一个长整型数据
    printf("%lld\n",ll);    // 输出一个长长整型的数据

    printf("%d\n",a);       // 输出一个有符号的10进制整型
    printf("%u\n",b);       // 输出一个10进制的无符号数

    return 0;
}

我们可以使用 sizeof 关键字来计算数据类型在内存中占用的字节（byte）大小，它的语法格式如下：

sizeof(数据类型)

或

sizeof(变量名)

#include <stdio.h>

int main(void)
{
    // sizeof计算数据类型在内存中占用的字节大小
    // 语法格式：sizeof(数据类型) 或 sizeof(变量名)
    // %zu 输出一个无符号整型数据
    printf("短整型：%zu\n",sizeof(short));
    printf("整型：%u\n",sizeof(int));
    printf("长整型：%zu\n",sizeof(long));
    printf("长长整型：%zu\n",sizeof(long long));

    return 0;
}

整型的数据在内存中占的字节数与所选择的操作系统有关。虽然 C 语言标准中没有明确规定整型数据的长度，但 long 类型整数的长度不能短于 int 类型，short 类型整数的长度不能长于 int 类型，即 short <= int <= long < long long。

通常，int 被设置为目标计算机而言最为 “自然” 的长度。自然长度指的是计算机处理起来效率最高的长度。如果没有非常有说服力的理由来选择其它类型，则应该使用 int 类型。如果变量的值不可能为负，则可以使用无符号类型，这样变量可以表示更大的数。如果知道变量可能表示的整数值大于 16 位整数的最大可能值，则推荐使用 long 类型。如果要存储的值超过 20 亿，推荐使用 long long 类型。由于 short 比 int 小，使用 short 可以节省内存。通常仅当有大型整型数组是，才有必要使用 short。

当一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转换。但当一个大的数据类型赋值给一个小的数据类型，那么就可能丢失高位。

4.1.2、浮点类型

浮点类型用于表示小数部分的数值。计算机把浮点数分成小数部分和指数部分来表示，而且分开存储这两部分。计算机在内部使用二进制和 2 的幂进行储存。C 语言中浮点类型常量默认是 double 类型，也可以在浮点数值后面添加后缀 ‘d’ 或 ‘D’ ；声明 float 类型的常量，需后加 ‘f’ 或 ‘F’。声明 long double 类型的常量，需后加 ‘l’ 或 ‘L’。double 型变量所表示的浮点数比 float 型变量更加精确。

因为在任何区间内都存在无穷多个实数，所以计算机的浮点数不能表示区间内的所有值。因此，浮点数通常只是实际值的近似值。浮点类型不能准确的表达一个浮点数，可能会有舍入误差。

浮点型常量的基本形式是：有符号的数字（包括小数点），后面紧跟 e 或 E，最后一个有符号数表示 10 的指数，如：-1.56E+12 和 2.87e-3。正号可以省略。可以没有小数点（如，2E5）或指数部分（19.28），但是不能同时省略两者。可以省略小数部分（如，3.E16）或整数部分（如，.45E-6），但是不能同时省略两者。

C99 标准提出了一种新的浮点型常量格式，即用十六进制表示浮点型常量，在十六进制数前面加上十六进制前缀（0x 或 0X），用 P 和 P 分别代替 e 和 E，用 2 的幂代替 10 的幂（p表示法），如 0xa.1fp10

数据类型	占用空间
float（单精度类型）	4 个字节，取值范围：1.2E-38 到 3.4E+38，6 位有效位
double（双精度类型）	8 个字节，取值范围：2.3E-308 到 1.7E+308，15 位有效位
long double（长双精度类型）	16 字节，取值范围：3.4E-4932 到 1.1E+4932，19 位有效位

printf() 函数使用 %f 转换说明打印十进制计数法的 float double 类型浮点数，用 %e 打印指数计数法的浮点数。如果系统支持十六进制格式的浮点数，可用 a 和 A 分别代替 e 和 E。打印 long double 类型要使用 %Lf、%Le 或 %La 转换说明。

#include <stdio.h>

int main(void)
{
    float f = 3.14f;
    double d = 3.14;
    long double ld = 3.14L;

    printf("%f\n",f);
    printf("%lf\n",d);
    printf("%lf\n",ld);

    printf("float：%zu\n",sizeof(float));
    printf("double：%zu\n",sizeof(double));
    printf("long double：%zu\n",sizeof(ld));

    return 0;
}

C 语言规定，float 类型必须至少能表示 6 位有效数字，且取值范围最少是 1.0e-37 ~ 1.0e+37，float 表示的数值的范围比 long 还大。double 类型和 float 类型的最小取值范围相同，但至少必须能表示 10 位有效数字。一般情况下，double 占用 64 位而不是 32 位。C 只保证 long double 类型至少与 double 类型的精度相同；

浮点类型只能使用 long 说明符，其它说明符（short、signed、unsigned）都是不可用的；

4.1.3、字符类型

字符型变量用于存储一个单一字符，在 C 语言中用 char 表示，其中每个字符变量都会占用 1 个字节。char 类型的字面量值要用一对单引号（’ '）括起来，内部只能写一个字符。

字符型变量实际上并不是把该字符本身放到变量的存储单元中去，而是将 该字符对应的 ASCII 编码放到变量的存储单元中。char 的本质就是一个 1 字节大小的整型，取值范围为：-128 ~ 127；我们可以直接给 char 类型的变量赋值一个整数，在输出时，可以按照 ASCII 码输出。char 类型的变量还可以进行运算，相当于一个整数。

数据类型	占用空间
signed char	1 字节，取值范围：-128 ~ 127
unsigned char	1 字节，取值范围：0 ~ 255

在这里插入图片描述

printf() 函数用 %c 指明待打印的字符。如果用 %d 转换说明打印 char 类型的变量，打印的是一个整数。而 %c 转化说明告诉 printf() 打印该整数值对应的字符。

#include <stdio.h>

int main(void)
{
    // 定义字符变量
    char ch = 'a';
    unsigned char uch = 97;

    // 格式化输出，%c输出字符型数据
    printf("字符：%c\n",ch);
    // 打印字母对应的ASCII码
    printf("ANSCII：%d\n",ch);

    printf("%c\n",uch);
    printf("%d\n",uch);

    printf("字符型：%zu\n",sizeof(ch));

    return 0;
}

在 C 语言中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，这种字符称为 转义字符。

转义字符	含义	ASCII码值（十进制）
\a	警报	007
\b	退格，将当前位置移到前一列	008
\f	换页，当当前位置移到下页开头	012
\n	换行，将当前位置移到下一行开头	010
\r	回车，将当前位置移到本行开头	013
\t	水平制表符，跳到下一个 tab 位置	009
\v	垂直制表符	011
\\	代表一个反斜线字符，\	092
\’	代表一个单引号字符，’	039
\"	代表一个双引号字符，"	034
\?	代表一个问号，?	063
\0	数字 0	000
\ddd	ddd 表示 1~3 个八进制的数字	3位 8进制
\xdd	dd 表示 2 个十六进制数字	3位 16进制

#include <stdio.h>

int main(void)
{
    printf("hello world!\n");
    printf("\thello\n");
    printf("鲁迅说：\"这句话我从未说过\"\n");
    printf("子曰：\'学而时习之，不亦说乎！\'\n");
    printf("御坂美琴 夏娜\r木之本樱\n");
    printf("\\\n");
    printf("%%\n");

    return 0;
}

signed 关键字一般用于 char 类型，因为其它基本整数类型在默认情况下都是有符号数。至于 char 是否是 signed 则因编译器而异。所以，char 可能等同于 signed char，也可能等同于 unsigned char；

4.1.4、布尔类型

C99 标准添加了 _Bool 类型，用于表示 布尔值，即逻辑值 true 和 false。因为 C 语言用值 1 表示 true，值 0 表示 false，所以 _Bool 类型实际上也是一种整数类型。但原则上它仅占 1 位存储空间。_Bool 类型的变量只能存储 1（真）或 0（假）。如果把其它非零数值赋值给 _Bool 类型的变量，该变量会被置为 1。

C99 提供了 stdbool.h 头文件，该头文件让 bool 成为 _Bool 的别名，而且还把 true 或 false 分别定义为 1 或 0 的符号常量。

#include <stdio.h>
#include <stdbool.h>

int main(void)
{
    _Bool a = true;
    bool b = false;

    if(a)
        printf("a is true\n");
    else
        printf("a is false\n");

    if(b)
        printf("b is true\n");
    else
        printf("b is false\n");

    return 0;
}

4.1.5、复数和虚数类型

C99 标准支持 复数类型 和 虚数类型。C 语言中有 3 中复数类型：float_Complex、double_Complex 和 long double_Complex。例如，float_Complex 类型的变量应包含两个 float 类型的值，分别表示复数的实部和虚部。C 语言的 3 中虚数类型是 float_Imaginary、double_Imaginary 和 long double_Imaginary。

如果包含 complex.h 头文件，便可以 complex 代替 _Complex，用 imaginary 代替 _Imaginary，还可以用 I 代替 -1 的平方根。

4.2、基本数据类型转换

4.2.1、隐式类型转换

①、初始化和赋值进行的转换

C 语言允许将一种类型的值赋给另一种类型的变量。这样做时，值将被转换为接收变量的类型。此时，将一个值赋给取值范围更大的类型通常不会导致什么问题，只是占用更多的字节而已。然后，将一个大的值赋值给取值范围小的类型将对导致降低精度。

潜在的数值转换问题：

转换	潜在的问题
将较大的浮点类型转换为较小的浮点类型	精度（有效位）降低，值可能超出目标类型的取值范围，在这种情况下，结果将是不确定的
将浮点类型转换为整型	小数部分丢失，原来的值可能超出目标类型的取值范围，在这种情况下，结果将是不确定的
将较大的整型转换为较小的整型	原来的值可能超出目标类型的取值范围，通常只复制右边的字节 ①、C语言中，基本的转换规则如下：

②、表达式中的转换

当同一个表达式中包含两种不同的算术类型时，C 语言将执行两种自动转换：首先，一些类型在出现时便会自动转换；其次，有些类型在于其它类型同时出现在表达式中时将被转换。

在计算表达式时，C 语言将 bool、char、unsigned char、signed char 和 short 值转换为 int。具体来说，true 被转换为 1，false 被转换为 0。这些转换被称为 整型提升（integral pormotion）。如果 short 比 int 短，则 unsigned short 被转换为 int。如果两种类型的长度相同，则 unsigned short 类型将被转换为 unsigned int。wchar_t 被提升为下列类型中第一个宽度足够存储 wchar_t 取值范围的类型：int、unsigned int、long 或 unsigned long。

当运算涉及两种类型时，较小的类型将被转换为较大的类型。

如果有一个操作数的类型时 long double，则将另一个操作数转换为 long double。
否则，如果有一个操作数的类型是 double，则将另一个操作数转换为 double。
否则，如果有一个操作数的类型是 float，则将另一个操作数转换为 float。
否则，说明操作数都是整型，因此执行整型提升。
在这种情况下，如果两个操作数都是有符号或无符号的，且其中一个操作数的级别比另一个低，则转换为级别高的类型。
如果一个操作数为有符号的，另一个操作数为无符号的，且无符号操作数的级别比有符号操作数高，则将有符号操作数转换为无符号操作数所属的类型。
否则，如果有符号类型则可以表示无符号类型的所有可能取值，则将无符号操作数转换为有符号操作数所属的类型。
否则，将两个操作数都转换为有符号类型的无符号版本。

类型的级别从高至低依次是 long double、double、float、unsigned long long、long long、unsigned long、long、unsigned int、int。之所以 short 和 char 没有列出，是因为它们已经被升级到 int 或 unsigned int 。

#include <stdio.h>

int main(void)
{
    char ch;
    int i;
    float f1;
  
    f1 = i = ch = 'C';
    printf("ch = %c, i = %d, f1 = %2.2f\n", ch, i, f1);

    ch = ch + 1;
    i = f1 + 2 * ch;
    f1 = 2.0 * ch + i;
    printf("ch = %c, i = %d, f1 = %2.2f\n", ch, i, f1);

    ch = 1107;
    printf("Now ch = %c\n", ch);

    ch = 80.89;
    printf("Now ch = %c\n", ch);
  
    return 0;
}

第 9 行和第 10 行：字符 ‘C’ 被作为 1 字节的 ASCII 码值储存在 ch 中。整数变量 i 接受由 ‘C’ 转换的整数，即按 4 字节储存 67。最后，f1 接受由 67 转换的浮点数 67.00；
第 12 行和第 15 行：字符变量 ‘C’ 被转换成整数 67，然后加 1。计算结果是 4 字节整数 68，被截断成 1 字节储存在 ch 中。根据 %c 转换说明打印时，68 被解释成 ‘D’ 的 ASCII 码。
第 13 行和第 15 行：ch 的值被转换为 4 字节的整数（68），然后 2 乘以 ch。为了和 f1 相加，乘积整数（136）被转换为浮点数。计算结果（203.00f）被转换成 int 类型，并储存在 i 中。
第 14 行和第 15 行：ch 的值（‘D’，或 68）被转换为浮点数，然后 2 乘以 ch。为了做加法，i 的值（203）被转换为浮点类型。计算结果（339.00）被储存在 f1 中。
第 17 行和第 18 行：演示了类型降级的示例。把 ch 设置为一个超过其范围的值，忽略额外的位后，最终 ch 的值时字符 S 的 ASCII 码。或者，更确切地说，ch 的值是 1107 % 265，即 83。
第 20 行和第 21 行：演示了另一个类型降级的示例。把 ch 设置为一个浮点数，发生截断后，ch 的值是字符 P 的 ASCII 码。

有多种类型的数据混合运算时，系统首先会自动将所有数据转换成精度最大的那种数据类型，然后再进行计算；

若两种类型的字节数不同，转换成字节数大的类型，若两种类型的字节数相同，且一种有符号，一种无符号，则转成成无符号类型；

在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换成左边量的类型，如果右边变量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入；

4.2.2、强制类型转换

强制类型转换就是自动类型提升运算的逆运算；我们需要 使用强转符：() 来强制转换；它的格式如下：

(目标数据类型)被强转的数据;

#include <stdio.h>

int main(void)
{
    int i1 = 353;
    char ch = (char)i1;

    float f = 3.14f;
    double d = (int)f;

    printf("%d\n",ch);
    printf("%lf\n",d);

    return 0;
}

强制类型转换可能会损失精度，导致数据错误；

强制类型转换操作不会改变操作数本身；

4.3、字符串类型

字符串（character string）是一个或多个字符的序列，它使用一对双引号包裹起来，以 ‘\0’ 作为字符串的结束标志。C 语言中没有专门用于存储字符串的变量类型，我们可以使用 字符数组 来保存字符串，也就是使用一个一维字符数组保存字符串中的每一个字符。此时，编译器会自动为其添加 ‘\0’ 作为结束符。

数组由连续的存储单元组成，字符串的字符被储存在相邻的存储单元中，每个单元储存一个字符。数组末尾位置的字符 ‘\0’。这是空字符（null character），C语言用它标记字符串的结束。空字符不是数字 0 ，它是非打印字符，其 ASCII 码值是（或等价于）0。C 中的字符串一定以空字符结束。这意味着数组的容量必须至少比待存储字符串的字符数多 1。

#include <stdio.h>

int main(void)
{
    char str[] = "hello world!";
    // 格式化输出，%s输出字符串
    printf("%s\n",str);

    return 0;
}

星光樱梦

关注

23
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录