第三章 数据和C
第三章 数据和C
1. 变量与常量数据
- 常量：有些数据类型在程序使用之前已经预先设定好了，在整个程序的运行过程中没有变化，这些称为常量。
- 变量：有此数据类型在程序运行期间可能会改变或被赋值，这些称为变量。
2 数据类型关键字
C通过识别一些基本的数据类型来区分和使用这些不同的数据类型。如果数据是常量，编译器一般通过用户书写的形式来识别类型。但是对变量而言，要在声明时指定其类型。
2.1 C语言的数据类型关键字
| 最初K&R给出的关键字 | C90标准添加的关键字 | C99标准添加的关键字 |
|---|---|---|
| int | signed | _Bool |
| long | void | _Complex |
| short | _Imaginary | |
| unsigned | ||
| char | ||
| float | ||
| double |
在C语言中，用int关键字来表示基本的整数类型，long、short、unsigned和C90新增的signed用于提供基本整数类型的变式，另外char类型也可以表示较小的整数，float、double和long double表示带小数点的数。Bool类型表示布尔值(true或false), _Complex和_Imaginary分别表示复数和虚数。
按计算机的储存方式可分为两大基本类型:整数类型和浮点类型。
位、字节和字
位、字节和字描述计算机数据单元或存储单元的术语。这里主要指存储单元。
最小的存储单元是位(bit),位是计算机内存的基本构建块。
字节(byte)是常用的计算机存储单位，对于几乎所有的机器，1字节等于8位。
字(word)是设计计算机时给定的自然存储单元。
2.2 整数和浮点数
2.2.1 整数
在C语言中整数是没有小数部分的数。比如：2、-23和2345都是整数，而3.14、0.22和2.000都不是整数。计算机以二进制存储整数。
2.2.2 浮点数
在一个数后面加一个小数点，该数就成为一个浮点数，例如：7是整数，7.0是浮点数。
计算机把浮点数分成小数部分和指数部分来表示，而且分开储存这两部分。因为虽然7.00和7在数值上相同，但是它们的储存方式不同。在十进制下，可以把7.0写成0.7E1。这里0.7是小数部分，1是指数部分。
整数和浮点数的区别
- 整数没有小数部分，浮点数有小数部分。
- 浮点数可以表示的范围比整数大。
- 对于一些算术运算，浮点数损失的精度更多。
- 浮点数据通常只是实际值的近似值。
- 在过去(CPU不包含浮点处理器)，浮点运算比整数运算慢。
3 C语言基本数据类型
3.1 int 类型
int类型有符号整形，即int类型的值必须是整数，可以是正整数 、负整数或零。
3.1.1 声明int变量
先写int然后写变量名，最后加上一个分号，要声明多个变量，可以单独声明每个变量，也可以在int后面列出多个变量名，变量名用逗号分隔。
int erns; 声明单个
int hogs, cows, goats; 声明多个
变量赋值
第1种方法：声明完赋值
int cows;
cows=112;
第2种方法:初始化变量
初始化变量就是为变量赋一个初始值，在C语言中初始化可以直接在声明中完成。只需要在变量后面加上赋值运算符(=)和待赋值给变量的值即可
int hogs = 21;
int cows = 32, goats = 14;
int dogs,cats = 94; /*有效，但不建议，它只初始化了cats的值，并未初始化dogs的值。此写法会让人误认为dogs也被初始化为94*/
两种赋值的区别：
第一种声明为变量创建和标记存储空间，但并没有指定初始值，第二种声明为变量创建和标记存储空间，并为其指定初始值。
3.1.2 int类型常量
C语言把不含小数点和指数的数作为整数。C语言把大多数整型常量视为int类型，但是非常大的整数除外。
3.1.3 打印int值
可以使用printf()函数打印int类型的值，%d指明了在一行中打印整数的位置，%d称为转换说明，它指定了printf()使用什么格式来显示一个值。
[root@hans ~]# cat print1.c
#include <stdio.h>
int main(void)
{
int ten = 10;
int two = 2;
printf("Doing it right: ");
printf("%d minus %d is %d\n", ten, 2, ten - two);
printf("Doing it wrong: ");
printf("%d minus %d is %d\n", ten);
return 0;
}
[root@hans ~]# gcc -o print1 print1.c
[root@hans ~]# ./print1
Doing it right: 10 minus 2 is 8
Doing it wrong: 10 minus 1853999616 is 1852403524
打印出来的第二行，由于写了三个%d,但只给了一个ten变量，后面两个没有提供任何值，所以打印出的值是内存中的任意值。
使用printf()函数时，要三确保转换说明的数量与待打印值的数量相等
3.2 其他整数类型
C语言提供了3个附属关键字修饰基本整数类型:short、long和unsigned.
- short int 类型(简写为short)占用的存储空间可能比int类型少，常用物较小数值的场合以节省空间。与int类似，short是有符号类型。
- long int 类型(简写为long)占用的存储空间可能比int类型多，适用于较大数值的场合，与int类似，long是有符号类型。
- unsigned int 只用于非负值的场合。这种类型与有符号类型表示的范围不同。比如16位unsigned int 允许的取值范围是
0~65535,而不是-32768~32767,所以符号整型可以表示更大的数。
在C90标准中，添加了unsigned long int和unsigned short into类型，在C99标准又添加了unsigned long long int。
在任何有符号类型前面添加关键字signed可强调使用有符号类型的意图。
3.2.1 声明其他整数类型
其他整数类型的声明与int类型相同。
long int estine;
long johns;
short int erns;
short ribs;
unsigned int s_count;
unsigned players;
unsigned long headcount;
unsigned short yesvotes;
long long age; #C99标准新增。
3.2.2 使用多种整数类型的原因
C语言只规定了short 占用的存储空间不能多于int, long占用的存储空间不能少于int。这样规定是为了适应不同的机器。在windows3.x的机器上，int类型和short类型都占16位,long类型占32位，后来windows和苹果都使用16位存储short类型，32位存储int和long,现在普遍使用64位处理器，为了存储64位的整数，才引入了long long类型。
现在个人计算机最常见的设置是:long long 占64位，long占32位，short占16位，int占16或32位。
如何选择合适的int类型：
- 首先考虑unsigned类型，这种类型常用于计数，因为计数不用负数，而且无符号类型可以表示更大的值。
- 如果一个数超过了int类型的取值范围，且在long类型的取值范围内时使用long类型。(在long占用空间比int大的系统时使用long类型会减慢运算速度，如果在long类型与int类型占用空间相同的机器上，确实需要32位整数时，应用long，以便把程序移植到16位机后仍然可以运行。)
3.2.3 long常量和long long常量
在使用long类型时在值的末尾加上l或L做后缀，建议使用L，因为小写的L和1很像。
在支持long long的系统中，可以使用ll或LL后缀。
u或U后缀表示unsigned。如5ULL,6LLU
注意
如果整数超出了相应类型的取值范围会怎么样?
[root@hans ~]# cat toobig.c
#include <stdio.h>
int main(void){
int i = 2147483647;
unsigned int j = 4294967295;
printf("%d %d %d\n", i, i+1, i+2);
printf("%u %u %u\n", j, j+1, j+2);
return 0;
}
[root@hans ~]# ./toobig
2147483647 -2147483648 -2147483647
4294967295 0 1
把无符号整数j看作是汽车的里程表，当达到它能表示的最大值时，全重新从起始点开始。整数i也一样。
无符号和有符号的区别是:
unsigned int类型j从0开始，而int i从-2147483648开始。
3.2.4 打印short、long、long long和unsigned类型
打印int类型的值使用%d转换说明;
打印unsigned int类型的值使用%u转换说明;
打印long类型的值使用%ld转换说明(如何long int和int的大小相同使用%d就行)。
打印十六进制格式long类型: %lx
打印八进制格式long类型:%lo
打印short类型整数使用h前缀，%hd表示以十进制显示short类型的整数，%ho表示以八进制显示short类型的整数，h和l前缀都可以和u一起使用，表示无符号类型，%lu表示unsigned long类型的值。
注意: 虽然C允许使用大写或小写的常量后缀，但是在转换说明中只能用小写。
[root@hans ~]# cat print2.c
#include <stdio.h>
int main(void){
unsigned int un = 3000000000;
short end = 200;
long big = 65537;
long long verybig = 12345678908642;
printf("un = %u and not %d\n",un, un);
printf("end = %hd and %d\n",end,end);
printf("big = %ld and not %hd\n",big,big);
printf("verybig = %lld and not %ld\n",verybig,verybig);
return 0;
}
[root@hans ~]#
[root@hans ~]# ./print2
un = 3000000000 and not -1294967296
end = 200 and 200
big = 65537 and not 1
verybig = 12345678908642 and not 12345678908642
3.3 char 类型
char类型用于储存字符(字母或标点符号)，但从技术层来看char是整数类型，因为 char类型实际上储存的是整数而不是字符，计算机使用数字编码来处理字符，即ASCII编码。
ASCII编码
Oct Dec Hex Char Oct Dec Hex Char
────────────────────────────────────────────────────────────────────────
000 0 00 NUL '\0' 100 64 40 @
001 1 01 SOH (start of heading) 101 65 41 A
002 2 02 STX (start of text) 102 66 42 B
003 3 03 ETX (end of text) 103 67 43 C
004 4 04 EOT (end of transmission) 104 68 44 D
005 5 05 ENQ (enquiry) 105 69 45 E
006 6 06 ACK (acknowledge) 106 70 46 F
007 7 07 BEL '\a' (bell) 107 71 47 G
010 8 08 BS '\b' (backspace) 110 72 48 H
011 9 09 HT '\t' (horizontal tab) 111 73 49 I
012 10 0A LF '\n' (new line) 112 74 4A J
013 11 0B VT '\v' (vertical tab) 113 75 4B K
014 12 0C FF '\f' (form feed) 114 76 4C L
015 13 0D CR '\r' (carriage ret) 115 77 4D M
016 14 0E SO (shift out) 116 78 4E N
017 15 0F SI (shift in) 117 79 4F O
020 16 10 DLE (data link escape) 120 80 50 P
021 17 11 DC1 (device control 1) 121 81 51 Q
022 18 12 DC2 (device control 2) 122 82 52 R
023 19 13 DC3 (device control 3) 123 83 53 S
024 20 14 DC4 (device control 4) 124 84 54 T
025 21 15 NAK (negative ack.) 125 85 55 U
026 22 16 SYN (synchronous idle) 126 86 56 V
027 23 17 ETB (end of trans. blk) 127 87 57 W
030 24 18 CAN (cancel) 130 88 58 X
031 25 19 EM (end of medium) 131 89 59 Y
032 26 1A SUB (substitute) 132 90 5A Z
033 27 1B ESC (escape) 133 91 5B [
034 28 1C FS (file separator) 134 92 5C \ '\\'
035 29 1D GS (group separator) 135 93 5D ]
036 30 1E RS (record separator) 136 94 5E ^
037 31 1F US (unit separator) 137 95 5F _
040 32 20 SPACE 140 96 60 `
041 33 21 ! 141 97 61 a
042 34 22 " 142 98 62 b
043 35 23 # 143 99 63 c
044 36 24 $ 144 100 64 d
045 37 25 % 145 101 65 e
046 38 26 & 146 102 66 f
047 39 27 ´ 147 103 67 g
050 40 28 ( 150 104 68 h
051 41 29 ) 151 105 69 i
052 42 2A * 152 106 6A j
053 43 2B + 153 107 6B k
054 44 2C , 154 108 6C l
055 45 2D - 155 109 6D m
056 46 2E . 156 110 6E n
057 47 2F / 157 111 6F o
060 48 30 0 160 112 70 p
061 49 31 1 161 113 71 q
062 50 32 2 162 114 72 r
063 51 33 3 163 115 73 s
064 52 34 4 164 116 74 t
065 53 35 5 165 117 75 u
066 54 36 6 166 118 76 v
067 55 37 7 167 119 77 w
070 56 38 8 170 120 78 x
071 57 39 9 171 121 79 y
072 58 3A : 172 122 7A z
073 59 3B ; 173 123 7B {
074 60 3C < 174 124 7C |
075 61 3D = 175 125 7D }
076 62 3E > 176 126 7E ~
077 63 3F ? 177 127 7F DEL
C语言把1字节定义为char类型占用的位(bit)数，因此无论是16位还是32位系统，都可以使用char类型。
3.3.1 声明char类型变量
char response;
char itable, latan;
char grade = 'A'; #声明并初始化值
在C语言中，用单引号括起来的单个字符被称为字符常量，编译器一发现'A',就将其转换成相应的代码值，给char类型赋值时单引号必不可少。
char broiled;
broiled = 'T'; #正确赋值
broiled = T; #错误，此时T是一个变量
broiled = “T”; #错误，此时T是个字符串
char grade = 65; #虽然对于 ASCII码来说这样没问题，但这是一种不好的编程风格
例子:
[root@hans ~]# cat print3.c
#include <stdio.h>
int main(void){
char grade1 = 'A';
char grade2 = 65;
printf("grade1: %c\n", grade1);
printf("grade2: %c\n", grade2);
return 0;
}
[root@hans ~]# ./print3
grade1: A
grade2: A
3.3.2 非打印字符
单引号只适用于字符、数字和标点符号，在ASCII码中有一些字符是打印不出来的，如代表行为的字符(退格、换行、终端响或蜂鸣)。
C语言提供了3种方法表示这些字符。
-
使用ASCII，比如蜂鸣字符的ASCII值是7，可以写成
char beep = 7; -
使用特殊字符序列表示一些特殊的字符，,这些符号序列叫作转义序列。
转义序列 表示 \a 响铃（警报） \b Backspace \f 换页,把活跃位置移至下一页的开始处 \n 换行，把活跃位置移至下一行的开始处 \r 回车，把活跃位置移至当前行的开始处 \t 水平制表符，把活跃位置移至到下一个水平制表点(通常是第1个，第9个，第17，25个等字符位置) \v 垂直制表符，把活跃位置移至下一个垂直制表点 \' 单引号 \" 双引号 \\ 反斜杠 \? 文本问号 \ooo 八进制表示法的 ASCII 字符(后面两个00必须是有效的八进制数) \xhh 十六进制表示法的 ASCII 字符(hh必须是有效的十六进制数) -
使用十六进制形式表示字符常量
int系列类型的常量写法示例
类型 十六进制 八进制 十进制 char \0x41 \0101 N.A. int 0x41 0101 65 unsigned int 0x41u 0101u 65u long 0x41L 0101L 65L unsigned long 0x41UL 0101UL 65UL long long 0x41LL 0101LL 65LL unsigned long long 0x41ULL 0101ULL 65ULL 在使用ASCII码时，注意数字和数字字符的区别:字符4对应的ASCII码是52。'4'表示字符4，而不是数字4.
3.3.3 打印字符
打印字符使用%c。
定义char类型打印%c和%d的区别
[root@hans ~]# cat charcode.c
#include <stdio.h>
int main(void){
char ch;
printf("Please enter a character.\n");
scanf("%c",&ch);
printf("The code for %c is %d.\n", ch, ch);
return 0;
}
[root@hans ~]# ./charcode
Please enter a character.
C
The code for C is 67.
3.3.4 有符号还是无符号
根据C90标准，C语言允许在关键字char前面使用signed或unsigned。
3.4 _Bool类型
C99标准添加了_Bool类型，用于表示布尔值，即true和false,1表示true,0表示false。
_Bool类型实际上也是一种整数类型，原则上它仅占用1位存储空间。
3.5 float、double和long double
C标准规定，float类型必须至少能表示6位有效数据，且取值范围至少是10-37～10+37
C语言提供的另一种浮点类型是double(双精度)，它和float类型的最小取值范围相同，但至少必须能表示10位有效数字。一般情况下double占用64位。
C语言的第3种浮点类型是long double，以满足比double类型更高的精度要求。(C只保证long double类型至少与 double类型的精度相同)
3.5.1 声明浮点类型变量
float noah, jonah;
double trouble;
float planck = 6.63;
long double gnp;
3.5.2 浮点型常量
浮点型常量的基本形式是:有符号的数字(包括小数点)，后面紧跟e或E，最后一个有符号数表示10的指数。例如:
-1.56E+12
2.87e-3
1.56 E+12 #错误，不能在浮点型常量中间加空格
默认情况下编译器假定浮点型常量是double类型的精度。比如4.0X2.0 被储存为64位的double类型，使用双精度进行乘法运算，然后将乘积截断成float类型的宽度，这样虽然计算精度更高，但会减慢程序的运行速度。
3.5.3 打印浮点值
使用%f转换说明打印十进制记数法的float和double类型的浮点数。
用%e打印指数记数法的浮点数。如果系统支持十六进制格式的浮点数，可用a和A分别代替e和E。打印long double类型要使用%Lf、%Le或%La转换说明。
[root@hans ~]# cat showf_pc.c
#include <stdio.h>
int main(void){
float aboat = 32000.0;
double abet = 2.14e9;
long double dip = 5.32e-5;
printf("%f can be written %e\n", aboat, aboat);
printf("And it's %a in hexadecimal, powers of 2 notation\n", aboat);
printf("%f can be written %e\n", abet, abet);
printf("%Lf can be written %Le\n", dip, dip);
return 0;
}
[root@hans ~]# ./showf_pc
32000.000000 can be written 3.200000e+04
And it's 0x1.f4p+14 in hexadecimal, powers of 2 notation
2140000000.000000 can be written 2.140000e+09
0.000053 can be written 5.320000e-05
3.5.4 浮点值的上溢和下溢
当计算导致数字过大，超过当前类型能表达的范围时就会发生上溢。
[root@hans ~]# cat overflow.c
#include <stdio.h>
int main(void){
float toobig = 3.4E38 * 100.0f;
printf("%e\n", toobig);
return 0;
}
[root@hans ~]# ./overflow
inf
当计算一个数字时虽然 得到了结果 ，但是在计算过程中却损失了原末尾有效位上的数字。这种情况叫作下溢。
例如0.1234E-10除以10，虽然能得到0.01234E-10,得却损失了原末尾有效位上的数字
浮点数舍入错误
一个数加上1，再减去这个数，结果是多少?
[root@hans ~]# cat floaterr.c #include <stdio.h> int main(void){ float a,b; b = 2.0e20 + 1.0; a = b - 2.0e20; printf("%f \n"); return 0; } [root@hans ~]# ./floaterr 0.000000 #Linux 上面得到这个值。别的上面得到的可能和这个不同。为什么不是1.而得到不同的答案，就是因为计算机缺少足够的小数位来完成正确的运算，2.0e20是2后面有20个0加上1，则是在第21位，float类型的数字通常只能储存按指数比例缩小或放大6或7位有效数字，但计算机的数字有21位，所以计算结果错误。
3.6 复数和虚数类型
C语言有3种复数类型:float_Complex、double_Complex和long double _Complex.复数有实部和虚部。
C语言有3种虚数类型:float_Imaginary、double_Imaginary和long double_Imaginary.
3.7 其他类型
数组、指针、结构体和联合。
3.8 类型的大小
如何知道当前系统指定类型的大小？
[root@hans ~]# cat typesize.c
#include <stdio.h>
int main(void){
printf("Type int has a size of %zd bytes.\n", sizeof(int));
printf("Type char has a size of %zd bytes.\n", sizeof(char));
printf("Type long has a size of %zd bytes.\n", sizeof(long));
printf("Type long long has a size of %zd bytes.\n", sizeof(long long));
printf("Type double has a size of %zd bytes.\n", sizeof(double));
printf("Type long double has a size of %zd bytes.\n", sizeof(long double));
return 0;
}
[root@hans ~]# ./typesize
Type int has a size of 4 bytes.
Type char has a size of 1 bytes.
Type long has a size of 8 bytes.
Type long long has a size of 8 bytes.
Type double has a size of 8 bytes.
Type long double has a size of 16 bytes.
3.9 基本数据类型小结
基本数据类型由11个关键字组成:
int、long、short、unsigned、char、float、double、signed、_Bool、_Complex和_Imaginary有符号整型：可用于表示正整数和负整数。
无符号整型：只表示零和正整数。无符号整型表示的正整数比有符号整型的大。
字符类型：char 占一个字节
布尔类型：true和false,1表示true,0表示false.
实浮点类型: 正浮点数和负浮点数。
float 类型精确表示至少6位有效数字
double 至少10位有效数字，通常会更多。
long double 比double更大
复数和虚数浮点数：虚数类型是可选的类型。复数的实部和虚部类型都基于实浮点类型来构成。
如何声明简单变量
选择需要的类型
使用有效的字符给变量起一个变量名
按以下格式声明：
类型说明符 变量名
可同时声明相同类型的多个变量，用逗号分隔各变量名
可以在声明时初始化变量。
3.10 转义序列示例
[root@hans ~]# cat escape.c
#include <stdio.h>
int main(void){
float salary;
printf("\aEnter your desired monthly salary:");
printf(" $_________\b\b\b\b\b\b\b");
scanf("%f",&salary);
printf("\n\t$%.2f a month is $%.2f a year.", salary,salary * 12.0);
printf("\rGee!\n");
return 0;
}
[root@hans ~]# ./escape
Enter your desired monthly salary: $__100.2__
Gee! $100.20 a month is $1202.40 a year.
4 编程练习
4.1
[root@hans ~]# cat overunderflow.c
#include <stdio.h>
int main(viod){
int a = 2147483647;
float b = 3.4E38 * 100.0f;
float c = (-3.4e-38-10) / 10e100;
printf("a=%d and a overflow is %d\n", a,a + 1);
printf("overflow b=%e \n", b);
printf("underflow c=%e \n", c);
return 0;
}
[root@hans ~]# ./overunderflow
a=2147483647 and a overflow is -2147483648
overflow b=inf
underflow c=-0.000000e+00
4.2
#include <stdio.h>
int main(void){
char num;
printf("Please input a ASCII:");
scanf("%d",&num);
printf("%d is %c\n",num, num);
return 0;
}
[root@hans ~]# ./3.11.2
Please input a ASCII:69
69 is E
4.3
[root@hans ~]# cat 3.11.3.c
#include <stdio.h>
int main(void){
printf("\aStartled by the sudden sound,Sally shouted,\n\"By the Great Pumpkin, what was that!\"\n");
return 0;
}
[root@hans ~]# ./3.11.3
Startled by the sudden sound,Sally shouted,
"By the Great Pumpkin, what was that!"
4.4
[root@hans ~]# cat 3.11.4.c
#include <stdio.h>
int main(viod){
float num;
printf("Enter a float-point value:");
scanf("%f",&num);
printf("fixed-point notation: %f\n", num);
printf("exponential notation: %e\n", num);
printf("p notation: %a\n", num);
return 0;
}
[root@hans ~]# ./3.11.4
Enter a float-point value:64.25
fixed-point notation: 64.250000
exponential notation: 6.425000e+01
p notation: 0x1.01p+6
4.5
[root@hans ~]# cat 3.11.5.c
#include <stdio.h>
int main(viod){
float sen = 3.156E7;
int age;
printf("Please input your age:");
scanf("%d",&age);
printf("age:%d is sen: %.2f\n", age, sen * age);
return 0;
}
[root@hans ~]# ./3.11.5
Please input your age:30
age:30 is sen: 946800000.00
4.6
[root@hans ~]# cat 3.11.6.c
#include <stdio.h>
int main(void){
float water = 3.0E-23;
int weight = 950;
int num;
double waternum;
printf("Please input num:");
scanf("%d",&num);
waternum = num * weight / water;
printf("%d quark contin %e water.\n", num, waternum);
return 0;
}
4.7
[root@hans ~]# cat 3.11.7.c
#include <stdio.h>
int main(void){
float cm = 2.54;
float hight;
printf("Please input hight:");
scanf("%f",&hight);
printf("boby hight%.2fcm\n", hight * cm);
return 0;
}
[root@hans ~]# ./3.11.7
Please input hight:80
boby hight203.20cm
4.8
[root@hans ~]# cat 3.11.8.c
#include <stdio.h>
int main(){
int num;
printf("please input cup number:");
scanf("%d", &num);
printf("%d cup is %d pint\n",num, num / 2 );
printf("%d cup is %d ounce\n", num, num * 8 );
printf("%d cup is %d soupSpoon\n", num, num * 8 * 2 );
printf("%d cup is %d teaSpoon\n", num , num * 8 * 2 * 3 );
return 0;
}
[root@hans ~]# ./3.11.8
please input cup number:2
2 cup is 1 pint
2 cup is 16 ounce
2 cup is 32 soupSpoon
2 cup is 96 teaSpoon
浮点类型比整数类型更适合：因为杯数不能被2整除时显示的品脱的值不正确。
[root@hans ~]# cat 3.11.8.c
#include <stdio.h>
int main(){
float num;
printf("please input cup number:");
scanf("%f", &num);
printf("%.2f cup is %.2f pint\n",num, num / 2 );
printf("%.2f cup is %.2f ounce\n", num, num * 8 );
printf("%.2f cup is %.2f soupSpoon\n", num, num * 8 * 2 );
printf("%.2f cup is %.2f teaSpoon\n", num , num * 8 * 2 * 3 );
return 0;
}
[root@hans ~]# ./3.11.8
please input cup number:3
3.00 cup is 1.50 pint
3.00 cup is 24.00 ounce
3.00 cup is 48.00 soupSpoon
3.00 cup is 144.00 teaSpoon
