C语言数据类型

时间 2020-02-17 标签 c语言数据类型

原文：http://zhidao.baidu.com/question/116383335.html?an=0&si=1linux

C语言各类数据类型及其在系统中占的字节和取值范围2009-08-21 09:53C语言包含5个基本数据类型: void, int, float, double, 和 char. 
（另：C++ 定义了另外两个基本数据类型: bool 和 wchar_t. 
一些基本数据类型可以被 signed, unsigned, short, 和 long 修饰
因此short,long等等都不算基本数据类型。
这是书上说的，因此C++是7种基本数据类型。

空值型是一种，但枚举型不算。缘由就是枚举型可分的，因此不够基本。

不过不一样的书也有不一样的规定，好比C++Primer上就说是bool,char,wchar_t,short,int,long,float,double,long double和void，这个暂时没有定论。)

============================================================

基本类型包括字节型（char）、整型（int）和浮点型（float/double）。

定义基本类型变量时，可使用符号属性signed、unsigned（对于char、int），和长度属性short、long（对

于int、double）对变量的取值区间和精度进行说明。

下面列举了Dev-C++下基本类型所占位数和取值范围：

符号属性 长度属性 基本型 所占位数 取值范围 输入符举例 输出符举例

    -- -- char                            8 -2^7 ~ 2^7-1 %c %c、%d、%u
    
    signed -- char                    8 -2^7 ~ 2^7-1 %c %c、%d、%u
    
    unsigned -- char                8 0 ~ 2^8-1 %c %c、%d、%u
    
    [signed] short [int]            16 -2^15 ~ 2^15-1 %hd
    
    unsigned short [int]           16 0 ~ 2^16-1 %hu、%ho、%hx
    
    [signed] -- int                    32 -2^31 ~ 2^31-1 %d
    
    unsigned -- [int]                 32 0 ~ 2^32-1 %u、%o、%x
    
    [signed] long [int]              32 -2^31 ~ 2^31-1 %ld
    
    unsigned long [int]             32 0 ~ 2^32-1 %lu、%lo、%lx
    
    [signed] long long [int]       64 -2^63 ~ 2^63-1 %I64d
    
    unsigned long long [int]      64 0 ~ 2^64-1 %I64u、%I64o、%I64x
    
    -- -- float                            32 +/- 3.40282e+038 %f、%e、%g
    
    -- -- double                        64 +/- 1.79769e+308 %lf、%le、%lg %f、%e、%g
    
    -- long double                    96 +/- 1.79769e+308 %Lf、%Le、%Lg

几点说明：

1. 注意! 表中的每一行，表明一种基本类型。“[]”表明可省略。

    例如：char、signed char、unsigned char是三种互不相同的类型；
    
    int、short、long也是三种互不相同的类型。
    
    可使用C++的函数重载特性进行验证，如:
    
    void Func(char ch) {}
    
    void Func(signed char ch) {}
    
    void Func(unsigned char ch) {}
    
    是三个不一样的函数。

2. char/signed char/unsigned char型数据长度为1字节；

    char为有符号型，但与signed char是不一样的类型。
    
    注意! 并非全部编译器都这样处理，char型数据长度不必定为1字节，char也不必定为有符号型。

3. 将char/signed char转换为int时，会对最高符号位1进行扩展，从而形成运算问题。

    因此,若是要处理的数据中存在字节值大于127的状况，使用unsigned char较为稳当。
    
    程序中若涉及位运算，也应该使用unsigned型变量。

4. char/signed char/unsigned char输出时，使用格式符%c（按字符方式）；

    或使用%d、%u、%x/%X、%o，按整数方式输出；
    
    输入时，应使用%c，若使用整数方式，Dev-C++会给出警告，不建议这样使用。

5. int的长度，是16位仍是32位，与编译器字长有关。

    16位编译器（如TC使用的编译器）下，int为16位；32位编译器（如VC使用的编译器cl.exe）下，int为32
    
    位。

6. 整型数据可使用%d（有符号10进制）、%o（无符号8进制）或%x/%X（无符号16进制）方式输入输出。

    而格式符%u，表示unsigned，即无符号10进制方式。

7. 整型前缀h表示short，l表示long。

    输入输出short/unsigned short时，不建议直接使用int的格式符%d/%u等，要加前缀h。
    
    这个习惯性错误，来源于TC。TC下，int的长度和默认符号属性，都与short一致，
    
    因而就把这两种类型当成是相同的，都用int方式进行输入输出。

8. 关于long long类型的输入输出：

    "%lld"和"%llu"是linux下gcc/g++用于long long int类型(64 bits)输入输出的格式符。
    
    而"%I64d"和"%I64u"则是Microsoft VC++库里用于输入输出__int64类型的格式说明。
    
    Dev-C++使用的编译器是Mingw32，Mingw32是x86-win32 gcc子项目之一，编译器核心仍是linux下的gcc。
    
    进行函数参数类型检查的是在编译阶段，gcc编译器对格式字符串进行检查，显然它不认得"%I64d"，
    
    因此将给出警告“unknown conversion type character `I' in format”。对于"%lld"和"%llu"，gcc理
    
    所固然地接受了。
    
    Mingw32在编译期间使用gcc的规则检查语法，在链接和运行时使用的倒是Microsoft库。
    
    这个库里的printf和scanf函数固然不认识linux gcc下"%lld"和"%llu"，但对"%I64d"和"%I64u"，它则是
    
    乐意接受，并能正常工做的。

9. 浮点型数据输入时可以使用%f、%e/%E或%g/%G，scanf会根据输入数据形式，自动处理。

    输出时可以使用%f（普通方式）、%e/%E（指数方式）或%g/%G（自动选择）。

10. 浮点参数压栈的规则：float(4 字节)类型扩展成double(8 字节)入栈。

    因此在输入时，须要区分float(%f)与double(%lf)，而在输出时，用%f便可。
    
    printf函数将按照double型的规则对压入堆栈的float(已扩展成double)和double型数据进行输出。
    
    若是在输出时指定%lf格式符，gcc/mingw32编译器将给出一个警告。

11. Dev-C++(gcc/mingw32)能够选择float的长度，是否与double一致。

12. 前缀L表示long（double）。

    虽然long double比double长4个字节，可是表示的数值范围倒是同样的。
    
    long double类型的长度、精度及表示范围与所使用的编译器、操做系统等有关。 

 
====================================================================
（一）32位平台： 
分为有符号型与无符号型。 
有符号型： 
short 在内存中占两个字节，范围为-2^15~（2^15-1) 
int 在内存中占四个字节，范围为-2^31~（2^31-1） 
long在内存中占四个字节，范围为-2^31~2^31-1 
无符号型：最高位不表示符号位 
unsigned short 在内存中占两个字节，范围为0~2^16-1 
unsigned int 在内存中占四个字节，范围为0~2^32-1 
unsigned long在内存中占四个字节，范围为0~2^32-1 
实型变量: 
分单精度 float 和双精度 double 两种形式： 
float:占四个字节，提供7~8位有效数字。 
double: 占八个字节，提供15~16位有效数字。 

（二）16位平台: 
1)整型(基本型)：类型说明符为int，在内存中占2个字节。 
2)短整型：类型说明符为short int或short。所占字节和取值范围均与整型(基本型)相同。 
3)长整型：类型说明符为long int或long，在内存中占4个字节。 
无符号型：类型说明符为unsigned。 
无符号型又可与上述三种类型匹配而构成： 
各类无符号类型量所占的内存空间字节数与相应的有符号类型量相同。但因为省去了符号位，故不能表示负数。 
实型变量: 
分为单精度（float型）、双精度（double型）和长双精度（long double型）三类。
单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，只能提供七位有效数字。 
双精度型占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。 
长双精度型16 个字节（128位）内存空间，可提供18-19位有效数字。
============================================================================
C语言中5种基本数据类型的存储空间长度的排列顺序:
char = signed char = unsigned char < short int = unsigned short int <= int = unsigned int <= long int = unsigned long int  <= long long int = unsigned long long int
float <= double <= long double
用short修饰int时,short int表示短整型,占2字节的数据位.用long修饰int时,long int表示长整型,占4字节的数据位,在vc++6.0中int的数据类型也是占用了4字节的数据位,  那么应用int型与long型有什么区别呢? 下面就让咱们来解答这个问题.咱们知道如今的C++开发工具很是的多,int型在不一样的系统中有可能占用的字节数会不同, 而short与long修饰的int型的字节数是固定的,任何支持标准C++编译系统中都是如此.因此若是须要编写可移植性好的程序,应该将整型数据声明为short与long修饰的int型。





----------------------------------------------------------------------------------------
在Ｃ语言中，数据类型可分为：基本数据类型，构造数据类型，指针类型，空类型四大类。

1.基本数据类型c++

　　基本数据类型最主要的特色是，其值不能够再分解为其它类型。也就是说，基本数据类型是自我说明的。数组

2.构造数据类型构造数据类型app

　　是根据已定义的一个或多个数据类型用构造的方法来定义的。也就是说，一个构造类型的值能够分解成若干个“成员”或“元素”。每一个“成员”都是一个基本数据类型或又是一个构造类型。在C语言中，构造类型有如下几种： ·数组类型 ·结构类型 ·联合类型函数

3.指针类型工具

　　指针是一种特殊的，同时又是具备重要做用的数据类型。其值用来表示某个量在内存储器中的地址。虽然指针变量的取值相似于整型量，但这是两个类型彻底不一样的量，所以不能混为一谈。4.空类型在调用函数值时，一般应向调用者返回一个函数值。这个返回的函数值是具备必定的数据类型的，应在函数定义及函数说明中给以说明，例如在例题中给出的max函数定义中，函数头为： int max(int a,int b);其中“int ”类型说明符即表示该函数的返回值为整型量。又如在例题中，使用了库函数 sin，因为系统规定其函数返回值为双精度浮点型，所以在赋值语句s=sin (x);中，s 也必须是双精度浮点型，以便与sin函数的返回值一致。因此在说明部分，把s说明为双精度浮点型。可是，也有一类函数，调用后并不须要向调用者返回函数值，这种函数能够定义为“空类型”。其类型说明符为void。在第五章函数中还要详细介绍。在本章中，咱们先介绍基本数据类型中的整型、浮点型和字符型。其他类型在之后各章中陆续介绍。post

　　对于基本数据类型量，按其取值是否可改变又分为常量和变量两种。在程序执行过程中，其值不发生改变的量称为常量，取值可变的量称为变量。它们可与数据类型结合起来分类。例如，可分为整型常量、整型变量、浮点常量、浮点变量、字符常量、字符变量、枚举常量、枚举变量。在程序中，常量是能够不经说明而直接引用的，而变量则必须先说明后使用。开发工具

整型量测试

整型量包括整型常量、整型变量。整型常量就是整常数。在Ｃ语言中，使用的整常数有八进制、十六进制和十进制三种。

整型常量

1.八进制整常数八进制整常数必须以0开头，即以0做为八进制数的前缀。数码取值为0～7。八进制数一般是无符号数。如下各数是合法的八进制数： 015(十进制为13)　0101(十进制为65)　0177777(十进制为65535) 如下各数不是合法的八进制数： 256(无前缀0) 03A2(包含了非八进制数码)　-0127(出现了负号)

2.十六进制整常数十六进制整常数的前缀为0X或0x。其数码取值为0~9，A~F或a~f。如下各数是合法的十六进制整常数： 0X2A(十进制为42)　　0XA0 (十进制为160)　　0XFFFF (十进制为65535) 如下各数不是合法的十六进制整常数： 5A (无前缀0X)　　0X3H (含有非十六进制数码)

3.十进制整常数十进制整常数没有前缀。其数码为0～9。如下各数是合法的十进制整常数： 237 -568 65535 1627 如下各数不是合法的十进制整常数： 023 (不能有前导0)　23D (含有非十进制数码)

在程序中是根据前缀来区分各类进制数的。所以在书写常数时不要把前缀弄错形成结果不正确。

4.整型常数的后缀在16位字长的机器上，基本整型的长度也为 16位，所以表示的数的范围也是有限定的。十进制无符号整常数的范围为0～65535，有符号数为-32768～+32767。八进制无符号数的表示范围为0～0177777。十六进制无符号数的表示范围为0X0～0XFFFF或0x0～0xFFFF。若是使用的数超过了上述范围，就必须用长整型数来表示。长整型数是用后缀“L”或“l”来表示的。例如：十进制长整常数 158L (十进制为158) 358000L (十进制为-358000) 八进制长整常数 012L (十进制为10) 077L (十进制为63)　0200000L (十进制为65536) 十六进制长整常数 0X15L (十进制为21) 0XA5L (十进制为165)　0X10000L (十进制为65536)
长整数158L和基本整常数158 在数值上并没有区别。但对158L，由于是长整型量，Ｃ编译系统将为它分配4个字节存储空间。而对158，由于是基本整型，只分配2 个字节的存储空间。所以在运算和输出格式上要予以注意，避免出错。无符号数也可用后缀表示，整型常数的无符号数的后缀为“U”或“u”。例如： 358u,0x38Au,235Lu 均为无符号数。前缀，后缀可同时使用以表示各类类型的数。如0XA5Lu表示十六进制无符号长整数A5，其十进制为165。

整型变量

整型变量可分为如下几类： 1.基本型类型说明符为int，在内存中占2个字节，其取值为基本整常数。 2.短整量类型说明符为short int或short'C110F1。所占字节和取值范围均与基本型相同。 3.长整型类型说明符为long int或long ，在内存中占4个字节，其取值为长整常数。 4.无符号型类型说明符为unsigned。无符号型又可与上述三种类型匹配而构成： (1)无符号基本型类型说明符为unsigned int或unsigned。 (2)无符号短整型类型说明符为unsigned short (3)无符号长整型类型说明符为unsigned long 各类无符号类型量所占的内存空间字节数与相应的有符号类型量相同。但因为省去了符号位，故不能表示负数。下表列出了Turbo C中各种整型量所分配的内存字节数及数的表示范围。类型说明符　　　　数的范围　　　　分配字节数 int 　　　　　　-32768~32767 　　　　■■ short int 　　　-32768~32767 　　　　■■ signed int 　　 -32768~32767 　　　　■■ unsigned int 　 0~65535 　　　　　　 ■■ long int 　-2147483648~2147483647　　■■■■ unsigned long 　0~4294967295 　　　　■■■■ 整型变量的说明变量说明的通常形式为：类型说明符变量名标识符，变量名标识符，...; 例如： int a,b,c; (a,b,c为整型变量) long x,y; (x,y为长整型变量) unsigned p,q; (p,q为无符号整型变量)

在书写变量说明时，应注意如下几点： 1.容许在一个类型说明符后，说明多个相同类型的变量。各变量名之间用逗号间隔。类型说明符与变量名之间至少用一个空格间隔。 2.最后一个变量名以后必须以“；”号结尾。 3.变量说明必须放在变量使用以前。通常放在函数体的开头部分。 x, y是长整型变量，a, b是基本整型变量。它们之间容许进行运算，运算结果为长整型。但c，d被定义为基本整型，所以最后结果为基本整型。本例说明，不一样类型的量能够参与运算并相互赋值。其中的类型转换是由编译系统自动完成的。有关类型转换的规则将在之后介绍。

实型量

实型常量

实型也称为浮点型。实型常量也称为实数或者浮点数。在Ｃ语言中，实数只采用十进制。它有二种形式：十进制数形式指数形式 1.十进制数形式由数码0~ 9和小数点组成。例如：0.0，.25，5.789，0.13，5.0，300.，-267.8230等均为合法的实数。 2.指数形式由十进制数，加阶码标志“e”或“E”以及阶码（只能为整数，能够带符号）组成。其通常形式为a E n （a为十进制数，n为十进制整数）其值为 a*10,n　如： 2.1E5 (等于2.1*10,5), 3.7E-2 (等于3.7*10,)-2*)　0.5E7 (等于0.5*10,7), -2.8E-2 (等于-2.8*10,)-2*)如下不是合法的实数 345 (无小数点)　E7 (阶码标志E以前无数字)　 -5 (无阶码标志)　53.-E3 (负号位置不对)　2.7E (无阶码) 标准Ｃ容许浮点数使用后缀。后缀为“f”或“F”即表示该数为浮点数。如356f和356.是等价的。例2.2说明了这种状况： void main() { printf("%f\n%f\n",356.,356f); } void 指明main不返回任何值　利用printf显示结果　结束

实型变量

实型变量分为两类：单精度型和双精度型，其类型说明符为float 单精度说明符，double 双精度说明符。在Turbo C中单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，只能提供七位有效数字。双精度型占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。实型变量说明的格式和书写规则与整型相同。例如： float x,y; (x,y为单精度实型量) double a,b,c; (a,b,c为双精度实型量) 实型常数不分单、双精度，都按双精度double型处理。 void main(){ float a; double b; a=33333.33333; b=33333.33333333333333; printf("%f\n%f\n",a,b); } 此程序说明float、double的不一样 a ■■■■ b ■■■■■■■■ a<---33333.33333 b<---33333.33333333333;; 显示程序结果此程序说明float、double的不一样 float a; double b; a=33333.33333; b=33333.33333333333333; 从本例能够看出，因为a 是单精度浮点型，有效位数只有七位。而整数已占五位，故小数二位后以后均为无效数字。b 是双精度型，有效位为十六位。但Turbo C 规定小数后最多保留六位，其他部分四舍五入。

字符型量

字符型量包括字符常量和字符变量。

字符常量字符常量是用单引号括起来的一个字符。例如'a','b','=','+','?'都是合法字符常量。在Ｃ语言中，字符常量有如下特色： 1.字符常量只能用单引号括起来，不能用双引号或其它括号。 2.字符常量只能是单个字符，不能是字符串。 3.字符能够是字符集中任意字符。但数字被定义为字符型以后就不能参与数值运算。如'5'和5 是不一样的。'5'是字符常量，不能参与运算。

转义字符转义字符是一种特殊的字符常量。转义字符以反斜?quot;\"开头，后跟一个或几个字符。转义字符具备特定的含义，不一样于字符原有的意义，故称“转义” 字符。例如，在前面各例题printf函数的格式串中用到的“\n”就是一个转义字符，其意义是“回车换行”。转义字符主要用来表示那些用通常字符不便于表示的控制代码。经常使用的转义字符及其含义转义字符　转义字符的意义 \n 　　　　　回车换行 \t 　　　　　横向跳到下一制表位置 \v 　　　　　竖向跳格 \b 　　　　　退格 \r 　　　　　回车 \f　　　　　走纸换页 \\ 　　　　　反斜线符"\" \' 　　　　　单引号符 \a 　　　　　鸣铃 \ddd 　　　　1～3位八进制数所表明的字符 \xhh 　　　　1～2位十六进制数所表明的字符广义地讲，Ｃ语言字符集中的任何一个字符都可用转义字符来表示。表2.2中的\ddd和\xhh正是为此而提出的。ddd和hh分别为八进制和十六进制的 ASCII代码。如\101表示字?quot;A" ，\102表示字母"B"，\134表示反斜线，\XOA表示换行等。转义字符的使用 void main() { int a,b,c; a=5; b=6; c=7; printf("%d\n\t%d %d\n %d %d\t\b%d\n",a,b,c,a,b,c); } 此程序练习转义字符的使用 a、b、c为整数　5->a,6->b,7->c 调用printf显示程序运行结果 printf("%d\n\t%d %d\n %d %d\t\b%d\n",a,b,c,a,b,c); 程序在第一列输出a值5以后就是“\n”，故回车换行；接着又是“\t”，因而跳到下一制表位置（设制表位置间隔为8），再输出b值6；空二格再输出c 值7后又是"\n"，所以再回车换行；再空二格以后又输出a值5；再空三格又输出b的值6；再次后"\t"跳到下一制表位置（与上一行的6 对齐），但下一转义字符“\b”又使退回一格，故紧挨着6再输出c值7。

字符变量字符变量的取值是字符常量，即单个字符。字符变量的类型说明符是char。字符变量类型说明的格式和书写规则都与整型变量相同。例如： char a,b; 每一个字符变量被分配一个字节的内存空间，所以只能存放一个字符。字符值是以ASCII码的形式存放在变量的内存单元之中的。如x的十进制ASCII码是120，y的十进制ASCII码是121。对字符变量a,b赋予'x'和'y'值： a='x';b='y';其实是在a,b两个单元内存放120和121的二进制代码： a　0 1 1 1 1 0 0 0 b　0 1 1 1 1 0 0 1 因此也能够把它们当作是整型量。Ｃ语言容许对整型变量赋以字符值，也容许对字符变量赋以整型值。在输出时，容许把字符变量按整型量输出，也容许把整型量按字符量输出。整型量为二字节量，字符量为单字节量，当整型量按字符型量处理时，只有低八位字节参与处理。 main(){ char a,b; a=120; b=121; printf("%c,%c\n%d,%d\n",a,b,a,b); } a ■ b ■ a <-- 120 b <--- 121 显示程序结果 char a,b; a=120; b=121; 本程序中说明a，b为字符型，但在赋值语句中赋以整型值。从结果看，a，b值的输出形式取决于printf函数格式串中的格式符，当格式符为"c"时，对应输出的变量值为字符，当格式符为"d"时，对应输出的变量值为整数。 void main(){ char a,b; a='x'; b='y'; a=a-32; b=b-32; printf("%c,%c\n%d,%d\n",a,b,a,b); } a，b被说明为字符变量并赋予字符值把小写字母换成大写字母以整型和字符型输出本例中，a，b被说明为字符变量并赋予字符值，Ｃ语言容许字符变量参与数值运算，即用字符的ASCII 码参与运算。因为大小写字母的ASCII 码相差32，所以运算后把小写字母换成大写字母。而后分别以整型和字符型输出。

字符串常量字符串常量是由一对双引号括起的字符序列。例如： "CHINA" ，"C program: ， "$12.5" 等都是合法的字符串常量。字符串常量和字符常量是不一样的量。它们之间主要有如下区别： 1.字符常量由单引号括起来，字符串常量由双引号括起来。 2.字符常量只能是单个字符，字符串常量则能够含一个或多个字符。 3.能够把一个字符常量赋予一个字符变量，但不能把一个字符串常量赋予一个字符变量。在Ｃ语言中没有相应的字符串变量。这是与BASIC 语言不一样的。可是能够用一个字符数组来存放一个字符串常量。在数组一章内予以介绍。 4.字符常量占一个字节的内存空间。字符串常量占的内存字节数等于字符串中字节数加1。增长的一个字节中存放字符"\0"(ASCII码为0)。这是字符串结束的标志。例如，字符串 "C program"在内存中所占的字节为：C program\0。字符常量'a'和字符串常量"a"虽然都只有一个字符，但在内存中的状况是不一样的。 'a'在内存中占一个字节，可表示为：a "a"在内存中占二个字节，可表示为：a\0符号常量

符号常量在Ｃ语言中，能够用一个标识符来表示一个常量，称之为符号常量。符号常量在使用以前必须先定义，其通常形式为： #define 标识符常量其中#define也是一条预处理命令（预处理命令都?quot;#"开头），称为宏定义命令（在第九章预处理程序中将进一步介绍），其功能是把该标识符定义为其后的常量值。一经定义，之后在程序中全部出现该标识符的地方均代之以该常量值。习惯上符号常量的标识符用大写字母，变量标识符用小写字母，以示区别。 #define PI 3.14159 void main(){ float s,r; r=5; s=PI*r*r; printf("s=%f\n",s); } 由宏定义命令定义PI 为3.14159 s,r定义为实数　5->r　PI*r*r->s 显示程序结果 float s,r;　r=5;　s=PI*r*r; 本程序在主函数以前由宏定义命令定义PI 为3.14159，在程序中即以该值代替PI 。s=PI*r*r等效于s=3.14159*r*r。应该注意的是，符号常量不是变量，它所表明的值在整个做用域内不能再改变。也就是说，在程序中，不能再用赋值语句对它从新赋值。

变量的初值和类型转换

变量赋初值在程序中经常须要对变量赋初值，以便使用变量。语言程序中可有多种方法，在定义时赋以初值的方法，这种方法称为初始化。在变量说明中赋初值的通常形式为：类型说明符变量1= 值1，变量2= 值2，……；例如： int a=b=c=5; float x=3.2,y=3f,z=0.75; char ch1='K',ch2='P'; 应注意，在说明中不容许连续赋值，如a=b=c=5是不合法的。 void main(){ int a=3,b,c=5; b=a+c; printf("a=%d,b=%d,c=%d\n",a,b,c); } a<---3,b<--0,c<---5 b<--a+c 显示程序运行结果

变量类型的转换变量的数据类型是能够转换的。转换的方法有两种，一种是自动转换，一种是强制转换。

自动转换自动转换发生在不一样数据类型的量混合运算时，由编译系统自动完成。自动转换遵循如下规则： 1.若参与运算量的类型不一样，则先转换成同一类型，而后进行运算。 2.转换按数据长度增长的方向进行，以保证精度不下降。如int型和long型运算时，先把int量转成long型后再进行运算。 3.全部的浮点运算都是以双精度进行的，即便仅含float单精度量运算的表达式，也要先转换成double型，再做运算。 4.char型和short型参与运算时，必须先转换成int型。 5.在赋值运算中，赋值号两边量的数据类型不一样时，赋值号右边量的类型将转换为左边量的类型。若是右边量的数据类型长度左边长时，将丢失一部分数据，这样会下降精度，丢失的部分按四舍五入向前舍入。图2 1表示了类型自动转换的规则。 void main(){ float PI=3.14159; int s,r=5; s=r*r*PI; printf("s=%d\n",s); } PI<--3.14159 s<--0,r<--5 s<--r*r*PI 显示程序运行结果 float PI=3.14159; int s,r=5; s=r*r*PI; 本例程序中，PI为实型；s，r为整型。在执行s=r*r*PI语句时，r和PI都转换成double型计算，结果也为double型。但因为s为整型，故赋值结果仍为整型，舍去了小数部分。

强制类型转换强制类型转换是经过类型转换运算来实现的。其通常形式为： (类型说明符) (表达式) 其功能是把表达式的运算结果强制转换成类型说明符所表示的类型。例如： (float) a 把a转换为实型(int)(x+y) 把x+y的结果转换为整型在使用强制转换时应注意如下问题： 1.类型说明符和表达式都必须加括号(单个变量能够不加括号)，如把(int)(x+y)写成(int)x+y则成了把x转换成int型以后再与y相加了。 2.不管是强制转换或是自动转换，都只是为了本次运算的须要而对变量的数据长度进行的临时性转换，而不改变数听说明时对该变量定义的类型。 main(){ float f=5.75; printf("(int)f=%d,f=%f\n",(int)f,f); } f<--5.75 将float f强制转换成int f float f=5.75;printf("(int)f=%d,f=%f\n",(int)f,f); 本例代表，f虽强制转为int型，但只在运算中起做用，是临时的，而f自己的类型并不改变。所以，(int)f的值为 5(删去了小数)而f的值仍为5.75



  程序中使用的各类变量都应预先加以定义，即先定义，后使用。对变量的定义能够包括三个方面：数据类型、存储类型、做用域。

用户存储空间能够分为三个部分：

程序区；
静态存储区；
动态存储区；

从变量的做用域（即从空间）角度来分，能够分为全局变量和局部变量。

从变量值存在的做时间（即生存期）角度来分，能够分为静态存储方式和动态存储方式。
静态存储方式：是指在程序运行期间分配固定的存储空间的方式。
动态存储方式：是在程序运行期间根据须要进行动态的分配存储空间的方式。

全局变量所有存放在静态存储区，在程序开始执行时给全局变量分配存储区，程序行完毕就释放。在程序执行过程当中它们占据固定的存储单元，而不动态地进行分配和释放；

动态存储区存放如下数据：

函数形式参数；
自动变量（未加static声明的局部变量）；
函数调用实的现场保护和返回地址；

对以上这些数据，在函数开始调用时分配动态存储空间，函数结束时释放这些空间。在c语言中，每一个变量和函数有两个属性：数据类型和数据的存储类别。

为了提升效率，C语言容许将局部变量得值放在CPU中的寄存器中，这种变量叫“寄存器变量”，用关键字register做声明。

PS：

只有局部自动变量和形式参数能够做为寄存器变量；
一个计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量；
局部静态变量不能定义为寄存器变量。

外部变量（即全局变量）是在函数的外部定义的，它的做用域为从变量定义处开始，到本程序文件的末尾。若是外部变量不在文件的开头定义，其有效的做用范围只限于定义处到文件终了。若是在定义点以前的函数想引用该外部变量，则应该在引用以前用关键字extern对该变量做“外部变量声明”。表示该变量是一个已经定义的外部变量。有了此声明，就能够从“声明”处起，合法地使用该外部变量。

数据类型

按被定义变量的性质，表示形式，占据存储空间的多少，构造特色来划分的。在Ｃ语言中，数据类型可分为：基本数据类型，构造数据类型，指针类型，空类型四大类。

对于基本数据类型量，按其取值是否可改变又分为常量和变量两种。在程序执行过程当中，其值不发生改变的量称为常量，其值可变的量称为变量。它们可与数据类型结合起来分类。例如，可分为整型常量、整型变量、浮点常量、浮点变量、字符常量、字符变量、枚举常量、枚举变量。在程序中，常量是能够不经说明而直接引用的，而变量则必须先定义后使用。整型量包括整型常量、整型变量。

常量

在程序执行过程当中，其值不发生改变的量称为常量。

直接常量(字面常量)：

整型常量：十二、0、-3；

实型常量：4.六、-1.23；

字符常量：‘a’、‘b’。

标识符：用来标识变量名、符号常量名、函数名、数组名、类型名、文件名的有效字符序列。

符号常量：用标示符表明一个常量。在Ｃ语言中，能够用一个标识符来表示一个常量，称之为符号常量。

符号常量在使用以前必须先定义，其通常形式为：#define 标识符常量

其中#define也是一条预处理命令（预处理命令都以"#"开头），称为宏定义命令（在后面预处理程序中将进一步介绍），其功能是把该标识符定义为其后的常量值。一经定义，之后在程序中全部出现该标识符的地方均代之以该常量值。

习惯上符号常量的标识符用大写字母，变量标识符用小写字母，以示区别。使用符号常量的好处是：含义清楚；能作到“一改全改”。

变量

一个变量应该有一个名字，在内存中占据必定的存储单元。变量定义必须放在变量使用以前。通常放在函数体的开头部分。要区分变量名和变量值是两个不一样的概念。

整型数据

整型常量

就是整常数。在Ｃ语言中，使用的整常数有八进制、十六进制和十进制三种。

十进制整常数：十进制整常数没有前缀。其数码为0～9。

八进制整常数：八进制整常数必须以0开头，即以0做为八进制数的前缀。数码取值为0～7。八进制数一般是无符号数。

十六进制整常数：十六进制整常数的前缀为0X或0x。其数码取值为0~9，A~F或a~f。

整型常数的后缀：在16位字长的机器上，基本整型的长度也为16位，所以表示的数的范围也是有限定的。十进制无符号整常数的范围为0～65535，有符号数为-32768～+32767。八进制无符号数的表示范围为0～0177777。十六进制无符号数的表示范围为0X0～0XFFFF或0x0～0xFFFF。若是使用的数超过了上述范围，就必须用长整型数来表示。长整型数是用后缀“L”或“l”来表示的。

整型变量

整型数据在内存中的存放形式

若是定义了一个整型变量i：

int i;

i=10;

i 10

数值是以补码表示的：

正数的补码和原码相同；

负数的补码：将该数的绝对值的二进制形式按位取反再加1。

左面的第一位是表示符号的。

整型变量的分类

基本型：类型说明符为int，在内存中占2个字节。

短整量：类型说明符为short int或short。所占字节和取值范围均与基本型相同。

长整型：类型说明符为long int或long，在内存中占4个字节。

无符号型：类型说明符为unsigned。

无符号型又可与上述三种类型匹配而构成：

无符号基本型：类型说明符为unsigned int或unsigned。

无符号短整型：类型说明符为unsigned short。

无符号长整型：类型说明符为unsigned long。

各类无符号类型量所占的内存空间字节数与相应的有符号类型量相同。但因为省去了符号位，故不能表示负数。

类型说明符数的范围字节数

int-32768~32767 即-2 ¹⁵~（2 ¹⁵-1） 2

unsigned int0~65535 即0~（2 ¹⁶-1） 2

short int-32768~32767 即-2 ¹⁵~（2 ¹⁵-1） 2

unsigned short int0~65535 即0~（2 ¹⁶-1） 2

long int-2147483648~2147483647 即-2 ³¹~（2 ³¹-1） 4

unsigned long0~4294967295 即0~（2 ³²-1） 4

实型常量

也称为浮点型。实型常量也称为实数或者浮点数。在Ｃ语言中，实数只采用十进制。它有二种形式：十进制小数形式，指数形式。

十进制数形式：由数码0~ 9和小数点组成。注意，必须有小数点。

指数形式：由十进制数，加阶码标志“e”或“E”以及阶码（只能为整数，能够带符号）组成。其通常形式为：a E n（a为十进制数，n为十进制整数）其值为 a*10n

标准Ｃ容许浮点数使用后缀。后缀为“f”或“F”即表示该数为浮点数。如356f和356.是等价的

实型数据在内存中的存放形式

实型数据通常占4个字节（32位）内存空间。按指数形式存储。实数3.14159在内存中的存放形式以下：

.314159

数符小数部分指数

小数部分占的位（bit）数愈多，数的有效数字愈多，精度愈高。

指数部分占的位数愈多，则能表示的数值范围愈大。

实型变量的分类

实型变量分为：单精度（float型）、双精度（double型）和长双精度（long double型）三类。

在Turbo C中单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，只能提供七位有效数字。双精度型占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。

类型说明符	比特数（字节数）	有效数字	数的范围
float	32（4）	6~7	10^-37~10³⁸
double	64(8)	15~16	10^-307~10³⁰⁸
long double	128(16)	18~19	10^-4931~10⁴⁹³²

实型数据的舍入偏差

因为实型变量是由有限的存储单元组成的，所以能提供的有效数字老是有限的。

a 是单精度浮点型，有效位数只有七位。而整数已占五位，故小数二位后以后均为无效数字。

b 是双精度型，有效位为十六位。但Turbo C 规定小数后最多保留六位，其他部分四舍五入。

PS：实型常数不分单、双精度，都按双精度double型处理。

字符型数据

包括字符常量和字符变量。

字符常量是用单引号括起来的一个字符。例如：'a'、'b'、'='、'+'、'?'都是合法字符常量。

字符常量只能用单引号括起来，不能用双引号或其它括号。

字符常量只能是单个字符，不能是字符串。

字符能够是字符集中任意字符。但数字被定义为字符型以后就不能参与数值运算。如'5'和5 是不一样的。'5'是字符常量，不能参与运算。

转义字符是一种特殊的字符常量。转义字符以反斜线"\"开头，后跟一个或几个字符。转义字符具备特定的含义，不一样于字符原有的意义，故称“转义”字符。例如，在前面各例题printf函数的格式串中用到的“\n”就是一个转义字符，其意义是“回车换行”。转义字符主要用来表示那些用通常字符不便于表示的控制代码。

转义字符	转义字符的意义	ASCII代码
\n	回车换行	10
\t	横向跳到下一制表位置	9
\b	退格	8
\r	回车	13
\f	走纸换页	12
\\	反斜线符"\"	92
\'	单引号符	39
\”	双引号符	34
\a	鸣铃	7
\ddd	1～3位八进制数所表明的字符
\xhh	1～2位十六进制数所表明的字符

广义地讲，Ｃ语言字符集中的任何一个字符都可用转义字符来表示。表中的\ddd和\xhh正是为此而提出的。ddd和hh分别为八进制和十六进制的ASCII代码。如\101表示字母"A" ，\102表示字母"B"，\134表示反斜线，\XOA表示换行等。

字符变量用来存储字符常量，即单个字符。字符变量的类型说明符是char。字符变量类型定义的格式和书写规则都与整型变量相同。例如：char a,b;

每一个字符变量被分配一个字节的内存空间，所以只能存放一个字符。字符值是以ASCII码的形式存放在变量的内存单元之中的。

例如:

a='x';

b='y';

其实是在a,b两个单元内存放120和121的二进制代码：

a：

b：

因此也能够把它们当作是整型量。Ｃ语言容许对整型变量赋以字符值，也容许对字符变量赋以整型值。在输出时，容许把字符变量按整型量输出，也容许把整型量按字符量输出。

整型量为二字节量，字符量为单字节量，当整型量按字符型量处理时，只有低八位字节参与处理。

字符串常量

字符串常量是由一对双引号括起的字符序列。

字符串常量和字符常量是不一样的量。它们之间主要有如下区别：

字符常量由单引号括起来，字符串常量由双引号括起来。

字符常量只能是单个字符，字符串常量则能够含一个或多个字符。

能够把一个字符常量赋予一个字符变量，但不能把一个字符串常量赋予一个字符变量。在Ｃ语言中没有相应的字符串变量。这是与BASIC 语言不一样的。可是能够用一个字符数组来存放一个字符串常量。在数组一章内予以介绍。

字符常量占一个字节的内存空间。字符串常量占的内存字节数等于字符串中字节数加1。增长的一个字节中存放字符"\0" (ASCII码为0)。这是字符串结束的标志。

字符串 "C program" 在内存中所占的字节为：






----------------------------------------------------------------------------------------

c语言基本数据类型short、int、long、char、float、double

C 语言包含的数据类型以下图所示：

1、数据类型与“模子” short、int、long、char、float、double 这六个关键字表明C 语言里的六种基本数据类型。怎么去理解它们呢? 举个例子：见过藕煤球的那个东西吧？(没见过？煤球总见过吧)。那个东西叫藕煤器，拿着它在和好的煤堆里这么一咔，一个煤球出来了。半径12cm，12 个孔。不一样型号的藕煤器咔出来的煤球大小不同，孔数也不同。这个藕煤器其实就是个模子。如今咱们联想一下，short、int、long、char、float、double 这六个东东是否是很像不一样类型的藕煤器啊？拿着它们在内存上咔咔咔，不一样大小的内存就分配好了，固然别忘了给它们取个好听的名字。在32 位的系统上short 咔出来的内存大小是2 个byte； int 咔出来的内存大小是4 个byte； long 咔出来的内存大小是4 个byte； float 咔出来的内存大小是4 个byte； double 咔出来的内存大小是8 个byte； char 咔出来的内存大小是1 个byte。（注意这里指通常状况，可能不一样的平台还会有所不一样，具体平台能够用sizeof 关键字测试一下）很简单吧？咔咔咔很爽吧？是很简单，也确实很爽，但问题就是你咔出来这么多内存块，你总不能给他取名字叫作x1,x2,x3,x4,x5…或者长江1 号，长江2 号…吧。它们长得这么像(不是你家的老大，老二，老三…)，过一阵子你就会忘了到底哪一个名字和哪一个内存块匹配了(到底谁嫁给谁了啊？^_^)。因此呢，给他们取一个好的名字绝对重要。下面咱们就来研究研究取什么样的名字好。 2、变量的命名规则一、命名应当直观且能够拼读，可望文知意，便于记忆和阅读。标识符最好采用英文单词或其组合，不容许使用拼音。程序中的英文单词通常不要太复杂，用词应当准确。二、命名的长度应当符合“min-length && max-information”原则。 C 是一种简洁的语言, 命名也应该是简洁的。例如变量名MaxVal 就比MaxValueUntilOverflow 好用。标识符的长度通常不要过长，较长的单词可经过去掉“元音”造成缩写。另外，英文词尽可能不缩写，特别是很是用专业名词，若是有缩写，在同一系统中对同一单词必须使用相同的表示法，而且注明其意思。三、当标识符由多个词组成时，每一个词的第一个字母大写，其他所有小写。好比： int CurrentVal；这样的名字看起来比较清晰，远比一长串字符好得多。四、尽可能避免名字中出现数字编号，如Value1,Value2 等，除非逻辑上的确须要编号。好比驱动开发时为管脚命名，非编号名字反而很差。初学者老是喜欢用带编号的变量名或函数名，这样子看上去很简单方便，但实际上是一颗颗定时炸弹。这个习惯初学者必定要改过来。五、对在多个文件之间共同使用的全局变量或函数要加范围限定符(建议使用模块名(缩写)做为范围限定符)。 (GUI_ ，etc)标识符的命名规则：六、标识符名分为两部分：规范标识符前缀(后缀) + 含义标识。非全局变量能够不用使用范围限定符前缀。

七、做用域前缀命名规则。

八、数据类型前缀命名规则。

九、含义标识命名规则，变量命名使用名词性词组，函数命名使用动词性词组。例如：

变量含义标识符构成：目标词+ 动词(的过去分词)+ [状语] + [目的地]；

函数含义标识符构成：动词(通常现时)+目标词+[状语]+[目的地]；十、程序中不得出现仅靠大小写区分的类似的标识符。例如： int x, X; 变量x 与X 容易混淆 void foo(int x); 函数foo 与FOO 容易混淆 void FOO(float x); 这里还有一个要特别注意的就是1（数字1）和l（小写字母l）之间，0（数字0）和o（小写字母o）之间的区别。这两对真是很难区分的，我曾经的一个同事就被这个问题折腾了一次。十一、一个函数名禁止被用于其它之处。例如： #include "c_standards.h" void foo(int p_1) { int x = p_1; } void static_p(void) { int foo = 1u; } 十二、全部宏定义、枚举常数、只读变量全用大写字母命名，用下划线分割单词。例如： const int MAX_LENGTH = 100; //这不是常量，而是一个只读变量，具体请日后看 #define FILE_PATH “/usr/tmp” 1三、考虑到习惯性问题，局部变量中可采用通用的命名方式，仅限于n、i、j 等做为循环变量使用。必定不要写出以下这样的代码： int p; char i; int c; char * a; 通常来讲习惯上用n,m,i,j,k 等表示int 类型的变量；c，ch 等表示字符类型变量；a 等表示数组；p 等表示指针。固然这仅仅是通常习惯，除了i,j,k 等能够用来表示循环变量外，别的字符变量名尽可能不要使用。 1四、定义变量的同时千万千万别忘了初始化。定义变量时编译器并不必定清空了这块内存，它的值多是无效的数据。这个问题在内存管理那章有很是详细的讨论，请参看。 1五、不一样类型数据之间的运算要注意精度扩展问题，通常低精度数据将向高精度数据扩展 <br />本文来自【C语言中文网】：<a href="http://see.xidian.edu.cn/cpp/html/437.html" target="_blank">http://see.xidian.edu.cn/cpp/html/437.html</a>

转载于:https://www.cnblogs.com/kungfupanda/archive/2013/03/17/2964697.html