int
long int
long long int
它们都有有符号，无符号，对否？
并没有：short int 类型！
28 个解决方案
#1
short 就是short int呢
#2
整数常量默认是 int 类型！
unsigned int n = 7; //常量：7，默认类型是：int
如果整数常量，也有short int 类型？
怎样表示这个常量？
#3
short：
The short keyword can be preceded by either the keyword signed or the keyword unsigned. The int keyword is optional and can be omitted. To the MIDL compiler, a short integer is signed by default and is synonymous with signed short int.
The short integer type is one of the base types of the IDL language. The short integer type can appear as a type specifier in const declarations, typedef declarations, general declarations, and function declarators (as a function-return-type specifier and a parameter-type specifier). For the context in which type specifiers appear, see Interface Definition (IDL) File.
The short keyword can be preceded by either the keyword signed or the keyword unsigned. The int keyword is optional and can be omitted. To the MIDL compiler, a short integer is signed by default and is synonymous with signed short int.
The short integer type is one of the base types of the IDL language. The short integer type can appear as a type specifier in const declarations, typedef declarations, general declarations, and function declarators (as a function-return-type specifier and a parameter-type specifier). For the context in which type specifiers appear, see Interface Definition (IDL) File.
#4
给个实例说明下？
#5
还用实例么？
MSDN说的很清楚了
==============
还有关于long的，你看看：
The long keyword can be preceded by either the keyword signed or the keyword unsigned. The int keyword is optional and can be omitted. To the MIDL compiler, a long integer is signed by default and is synonymous with signed long int. On 32-bit platforms, long is synonymous with int.
#6
//有符号整型
int n=-7; //常量：-7，是有符号整型
int n=-7l; //常量：-7l，是有符号长整型
int n=-7ll; //常量：-7ll，是有符号长长整型
//无符号整型
unsigned int y=7; //常量：7，是无符号整型
unsigned int y=7l; //常量：7l，是无符号长整型
unsigned int y=7ll; //常量：7ll，是无符号长长整型
如果，赋值表达式的右操作数是 短整型常量，怎样表示它?
给个实例！
#7
有short int啊，即为int类型，默认的是有符号的，即signed short int，可以简写位short。
#8
short = short int
#9
更改：
//有符号整型
int n=-7; //常量：-7，是有符号整型
int n=-7l; //常量：-7l，是有符号长整型
int n=-7ll; //常量：-7ll，是有符号长长整型
//无符号整型
int y=7u; //常量：7u，是无符号整型
int y=7ul; //常量：7ul，是无符号长整型
int y=7ull; //常量：7ull，是无符号长长整型
#10
赋值表达式的
右操作数是个常量！
如果，这个 常量是短整型(short int)，怎样表示它?
给个实例说明下！
如果，这个 常量是短整型(short int)，怎样表示它?
给个实例说明下！
#11
就直接short int/short就行了
#12
不清楚的话，最好自己写完整。再说这种省略，不同的编译器也可能不一样的。
#13
楼上各位：
问题是： 常量，并非变量啊！
变量的类型当然可以声明为短整型了。
如：short int x=9; //变量：x，是短整型(short int)!
常量，怎样表示为短整型？
给个实例！
问题是： 常量，并非变量啊！
变量的类型当然可以声明为短整型了。
如：short int x=9; //变量：x，是短整型(short int)!
常量，怎样表示为短整型？
给个实例！
#14
这里需要弄清楚的是C语言里的常量到底是什么。从根本上说，C语言里的常量是没有类型的。
C语言里的常量含义是指在编译期就已经知道其具体值的量。编译器在处理常量时不会为它分配内存，而会把它当作“立即数”处理。
以整形常量为例，由于int的标准定义是字(Word)。存放int类型的空间与寄存器大小一致。无后缀常量实质是告诉编译器该量可以直接存入一个寄存器；后缀u常量则是告诉编译器该量在运算时要对符号位作特殊处理；后缀l常量就很清楚了吧：其实就是告诉编译器这个量用一个寄存器是存不下的。
由于计算机运算的最小单位是一个寄存器位数，所以设置比字长要短的short型常量是没有意义的。
C语言里的常量含义是指在编译期就已经知道其具体值的量。编译器在处理常量时不会为它分配内存，而会把它当作“立即数”处理。
以整形常量为例，由于int的标准定义是字(Word)。存放int类型的空间与寄存器大小一致。无后缀常量实质是告诉编译器该量可以直接存入一个寄存器；后缀u常量则是告诉编译器该量在运算时要对符号位作特殊处理；后缀l常量就很清楚了吧：其实就是告诉编译器这个量用一个寄存器是存不下的。
由于计算机运算的最小单位是一个寄存器位数，所以设置比字长要短的short型常量是没有意义的。
#15
楼上各位：
9楼是常量的所有类型，对否？
常量是否有：short int 类型？
int x=9; //常量：9，是有符号整型常量。
int y=9u; //常量：9u，是无符号整型常量。
//u：表示无符号，对否？
9楼是常量的所有类型，对否？
常量是否有：short int 类型？
#16
楼上那么多回答的人没有一个理解楼主的问题，真是隔靴搔痒，无怪乎楼主急死了。
整数常量是没有short int的，无论C还是C++各版本的标准都如此。
而整数常量的类型视数值大小及是否带后缀，十进制、八进制还是十六进制均有不同，情况比较复杂，C90是这样说的：
6.1.3.2 integer constants
........
The type ot an integer constant is the tirst ot the corresponding list in which its value can be represented. Unsuffixed decimal int. long int, unsigned long int: unsuftixed octal or hexadecimal: int. unsigned int. long int, unsigned long int: suffixed by the letrer u or U: unsigned int. unsigned long int: suffixed by the letter 1 or L long int.unsigned long int. suttixed by both the letters u or U and 1 or L: unsigned long int.
而C99多了个long long，搞了一张大表，如下：
整数常量是没有short int的，无论C还是C++各版本的标准都如此。
而整数常量的类型视数值大小及是否带后缀，十进制、八进制还是十六进制均有不同，情况比较复杂，C90是这样说的：
6.1.3.2 integer constants
........
The type ot an integer constant is the tirst ot the corresponding list in which its value can be represented. Unsuffixed decimal int. long int, unsigned long int: unsuftixed octal or hexadecimal: int. unsigned int. long int, unsigned long int: suffixed by the letrer u or U: unsigned int. unsigned long int: suffixed by the letter 1 or L long int.unsigned long int. suttixed by both the letters u or U and 1 or L: unsigned long int.
而C99多了个long long，搞了一张大表，如下：
#17
字面量没有short类型的。
#18
“常量”指什么？const?
#19
该回复于2012-09-05 09:09:38被版主删除
#20
给short变量附一个大值，输出看看，或者看看内存如何保存的就行了
#21
const准确理解是只读
#22
16楼正解
#23
16楼可以解释下
tirst
的意思吗？我翻遍字典找不到！多谢
tirst
的意思吗？我翻遍字典找不到！多谢
#24
编译器有差别，比如说VS和C99编译结果不同
#25
在c中是只读，但在c++中就不仅只读的语义了，可以粗略地理解为"常量"了。
#26
first
#27
C++ Integer Constants
Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.
Syntax
integer-constant :
decimal-constant integer-suffixopt
octal-constant integer-suffixopt
hexadecimal-constant integer-suffixopt
'c-char-sequence'
decimal-constant :
nonzero-digit
decimal-constant digit
octal-constant :
0
octal-constant octal-digit
hexadecimal-constant :
0x hexadecimal-digit
0X hexadecimal-digit
hexadecimal-constant hexadecimal-digit
nonzero-digit : one of
1 2 3 4 5 6 7 8 9
octal-digit : one of
0 1 2 3 4 5 6 7
hexadecimal-digit : one of
0 1 2 3 4 5 6 7 8 9
a b c d e f
A B C D E F
integer-suffix :
unsigned-suffix long-suffixopt
long-suffix unsigned-suffixopt
unsigned-suffix : one of
u U
long-suffix : one of
l L
64-bit integer-suffix :
i64
To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.
To specify a decimal constant, begin the specification with a nonzero digit. For example:
int i = 157; // Decimal constant
int j = 0198; // Not a decimal number; erroneous octal constant
int k = 0365; // Leading zero specifies octal constant, not decimal
To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:
int i = 0377; // Octal constant
int j = 0397; // Error: 9 is not an octal digit
To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:
int i = 0x3fff; // Hexadecimal constant
int j = 0X3FFF; // Equal to i
To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:
unsigned uVal = 328u; // Unsigned value
long lVal = 0x7FFFFFL; // Long value specified
// as hex constant
unsigned long ulVal = 0776745ul; // Unsigned long value
Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.
Syntax
integer-constant :
decimal-constant integer-suffixopt
octal-constant integer-suffixopt
hexadecimal-constant integer-suffixopt
'c-char-sequence'
decimal-constant :
nonzero-digit
decimal-constant digit
octal-constant :
0
octal-constant octal-digit
hexadecimal-constant :
0x hexadecimal-digit
0X hexadecimal-digit
hexadecimal-constant hexadecimal-digit
nonzero-digit : one of
1 2 3 4 5 6 7 8 9
octal-digit : one of
0 1 2 3 4 5 6 7
hexadecimal-digit : one of
0 1 2 3 4 5 6 7 8 9
a b c d e f
A B C D E F
integer-suffix :
unsigned-suffix long-suffixopt
long-suffix unsigned-suffixopt
unsigned-suffix : one of
u U
long-suffix : one of
l L
64-bit integer-suffix :
i64
To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.
To specify a decimal constant, begin the specification with a nonzero digit. For example:
int i = 157; // Decimal constant
int j = 0198; // Not a decimal number; erroneous octal constant
int k = 0365; // Leading zero specifies octal constant, not decimal
To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:
int i = 0377; // Octal constant
int j = 0397; // Error: 9 is not an octal digit
To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:
int i = 0x3fff; // Hexadecimal constant
int j = 0X3FFF; // Equal to i
To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:
unsigned uVal = 328u; // Unsigned value
long lVal = 0x7FFFFFL; // Long value specified
// as hex constant
unsigned long ulVal = 0776745ul; // Unsigned long value
#28
该回复于2012-09-07 08:31:23被版主删除
#1
short 就是short int呢
#2
整数常量默认是 int 类型！
unsigned int n = 7; //常量：7，默认类型是：int
如果整数常量，也有short int 类型？
怎样表示这个常量？
#3
short：
The short keyword can be preceded by either the keyword signed or the keyword unsigned. The int keyword is optional and can be omitted. To the MIDL compiler, a short integer is signed by default and is synonymous with signed short int.
The short integer type is one of the base types of the IDL language. The short integer type can appear as a type specifier in const declarations, typedef declarations, general declarations, and function declarators (as a function-return-type specifier and a parameter-type specifier). For the context in which type specifiers appear, see Interface Definition (IDL) File.
The short keyword can be preceded by either the keyword signed or the keyword unsigned. The int keyword is optional and can be omitted. To the MIDL compiler, a short integer is signed by default and is synonymous with signed short int.
The short integer type is one of the base types of the IDL language. The short integer type can appear as a type specifier in const declarations, typedef declarations, general declarations, and function declarators (as a function-return-type specifier and a parameter-type specifier). For the context in which type specifiers appear, see Interface Definition (IDL) File.
#4
给个实例说明下？
#5
还用实例么？
MSDN说的很清楚了
==============
还有关于long的，你看看：
The long keyword can be preceded by either the keyword signed or the keyword unsigned. The int keyword is optional and can be omitted. To the MIDL compiler, a long integer is signed by default and is synonymous with signed long int. On 32-bit platforms, long is synonymous with int.
#6
//有符号整型
int n=-7; //常量：-7，是有符号整型
int n=-7l; //常量：-7l，是有符号长整型
int n=-7ll; //常量：-7ll，是有符号长长整型
//无符号整型
unsigned int y=7; //常量：7，是无符号整型
unsigned int y=7l; //常量：7l，是无符号长整型
unsigned int y=7ll; //常量：7ll，是无符号长长整型
如果，赋值表达式的右操作数是 短整型常量，怎样表示它?
给个实例！
#7
有short int啊，即为int类型，默认的是有符号的，即signed short int，可以简写位short。
#8
short = short int
#9
更改：
//有符号整型
int n=-7; //常量：-7，是有符号整型
int n=-7l; //常量：-7l，是有符号长整型
int n=-7ll; //常量：-7ll，是有符号长长整型
//无符号整型
int y=7u; //常量：7u，是无符号整型
int y=7ul; //常量：7ul，是无符号长整型
int y=7ull; //常量：7ull，是无符号长长整型
#10
赋值表达式的
右操作数是个常量！
如果，这个 常量是短整型(short int)，怎样表示它?
给个实例说明下！
如果，这个 常量是短整型(short int)，怎样表示它?
给个实例说明下！
#11
就直接short int/short就行了
#12
不清楚的话，最好自己写完整。再说这种省略，不同的编译器也可能不一样的。
#13
楼上各位：
问题是： 常量，并非变量啊！
变量的类型当然可以声明为短整型了。
如：short int x=9; //变量：x，是短整型(short int)!
常量，怎样表示为短整型？
给个实例！
问题是： 常量，并非变量啊！
变量的类型当然可以声明为短整型了。
如：short int x=9; //变量：x，是短整型(short int)!
常量，怎样表示为短整型？
给个实例！
#14
这里需要弄清楚的是C语言里的常量到底是什么。从根本上说，C语言里的常量是没有类型的。
C语言里的常量含义是指在编译期就已经知道其具体值的量。编译器在处理常量时不会为它分配内存，而会把它当作“立即数”处理。
以整形常量为例，由于int的标准定义是字(Word)。存放int类型的空间与寄存器大小一致。无后缀常量实质是告诉编译器该量可以直接存入一个寄存器；后缀u常量则是告诉编译器该量在运算时要对符号位作特殊处理；后缀l常量就很清楚了吧：其实就是告诉编译器这个量用一个寄存器是存不下的。
由于计算机运算的最小单位是一个寄存器位数，所以设置比字长要短的short型常量是没有意义的。
C语言里的常量含义是指在编译期就已经知道其具体值的量。编译器在处理常量时不会为它分配内存，而会把它当作“立即数”处理。
以整形常量为例，由于int的标准定义是字(Word)。存放int类型的空间与寄存器大小一致。无后缀常量实质是告诉编译器该量可以直接存入一个寄存器；后缀u常量则是告诉编译器该量在运算时要对符号位作特殊处理；后缀l常量就很清楚了吧：其实就是告诉编译器这个量用一个寄存器是存不下的。
由于计算机运算的最小单位是一个寄存器位数，所以设置比字长要短的short型常量是没有意义的。
#15
楼上各位：
9楼是常量的所有类型，对否？
常量是否有：short int 类型？
int x=9; //常量：9，是有符号整型常量。
int y=9u; //常量：9u，是无符号整型常量。
//u：表示无符号，对否？
9楼是常量的所有类型，对否？
常量是否有：short int 类型？
#16
楼上那么多回答的人没有一个理解楼主的问题，真是隔靴搔痒，无怪乎楼主急死了。
整数常量是没有short int的，无论C还是C++各版本的标准都如此。
而整数常量的类型视数值大小及是否带后缀，十进制、八进制还是十六进制均有不同，情况比较复杂，C90是这样说的：
6.1.3.2 integer constants
........
The type ot an integer constant is the tirst ot the corresponding list in which its value can be represented. Unsuffixed decimal int. long int, unsigned long int: unsuftixed octal or hexadecimal: int. unsigned int. long int, unsigned long int: suffixed by the letrer u or U: unsigned int. unsigned long int: suffixed by the letter 1 or L long int.unsigned long int. suttixed by both the letters u or U and 1 or L: unsigned long int.
而C99多了个long long，搞了一张大表，如下：
整数常量是没有short int的，无论C还是C++各版本的标准都如此。
而整数常量的类型视数值大小及是否带后缀，十进制、八进制还是十六进制均有不同，情况比较复杂，C90是这样说的：
6.1.3.2 integer constants
........
The type ot an integer constant is the tirst ot the corresponding list in which its value can be represented. Unsuffixed decimal int. long int, unsigned long int: unsuftixed octal or hexadecimal: int. unsigned int. long int, unsigned long int: suffixed by the letrer u or U: unsigned int. unsigned long int: suffixed by the letter 1 or L long int.unsigned long int. suttixed by both the letters u or U and 1 or L: unsigned long int.
而C99多了个long long，搞了一张大表，如下：
#17
字面量没有short类型的。
#18
“常量”指什么？const?
#19
该回复于2012-09-05 09:09:38被版主删除
#20
给short变量附一个大值，输出看看，或者看看内存如何保存的就行了
#21
const准确理解是只读
#22
16楼正解
#23
16楼可以解释下
tirst
的意思吗？我翻遍字典找不到！多谢
tirst
的意思吗？我翻遍字典找不到！多谢
#24
编译器有差别，比如说VS和C99编译结果不同
#25
在c中是只读，但在c++中就不仅只读的语义了，可以粗略地理解为"常量"了。
#26
first
#27
C++ Integer Constants
Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.
Syntax
integer-constant :
decimal-constant integer-suffixopt
octal-constant integer-suffixopt
hexadecimal-constant integer-suffixopt
'c-char-sequence'
decimal-constant :
nonzero-digit
decimal-constant digit
octal-constant :
0
octal-constant octal-digit
hexadecimal-constant :
0x hexadecimal-digit
0X hexadecimal-digit
hexadecimal-constant hexadecimal-digit
nonzero-digit : one of
1 2 3 4 5 6 7 8 9
octal-digit : one of
0 1 2 3 4 5 6 7
hexadecimal-digit : one of
0 1 2 3 4 5 6 7 8 9
a b c d e f
A B C D E F
integer-suffix :
unsigned-suffix long-suffixopt
long-suffix unsigned-suffixopt
unsigned-suffix : one of
u U
long-suffix : one of
l L
64-bit integer-suffix :
i64
To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.
To specify a decimal constant, begin the specification with a nonzero digit. For example:
int i = 157; // Decimal constant
int j = 0198; // Not a decimal number; erroneous octal constant
int k = 0365; // Leading zero specifies octal constant, not decimal
To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:
int i = 0377; // Octal constant
int j = 0397; // Error: 9 is not an octal digit
To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:
int i = 0x3fff; // Hexadecimal constant
int j = 0X3FFF; // Equal to i
To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:
unsigned uVal = 328u; // Unsigned value
long lVal = 0x7FFFFFL; // Long value specified
// as hex constant
unsigned long ulVal = 0776745ul; // Unsigned long value
Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.
Syntax
integer-constant :
decimal-constant integer-suffixopt
octal-constant integer-suffixopt
hexadecimal-constant integer-suffixopt
'c-char-sequence'
decimal-constant :
nonzero-digit
decimal-constant digit
octal-constant :
0
octal-constant octal-digit
hexadecimal-constant :
0x hexadecimal-digit
0X hexadecimal-digit
hexadecimal-constant hexadecimal-digit
nonzero-digit : one of
1 2 3 4 5 6 7 8 9
octal-digit : one of
0 1 2 3 4 5 6 7
hexadecimal-digit : one of
0 1 2 3 4 5 6 7 8 9
a b c d e f
A B C D E F
integer-suffix :
unsigned-suffix long-suffixopt
long-suffix unsigned-suffixopt
unsigned-suffix : one of
u U
long-suffix : one of
l L
64-bit integer-suffix :
i64
To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.
To specify a decimal constant, begin the specification with a nonzero digit. For example:
int i = 157; // Decimal constant
int j = 0198; // Not a decimal number; erroneous octal constant
int k = 0365; // Leading zero specifies octal constant, not decimal
To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:
int i = 0377; // Octal constant
int j = 0397; // Error: 9 is not an octal digit
To specify a hexadecimal constant, begin the specification with 0x or 0X (the case of the “x” does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:
int i = 0x3fff; // Hexadecimal constant
int j = 0X3FFF; // Equal to i
To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:
unsigned uVal = 328u; // Unsigned value
long lVal = 0x7FFFFFL; // Long value specified
// as hex constant
unsigned long ulVal = 0776745ul; // Unsigned long value
#28
该回复于2012-09-07 08:31:23被版主删除