&&/&&&&/&&&&/&&
C 语言包含的数据类型如下图所示：
一、数据类型与&模子&
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 号&吧。它们长得这么像(不是你家的老大，老二，老三&)，过一阵子你就会忘了到底哪个名字和哪个内存块匹配了(到底谁嫁给谁了啊？^_^)。所以呢，给他们取一个好的名字绝对重要。下面我们就来研究研究取什么样的名字好。
二、变量的命名规则
1、命名应当直观且可以拼读，可望文知意，便于记忆和阅读。
标识符最好采用英文单词或其组合，不允许使用拼音。程序中的英文单词一般不要太复杂，用词应当准确。
2、命名的长度应当符合&min-length && max-information&原则。
C 是一种简洁的语言, 命名也应该是简洁的。例如变量名MaxVal 就比MaxValueUntilOverflow 好用。标识符的长度一般不要过长，较长的单词可通过去掉&元音&形成缩写。
另外，英文词尽量不缩写，特别是非常用专业名词，如果有缩写，在同一系统中对同一单词必须使用相同的表示法，并且注明其意思。
3、当标识符由多个词组成时，每个词的第一个字母大写，其余全部小写。比如：
& &int CurrentVal；
这样的名字看起来比较清晰，远比一长串字符好得多。
4、尽量避免名字中出现数字编号，如Value1,Value2 等，除非逻辑上的确需要编号。比如驱动开发时为管脚命名，非编号名字反而不好。
初学者总是喜欢用带编号的变量名或函数名，这样子看上去很简单方便，但其实是一颗颗定时炸弹。这个习惯初学者一定要改过来。
5、对在多个文件之间共同使用的全局变量或函数要加范围限定符(建议使用模块名(缩写)作为范围限定符)。
(GUI_ ，etc)标识符的命名规则：
6、标识符名分为两部分：规范标识符前缀(后缀) + 含义标识。非全局变量可以不用使用范围限定符前缀。
7、作用域前缀命名规则。
8、数据类型前缀命名规则。
9、含义标识命名规则，变量命名使用名词性词组，函数命名使用动词性词组。例如：
变量含义标识符构成：目标词+ 动词(的过去分词)+ [状语] + [目的地]；
函数含义标识符构成：动词(一般现时)+目标词+[状语]+[目的地]；
10、程序中不得出现仅靠大小写区分的相似的标识符。例如：
& &int x, X; 变量x 与X 容易混淆
& &void foo(int x); 函数foo 与FOO 容易混淆
& &void FOO(float x);
这里还有一个要特别注意的就是1（数字1）和l（小写字母l）之间，0（数字0）和o（小写字母o）之间的区别。这两对真是很难区分的，我曾经的一个同事就被这个问题折腾了一次。
11、一个函数名禁止被用于其它之处。例如：
#include &c_standards.h&
void foo(int p_1)
& &int x = p_1;
void static_p(void)
& &int foo = 1u;
12、所有宏定义、枚举常数、只读变量全用大写字母命名，用下划线分割单词。例如：
const int MAX_LENGTH = 100; //这不是常量，而是一个只读变量，具体请往后看
& &#define FILE_PATH &/usr/tmp&
13、考虑到习惯性问题，局部变量中可采用通用的命名方式，仅限于n、i、j 等作为循环变量使用。
一定不要写出如下这样的代码：
一般来说习惯上用n,m,i,j,k 等表示int 类型的变量；c，ch 等表示字符类型变量；a 等表示数组；p 等表示指针。当然这仅仅是一般习惯，除了i,j,k 等可以用来表示循环变量外，别的字符变量名尽量不要使用。
14、定义变量的同时千万千万别忘了初始化。定义变量时编译器并不一定清空了这块内存，它的值可能是无效的数据。这个问题在内存管理那章有非常详细的讨论，请参看。
15、不同类型数据之间的运算要注意精度扩展问题，一般低精度数据将向高精度数据扩展。
推荐文章 TOP10C语言的三种整型数据类型：int、short&int和long&int
这样一个题，据说是微软面试题：&
unsigned int i=3;
cout&&i * -1;
问结果是多少。
&第一反应：-3。不过结果似乎不是这样的，写了个程序，运行了一下，发现是：。很诡异的一个数字，怎么也想不明白为什么会是这么个奇怪的数字。但是在我发现这数的十六进制数是FFFFFFFD时，我想我已经离答案很近了...
&这个涉及到了混合着不同数据类型的表达式中的数据类型的转换问题。在总结转换问题之前，先说明一下各种数据类型（只说明numeric类型的），下表来自MSDN：
Type Name Bytes Other Names Range of
int * signed,
signed int System
dependent&
unsigned int * unsigned System
dependent&
__int8 1 char,
signed char &128 to 127&
__int16 2 short,
short int,
signed short int &32,768 to
__int32 4 signed,
signed int &2,147,483,648 to
2,147,483,647&
__int64 8 none &9,223,372,036,854,775,808 to
9,223,372,036,854,775,807&
char 1 signed char &128 to
unsigned char 1 none 0 to
short 2 short int,
signed short int &32,768 to
unsigned short 2 unsigned short int 0 to
long 4 long int,
signed long int &2,147,483,648 to
2,147,483,647&
unsigned long 4 unsigned long int 0 to
4,294,967,295&
enum * none Same as int&
float 4 none 3.4E +/- 38 (7
double 8 none 1.7E +/- 308 (15
long double 10 none 1.2E +/- 4932 (19
对上表补充说明一下：
<font COLOR="#）在32位机上，int型和unsigned int型都是32位的（4个字节）。
<font COLOR="#）enum会跟据最大值来决定类型，一般来说为int型，如果超出int型所能表示的范围，则用比int型大的最小类型来表示（unsigned
int, long 或者unsigned long）
<font COLOR="#）关于类型的大小。一般用所能表示的数据范围来比较类型的大小，如char型&unsigned
char型&short型...在表达式中，一般都是由小的类型向大的类型转换（强制类型转换除外）
&下面结合自己查的资料，加上自己不断地举各种情况编程，总结一下关于类型转换（仅限于算术表达式中关于整数类型的转换）的一些问题（如有缺漏，欢迎补充，感激不尽）
<font COLOR="#、所有比int型小的数据类型（包括char,signed char,unsigned
char,short,signed short,unsigned
short）转换为int型。如果转换后的数据会超出int型所能表示的范围的话，则转换为unsigned
<font COLOR="#、bool型转化为int型时，false转化为0，true转换为1；反过来所有的整数类型转化为bool时，0转化为false，其它非零值都转为true；
<font COLOR="#、如果表达式中混有unsigned short和int型时，如果int型数据可以表示所有的unsigned
short型的话，则将unsigned short类型的数据转换为int型，否则，unsigned
short类型及int型都转换为unsigned int类型。举个例子，在32位机上，int是32位，范围&2,147,483,648
to 2,147,483,647，unsigned short是16位，范围0 to
65,535，这样int型的足够表示unsigned short类型的数据，因此在混有这两者的运算中，unsigned
short类型数据被转换为int型；
<font COLOR="#、unsigned int 与long类型的转换规律同3，在32位机上，unsigned int是32位，范围0
to 4,294,967,295，long是32位，范围&2,147,483,648 to
2,147,483,647，可见long类型不够表示所有的unsigned int型，因此在混有unsigned
int及long的表达式中，两者都被转换为unsigned long；
<font COLOR="#、如果表达式中既有int 又有unsigned int，则所有的int数据都被转化为unsigned
&经过这番总结，前面提出的问题的答案应该就很明显了吧。在表达式i*-1中，i是unsigned
int型，-1是int型（常量整数的类型同enum），按第5条可以知道-1必须转换为unsigned
int型，即0xffffffff，十进制的，然后再与i相乘，即*3，如果不考虑溢出的话，结果是，十六进制0x2FFFFFFFD，由于unsigned
int只能表示32位，因此结果是0xfffffffd，即。
原文地址：C语言的三种整型数据类型：int、short&int和long&int作者：
int数据类型的位数为16位，short int数据类型的位数也是16位。而long
int的位数为32位，可用来存储比较大的整数。
short int 和 long int可以缩写为short 和 long。
&&&&&&&&&&&&&C语言中的整型数据类型int、short
int 和 long int
全称类型说明符
缩写类型说明符&&&&&&
位数&&&&&&&
&&&&&&&&&&&&&范围
-32768至+32767&
无符号整型
unsigned int&
0 至 65,535&
short int&
-32768至+32767&
无符号短整型&&&&&
unsigned short
unsigned short
0 至 65,535&
-2,147,483,648 至 2,147,483,647
无符号长整型&&&&&
unsigned long
long&&&&&&&&
32位&&&&&&
0至4,294,967,295
&&&&&&&&&&&&&&&
整型变量的声明方式：
在一个语句中声明多个属于同一类型的变量：
int withd,
int 类型的变量初始化方式：
withd = 150; //前面已经声明，在此进行初始化
int height = 60; //直接在一个语句中进行声明和初始化
C语言中整型常量有三种不同的表示形式：
&&&&&1、八进制整型常量：在八进制数值前面加前缀“0”，其数码取值为0~7。例如：054、。
&&&&&2、十六进制整型常量：前缀为“0X”或“0x“，其数码取值为0~9、A~F
或 a~f。例如：0X3D、0XE0、0xfff等。
&&&&&3、十进制整型常量：既无前缀也无后缀。例如：254、745、890等。
如将存储为long类型，需要在数字序列最后附一个字母L 或 l 作为后缀。例如：245L、7850L、124l等
1.&其它整数类型&&&&int
是 C 语言的基本整数类型，可以满足我们处理一般数据的需求。C 语言还提供了四个可以修饰
int 的关键字：short、long、signed，以及&unsigned。利用这四个关键字，C
语言标准定义了以下整数类型：&&&&&&1)
short int（可简写为 short），和 int 一样，也是有符号整数
long int（简写：long），有符号整数
long long int（简写：long long），C99 标准添加的类型，
&&&&&&&&&有符号整数
unsigned int（简写：unsigned），无符号整数，不能表示负数
unsigned long int（简写：unsigned long），无符号整数，
&&&&&&&&&不能表示负数
unsigned short int（简写：unsigned short），无符号整数，
&&&&&&&&&不能表示负数
unsigned long long int（简写：unsigned long long），
&&&&&&&&&C99
添加的类型，无符号整数
所有没有标明 unsigned 的整数类型默认都是有符号整数。
&&&&&&&&&在这些整数类型前面加上
signed 可以使读者更清楚地知道
&&&&&&&&&这些是有符号整数，尽管有没有
signed 都表示有符号整数。
&&&&&&&&&例如：signed
int 等同于 int 。
&&&&一般我们把
short 称为短整型，把 long
称为长整型，把 long long
称为超长整型，把 int
称为整型。unsigned
打头的那些整数类型统称为无符号整型。例如：我们称 unsigned short
为无符号短整型。以此类推。
2.&声明方式
&&&&这些整数类型的声明方式与
类型的声明方式一样。例如：&&&&&&&&long
&&&&&&&&long
&&&&&&&&short
&&&&&&&&short
&&&&&&&&unsigned
&&&&&&&&unsigned
&&&&&&&&unsigned
&&&&&&&&unsigned
&&&&&&&&long
&&&&&&&&unsigned
如果您的编译器不支持
C99 标准，那就不能使用 long long 和 unsigned long long。
3.&取值范围（表示范围）
&&&&标准也规定了这些整数类型的最小取值范围。short
的最小表示范围和 int 一样，都是-32767 到 32767 。也就是 -(2^15 - 1)到(2^15 -
1)。其中，2^15表示 2 的 15 次方。类似地，2 的 20 次方记作2^20 ，以此类推。注意：C 语言中 2^15 并不表示
2 的 15 次方，为了书写方便，我们姑且这么表示。long 的最小取值范围是 - 到
。也就是 -(2^31 - 1) 到 (2^31 - 1) 。unsigned short的最小表示范围和unsigned int
一样，都是 0 到 6 - 1）。unsigned long 的最小取值范围是 0 到
（2^32 - 1）。long long的最小取值范围是 -4775807（-(2^63
- 1)）到 ^63 - 1）；unsigned long long 是 0 到
^64 - 1）。
&&&&标准规定，int
的表示范围不能小于&short
的表示范围，long 的表示范围不能小于&int 的表示范围。这就是说
short 型变量占用的空间可能比 int 型变量少，而 long 型变量占用的空间可能比 int 型变量多。16
位（bit）的计算机中，int 和 short 一般都是 16 位，而 long 是 32位；32位的计算机中，short一般是 16
位，而long和int是 32位。TC2（16位的编译器）中，int是16位的；而 Dev-C++（32 位的编译器）中，int 是
unsigned int 声明的变量只能表示非负整数（0 和正整数）。如果 int 是 16 位的话，那么
unsigned int 的表示范围是 0 到 6 - 1）。这是因为 unsigned 不需要符号位，可以把 16
个位全都用于表示整数。而 int 需要一个位作为符号位，用于表示正负，只有 15
个位用于表示整数。
&&&&目前，long
long 一般 64 位，long 是 32 位，short 是 16 位，而 int 或者 16 位，或者 32
位。具体某个编译器到底使用多少位来表示这些类型，我们可以用运算符&sizeof
来获取。例如：
&&&&&&&&&&printf(
"%lun", (unsigned long)sizeof(int) * 8
&&&&&&&&&&printf(
"%zun", sizeof(short) * 8
&&&&sizeof
运算符返回其操作数占用空间的大小，以字节（Byte）为单位。注意，C 定义字节的大小为 char
类型的大小。char 通常是 8 位（bit）的，当然也可以更大。这里我们假设 char 是 8 位的。
&&&&sizeof
的用法我们以后会讲到，现在只要有个印象就好了。第二句中的&%zu&是 C99
特有的，如果您的编译器不支持 C99（准确地说，应该是如果您的编译器使用的库函数不支持
C99），运行结果将会出错。
4.&整数类型的选择&&&&如果您要处理的只是非负整数，那么应该优先使用
unsigned 打头的那些整数类型。如果您要处理的整数超出了 int 所能表示的范围，并且您的编译器中，long 的表示范围比
int 大，那就使用 long。不过，若非必要，尽量不要用
long，因为它可能会降低程序运行效率。有一点要注意：如果您的编译器中，long 和 int 都是 32 位的，并且您需要使用 32
位整数，那么应该用 long，而不要用 int。只有这样，我们的程序才可以安全地移植到 16 位的计算机，因为 16
位的计算机中，int 一般也是 16 位的。类似地，如果您需要使用 64 位整数，那就用 long long。如果 int 是 32
位的话，那么使用 short 可以节省空间，不过您得确保您要处理的整数不会超出 short
的表示范围。这种“节省”对内存大的计算机来说，是没什么意义的。
5.&long 型常量和 long long
&&&&一般来说，整数常量是被当作
int 类型来存储的。如果我们使用的整数常量超出了 int 的表示范围，C 语言规定编译器自动使用 unsigned int
来处理这个常量。如果 unsigned 也不足以表示这个常量的话，编译器就会用 long。如果还表示不了的话，那就依次用
unsigned long，long long，unsigned long long。如果 unsigned long long
也表示不了，那么编译器就没辙了。注意：long long 和 unsigned long long 是 C99 特有的。例如：如果
int 是 16 位的话，它就表示不了常量 1000000。编译器会使用 long 来处理这个常量，因为 unsigned int
也表示不了 1000000 。
&&&&同样，十六进制和八进制整数常量通常也是被作为
int 来处理。但是，当我们使用的常量超出了 int 的表示范围后，编译器会依次使用unsigned
int，long，unsigned long，long long 和 unsigned long
long。直到所使用的类型足以表示那个常量为止。
&&&&有时，我们使用的是较小的常量，但是我们希望这个常量被当作
long 来处理，这就需要在这个常量后面加上后缀&l（小写字母 l）或者
L（大写字母 L）。我们应该避免使用 l ，因为 l 容易和数字 1 混淆。例如：整数常量 7 是被作为 int 来处理的，但整数常量
7L（或者 7l）是被作为 long 来处理的。类似地，在整数常量后面加上后缀 ll 或者 LL ，这个常量就会被当作 long
long 来处理。例如：3LL 。如果想使用无符号整数常量的话，还要配合使用后缀 u 或者 U
。例如：2u，3U，4Lu，5ul，6LU，7LLU，8Ull，9uLL 。
&&&&这些后缀也可以用于十六进制和八进制整数常量。例如：020L，010LL，0x30uL，0x40ull
参考资料：C Primer Plus, 5th
Edtion By Stephen Prata
&&&&&&&&&&The
C Programming Language 2e By K&R
&&&&&&&&&&C99
十进制、八进制和十六进制的整型常量可加后缀以指示类型，如下表所示。
数据类型后缀
long&[long
long&和&unassigned long
long&在&-xc99=none&和&-Xc&模式下不可用。]
lu、LU、Lu、lU、ul、uL、Ul&或&UL
unsigned long
llu、LLU、LLu、llU、ull、ULL、uLL、Ull
unsigned long long
如果设置&-xc99=all，编译器将根据常量大小，使用以下列表中可以表示该值的第一项：
long long int
如果值超过&long long&int
可表示的最大值，编译器会发出警告。
如果设置&-xc99=none，则为无后缀常量指定类型时，编译器将根据常量大小，使用以下列表中可以表示该值的第一项：
unsigned long int
unsigned long long int
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。编程测试long,int和short类型数据所占内存大小_百度知道
编程测试long,int和short类型数据所占内存大小
printf(&quot#include &lt,________________);补充完整&#47;stdio&gt,%d：4,%d&quot,2;;&#47;}输出结果为;%d
提问者采纳
a=sizeof(short);printf(……）；或int a，那么用的什么编译器呢,sizeof(int)，是vc++还是turbo c呢。可以用下面的语句测试一下，int在turbo中是两个字节：sizeof(long)：int a，short 是两个字节，long是四个字节;a=sizeof(int)，在vc++中是四个字节,sizeof(short)例如;printf(……)看你写的应该是c语言吧
其他类似问题
为您推荐：
内存大小的相关知识
其他1条回答
sizeof(long),sizeof(int),sizeof(short)好像是这个！
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁&&/&&&&/&&&&/&&
其长度分别为一字节，至少两字节，至少两字节和至少4字节。除此之外，不要再依赖任何约定。
char类型的长度被定义为一个8位字节，这很简单。
short类型的长度至少为两字节。在有些计算机上，对于有些编译程序，short类型的长度可能为4字节，或者更长。
int类型是一个整数的&自然&大小，其长度至少为两字节，并且至少要和short类型一样长。在16位计算机上，int类型的长度可能为两字节；在32位计算机上，可能为4字节；当64位计算机流行起来后，int类型的长度可能会达到8字节。这里说的都是&可能&，例如，早期的Motorala 68000是一种16／32位的混合型计算机，依赖于不同的命令行选项，一个68000编译程序能产生两字节长或4字节长的int类型。
long类型至少和int类型一样长(因此，它也至少和short类型一样长)。long类型的长度至少为4字节。32位计算机上的编译程序可能会使short，int和long类型的长度都为4字节&&也可能不会。
如果你需要一个4字节长的整型变量，你不要想当然地以为int或long类型能满足要求，而要用typedef把一种固有的类型(一种确实存在的类型)定义为你所需要的类型，并在它的前后加上相应的#ifdef指令：
&&& #ifdef FOUR_BYTE_LONG
&&& typedef long int4；
&&& #endif
如果你需要把一个整型变量以字节流的方式写到文件中或网络上，然后再从不同的计算机上读出来，你可能就会用到这样的类型。
如果你需要一个两字节长的整型变量，你可能会遇到一些麻烦!因为并不一定有这样的类型。但是，你总是可以把一个较小的值存放到一个由两个char类型组成的数组中。
推荐文章 TOP1090253人阅读
和机器字长及编译器有关系：
所以，int，long int，short int的宽度都可能随编译器而异。但有几条铁定的原则（ANSI/ISO制订的）：
1 sizeof(short int)&=sizeof(int)
2 sizeof(int)&=sizeof(long int)
3 short int至少应为16位（2字节）
4 long int至少应为32位。
unsigned 是无符号的意思。
16位编译器
char ：1个字节
char*(即指针变量): 2个字节
short int : 2个字节
unsigned int : 2个字节
long long:
unsigned long:
32位编译器char ：1个字节
char*（即指针变量）: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）
short int : 2个字节int：
unsigned int : 4个字节
long long:
unsigned long:
64位编译器
char ：1个字节
char*(即指针变量): 8个字节
short int : 2个字节
unsigned int : 4个字节
long long:
unsigned long:
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：146846次
排名：千里之外
原创：14篇
评论：10条
(8)(4)(3)(1)(1)(2)(3)(1)}