提到unsigned，大家应该都了解，有朋友问c语言中unsigned什么意思，还有人想问c语言中的unsigned是什么意思，这到底是咋回事？事实上unsigned呢，下面是小编推荐给大家的unsigned int，下面我们一起来看看吧！
 
unsigned int
 
一、指代不同
 
1、int：定义整数类型变量的标识符。
 
2、unsigned int：需声明无符号类型的话就需要在类型前加上unsigned。
 
二、内存占用不同
 
1、int：int占用4字节，32比特，数据范围为-2147483648~2147483647[-2^31~2^31-1]。
 
2、unsigned int：unsigned能存储的数据范围则是0~65535。由于在计算机中,整数是以补码形式存放的。根据最高位的不同，如果是1,有符号数的话就是负数；如果是无符号数,则都解释为正数。
 

 
三、特点不同
 
1、int： Int 返回小于或等于 number 的第一个负整数。例如，Int 将 -8.4 转换成 -9。
 
2、unsigned int：无符号类型能保存2倍于有符号类型的正整数数据。
 
1、unsigned的作用就是将数字类型无符号化， 例如 int 型的范围：-2^31 ~ 2^31 - 1，而unsigned int的范围：0 ~ 2^32。看起来unsigned 是个不错的类型，尤其是用在自增或者没有负数的情况。但是在实际使用中会出现一些意外的情况。
 
2、signed在默认情况下声明的整型变量都是有符号的类型(char有点特别)，如果需声明无符号类型的话就需要在类型前加上unsigned。无符号版本和有符号版本的区别就是无符号类型能保存2倍于有符号类型的正整数数据。
 

 
unsigned和signed的区别
 
1、所有比int型小的数据类型(包括char,signed char,unsigned char,short,signed short,unsigned short)转换为int型。如果转换后的数据会超出int型所能表示的范围的话，则转换为unsigned int型
 
2、bool型转化为int型时，false转化为0，true转换为1；反过来所有的整数类型转化为bool时，0转化为false，其它非零值都转为true
 
3、如果表达式中混有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型
 
4、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
 
5、如果表达式中既有int 又有unsigned int，则所有的int数据都被转化为unsigned int类型
 
unsigned int 十进制范围是多少？
 
不同编译器范围不同，C语言没有明确规定
 
但是在Turbo C中为两个字节，即0~2^16-1(62353)
 
在Visual C++6.0中为4个字节，即0~2^32-1(4394967295)
 
一个字节8位，就这样，还不懂请发邮件给我
 
C语言中unsigned int 类型取值范围最大能到多少
 
在32位的编译器上，unsigned int最大值:4294967295。
 
c语言标准库中的limits.h头文件定义了unsinged int的最大值宏——UINT_MAX，可以直接使用printf函数将其打印出来。
 
#include
 
#include 
 
int main()
 
{
 
printf("unsigned int最大值:%u\n", UINT_MAX );
 
return 0;
 
}
 

 
举例
 
16位系统中一个int能存储的数据的范围为-32768~32767，而unsigned能存储的数据范围则是0~65535。
 
由于在计算机中，整数是以补码形式存放的，根据最高位的不同，如果是1，有符号数的话就是负数，如果是无符号数，则都解释为正数，另外，unsigned若省略后一个关键字，大多数编译器都会认为是unsigned int。
 
在sql语句中的意义
 
sql语句中，创建一个数据表时
 
create table user{
 
user_id int unsigned...
 
...
 
}
 
当中的unsigned表示，数据项user_id恒为正整数还可以为整数0,0不属于正整数。
 
C语言中的unsigned int是什么
 
unsigned integer意思是“无符整型”，表示从0开始到2^32-1的所有整数。unsigned 后的int可以省略的。
 
具体用法如下：
 
unsigned a;
 
a=5;
 
或：unsigned int a;
 
a=5;
 
16位系统中一个int能存储的数据的范围为-32768~32767，而unsigned int能存储的数据范围则是0~65535，在计算机中，整数是以补码形式存放的。
 

 
根据最高位的不同，如果是1，有符号数的话就是负数；如果是无符号数,则都解释为正数。同时在相同位数的情况下，所能表达的整数范围变大 。
 
1、int 是整数类型，用于定义变量的类型，有符号unsigned int 是无符号的整数类型，直白点说有符号无符号整型就是能不能存放负数。
 
2、根据程序编译器的不同，整形定义的字节数不同。注意一下取值范围。
 
C语言中：unsigned int a=-2;printf("%u",a);输出结果为多少？
 
输出结果为65534或者4294967294
 
因为在不同位的操作系统下，数值的表示位数是不一样的。首先我们先明确一点：在计算机中，正数用原码来计算(正数的原码、补码、反码都是一样的)；负数是用补码来计算的。至于原因可以参考一下文章网页链接就是把减法简化为加法从而大大简化计算机电路的过程。
 
首先在16位系统中，-2的原码为1000 0000 0000 0010；补码为：1111 1111 1111 1110；我们使用的unsigned为无符号数，那么此时计算机会把我们的-2强制转化为正数进行运算，即用1111 1111 1111 1110表示-2，即为65534.
 
在32位操作系统中，-2的原码为：1000 0000 0000 0000 0000 0000 0000 0010；补码为：1111 1111 1111 1111 1111 1111 1111 1110；同上述，计算机会强制输出1111 1111 1111 1111 1111 1111 1111 1110所代表的十进制数，即4294967294。
 
可以参考一下例子：#include 
 
#include
 
void main()
 
{
 
unsigned int a=65535;
 
int b=4294967294;
 
printf("%d %u\n",a,a);
 
printf("%d %u\n",b,b);
 
system("pause");
 
}
 
输出结果：
 
65535   65535
 
-2   4294967294
 
*(unsigned int *)addr = type;怎么理解
 
(unsigned int*)是一个强制类型转换，首先把指针强制转换成(unsigned int*)型，然后再取值，
 
比如 int *addr，那么就需要强制转换，因为有的编译器编译会有警告，如果加上(unsigned int *)，警告就会消失
 
unsigned int 和 uint 的详细用法？？
 
UINT　　typedef unsigned int UINT; 　　UINT类型在WINDOWS API中有定义，它对应于32位无符号整数。
 
1.在C, C++中不存在UINT这个关键字
 
UINT类型是unsigned int派生出来的 　　int是带符号的，表示范围是:-2147483648 到2147483648 　　uint是不带符号整形，表示范围是0到4294967295(2^32-1)，即第一个数字不表示符号
 
2.在C#中，uint 是关键字
 
表示一种整型，该类型根据下表显示的大小和范围存储值 　　类型 范围 大小 .NET Framework 类型
 
uint 0 到 4,294,967,295(2的32次方) 无符号 32 位整数 System..::.UInt32
 
3 在MFC中的解释?
 
在MFC中，Data Types关于UINT的解释： 　　UINT A 16-bit unsigned integer on Windows versions 3.0 and 3.1; a 32-bit unsigned integer on Win32.
 
整型的每一种都有无符号(unsigned)和有符号(signed)两种类型(float和double总是带符号的)，在默认情况下声明的整型变量都是有符号的类型(char有点特别)，如果需声明无符号类型的话就需要在类型前加上unsigned。无符号版本和有符号版本的区别就是无符号类型能保存2倍于有符号类型的数据，比如16位系统中一个int能存储的数据的范围为-32768~32767，而unsigned能存储的数据范围则是0~65535。由于在计算机中，整数是以补码形式存放的。根据最高位的不同，如果是1,有符号数的话就是负数；如果是无符号数，则都解释为正数。同时在相同位数的情况下，所能表达的整数范围变大。另外，unsigned若省略后一个关键字，大多数编译器都会认为是unsigned int。 　　在sql语句中的意义 　　sql语句中，创建一个数据表时 　　ceate table user{ 　　user_id int unsigned… 　　… 　　} 　　当中的unsigned表示，数据项user_id恒为正整数。
 
一般情况 没什么区别
 
资料寻找很辛苦 给个最佳答案 谢谢
 
单片机中unsigned char 和unsigned int的区别
 
uint 是无符号整型,16位二进制，需要2个字节表达，其值范围为：0到65535。
 
uchar是无符号字符型,8位二进制，只需要1个字节表达，其值范围为：0到255。
 
显然，如果delay函数定义为delay(uchar z),你在调用delay函数时，传递的参量不能超过255，否则就会得到意想不到的后果。另外，在delay函数内部，传递的延时量z用unchar型和unint型，即使是用同一个传递数字，例如都是用delay(100)，因为运算量的不同，它们之间还是有些差异的。
 
这里所谓的运算量是指编译成汇编后的运算，从C源程序是看不出来的。
 
C语言的unsigned int是什么意思？
 
C语言中unsigned  int是无符号整数的意思。
 
无符号整型(unsigned  int)：
 
(1)我们都知道整型是4个字节(有些编译器不同，可能会是2个)，即32位，无符号整型当然也为32位。
 
(2)既然是32位，无符号整型的取值是32个0~32个1，即：0~4294967295
 
(3)我们举个例子：32位有点长，所以我们拿16位的unsigned short int 来举例。
 
short int 是16位的，无符号的范围是0~65535，就拿十进制的32767(以下的所有举例均拿这个数字来说事了)来说，它的二进制为：
 
0111 1111 1111 1111
 
对于无符号的整型32767来说，它的二进制的最高位称为数据位，即那个0就是数据位，数据位是要参与运算的，如果我们把0改成1，即16个1，它的十进制就是65535(就是2的15次方+2的14次方...一直加到2的0次方)，这是不同于有符号整型的。

 
当要进行底层移植的时候肯定会遇到这些问题。特整理了下。
 
java语言基本数据类型
 
在JAVA中一共有八种基本数据类型，他们分别是
 
byte、short、int、long、float、double、char、boolean
 
整型
 
其中byte、short、int、long都是表示整数的，只不过他们的取值范围不一样
 
byte的取值范围为-128~127，占用1个字节(-2的7次方到2的7次方-1)
 
short的取值范围为-32768~32767，占用2个字节(-2的15次方到2的15次方-1)
 
int的取值范围为(-2147483648~2147483647)，占用4个字节(-2的31次方到2的31次方-1)
 
long的取值范围为(-9223372036854774808~9223372036854774807)，占用8个字节(-2的63次方到2的63次方-1)
 
可以看到byte和short的取值范围比较小，而long的取值范围太大，占用的空间多，基本上int可以满足我们的日常的计算了，而且int也是使用的最多的整型类型了。
 
在通常情况下，如果JAVA中出现了一个整数数字比如35，那么这个数字就是int型的，如果我们希望它是byte型的，可以在数据后加上大写的
 
B：35B，表示它是byte型的，同样的35S表示short型，35L表示long型的，表示int我们可以什么都不用加，但是如果要表示long型
 
的，就一定要在数据后面加“L”。
 
浮点型
 
float和double是表示浮点型的数据类型，他们之间的区别在于他们的精确度不同
 
float 3.402823e+38 ~ 1.401298e-45(e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方)占用4个字节
 
double 1.797693e+308~ 4.9000000e-324 占用8个字节
 
double型比float型存储范围更大，精度更高，所以通常的浮点型的数据在不声明的情况下都是double型的，如果要表示一个数据是float型的，可以在数据后面加上“F”。
 
浮点型的数据是不能完全精确的，所以有的时候在计算的时候可能会在小数点最后几位出现浮动，这是正常的。
 
boolean型(布尔型)
 
这个类型只有两个值，true和false(真和非真)
 
boolean t = true；
 
boolean f = false；
 
char型(文本型)
 
用于存放字符的数据类型，占用2个字节，采用unicode编码，它的前128字节编码与ASCII兼容
 
字符的存储范围在\u0000~\uFFFF，在定义字符型的数据时候要注意加' '，比如 '1'表示字符'1'而不是数值1，
 
char c = ' 1 ';
 
我们试着输出c看看，System.out.println(c);结果就是1，而如果我们这样输出呢System.out.println(c+0);
 
结果却变成了49。
 
如果我们这样定义c看看
 
char c = ' \u0031 ';输出的结果仍然是1，这是因为字符'1'对应着unicode编码就是\u0031
 
char c1 = 'h',c2 = 'e',c3='l',c4='l',c5 = 'o';
 
System.out.print(c1);System.out.print(c2);System.out.print(c3);System.out.print(c4);Sytem.out.print(c5);
 
String
 
在前面我们看到过这样的定义：
 
String s = "hello";
 
System.out.println(s);跟上面的5条语句组合起来的效果是一样的，那么String是个什么呢？String是字符串，它不是基本数据类型，它是一个类。
 
c语言数据类型
 
1.整型数据类型
 
C定义了5种整型数据类型。
 
整型数据类型表
 
序号
 
类型名称
 
说明
 
字节数
 
取值范围
 
1
 
signed char
 
有符号的单字节整数类型
 
1
 
-128~+127
 
2
 
short int
 
短整型
 
2
 
-32768~+32767
 
3
 
int
 
整型
 
4
 
-2147438648~+2147438647
 
4
 
long int
 
长整型
 
4
 
-2147438648~+2147438647
 
5
 
long long int
 
长长整型
 
8
 
-9223372036854775808~+-9223372036854775807
 
2.无符号整数类型
 
对应有符号类型，还有无符号整数类型。
 
无符号整数类型表
 
序号
 
类型名称
 
字节数
 
取值范围
 
1
 
unsigned char
 
1
 
0~255
 
2
 
unsign short int
 
2
 
0~65535
 
3
 
unsigned int
 
4
 
0~4294967295
 
4
 
unsigned long int
 
4
 
0~4294967295
 
5
 
unsign long long int
 
8
 
0~18446744073709551615
 
3.整型常量
 
整型常量是指用以表示整型数值的常量，分为短整型(short int)、整型(int)、长整型(long int )和长长整型(long long int)四种。C默认整型(int)。 各种类型整型常量进制表示表(后缀不区分大小写)
 
序号
 
数据类型
 
八进制
 
十进制
 
十六进制
 
1
 
整型
 
0112
 
74
 
0x4a
 
2
 
长整型(l)
 
0112l
 
74l
 
0x4al
 
3
 
长长整型(ll)
 
0112ll
 
74ll
 
0x4all
 
4
 
无符号整型(u)
 
0112u
 
74u
 
0x4au
 
5
 
无符号长整型(ul)
 
0112ul
 
74ul
 
0x4aul
 
6
 
无符号长长整型(ull)
 
0112ull
 
74ull
 
0x4aull
 
4.字符数据类型
 
C语言中字符型数据只有一种，即char型数据。一般也把char直接称为字符型。字符型占用内存空间最少，一般占用一个字节，存储在char类型变量的整数可以表示为有符号或无符号的值，这取决于编译器。
 
5.字符变量
 
字符变量是用于存储字符型数值的变量。字符型变量也分为两种：有符号和无符号型。
 
6.浮点型数据类型
 
C语言定义了三种浮点数据类型：
 
•float，单精度
 
•double，双精度
 
•long double，长双精度
 
C标准中对不同类型的浮点数有不同的规定，编译器不同或硬件条件不同，字节长度也不相同。
 
浮点型的字节长度、精度、数量级范围和输出输入格式表
 
序号
 
数据类型
 
字节长度
 
精度
 
数量级范围
 
printf和scanf格式
 
1
 
float(f)
 
4
 
7
 
-38~38
 
%f
 
2
 
double
 
8
 
约16
 
-308~308
 
%f
 
3
 
long double(1)
 
12
 
约19
 
-4932~4932
 
%llf
 
7.浮点型精度
 
浮点型精度从低到高排列为float、double和long long double。
 
8.浮点型的存储方式
 
浮点型数值以科学计数法的表示形式存储在内存中。浮点型的内存形式包含三个部分：
 
1)符号位
 
符号位浮点型的符号位只有一位，为最高位。该位为1，表示负数，该位为0，为非负数。
 
2)指数位
 
浮点型的指数位以补码形式存储，是科学计数法的指数部分。
 
3)基数位
 
基数位是浮点型的最后一位，这个位决定数值的精度。
 
浮点型储存分段表
 
序号
 
数据类型
 
符号位
 
指数位
 
基数位
 
偏差值
 
1
 
float
 
1
 
8
 
23
 
127
 
2
 
double
 
1
 
11
 
52
 
1023
 
3
 
long double
 
1
 
15
 
64
 
16383
 
c++语言基本数据类型
 
C++基本数据类型有字符型(char)、整数类型(int)、浮点型(float)、双精度型(double)和无值类型(void)，下表给出各种基本类型和内存中的位数和表示数值的范围(对于字符型存储的是ASCII码)：
 
基本数据类型
 
类型
 
类型名
 
位数
 
范围
 
字符型
 
char
 
8
 
-128 ------ 127
 
整型
 
int
 
16
 
-32768 ------ 32767
 
浮点型
 
float
 
32
 
3.4E-38 ------ 3.4E+38
 
双精度型
 
double
 
64
 
1.7E-308 ------ 1.7E+308
 
无值类型
 
void
 
0
 
0
 
类型名前可以加修饰符(void类型除外)，修饰符有　signed(带符号的)、 unsigned(无符号的)、
 
short(短的)和 long(长的)。signed　和　unsigned　用于字符型或整型，short　和
 
long　可用于整型，还可用于双精度型，如下表所示：
 
基本数据类型和修饰符
 
类型
 
类型名
 
位数
 
范围
 
字符型
 
char
 
8
 
-128 ------ 127
 
signed　char
 
8
 
-128 ------ 127
 
unsigned char
 
8
 
0 ------ 255
 
整型
 
int
 
16
 
-32768 ------ 32767
 
signed int
 
16
 
-32768 ------ 32767
 
unsigned int
 
16
 
0 ------ 65535
 
short int
 
16
 
-32768 ------ 32767
 
signed short int
 
16
 
-32768 ------ 32767
 
unsigned short int
 
16
 
0 ------ 65535
 
long　int
 
32
 
-2,147,483,648 ---- 2,147,483,647
 
signed　long　int
 
32
 
-2,147,483,648 ---- 2,147,483,647
 
unsigned　long　int
 
32
 
0 ----------------4,294,967,295
 
浮点型
 
float
 
32
 
3.4E-38 ------ 3.4E+38
 
双精度型
 
double
 
64
 
1.7E-308 ------ 1.7E+308
 
long double
 
80
 
3.4E-4932 ------ 1.1E+4932
 
当用　signed 、unsigned 、short　和 long 修饰　int 时，int　可省略。
 
字符型实际上是一个字节的整型
 
，浮点型和双精度型表示实数。
 
注：不同编译系统，整数的存储长度不同。对于16位的编译系统，int为2字节；而对于32位的编译系统，int为4字节。可以用sizeof运算符测试。如：
 
cout<
 
输出结果是字节数。

 
在很多函数调用里面都有 unsigned long 参数，事实上他不只是传递一个数(当然大多数情况下就传递一个数)，更重要的是通过强转他还能代表一个地址，即当一个指针使用，下面就举例说明。
 
(指针与unsigned long什么关系？没有关系，C中值的类型并非值本身的属性，而是取决于它的使用方式。)
 
一，内核定时器的使用。
 
内核定时器一般分为声明、注册、删除等操作。
 
#include 
 
Struct timer_list
 
{
 
Unsigned long expires;
 
Void (*function)(unsigned long)
 
Unsigned long data;
 
}
 
Void init_timer(struct timer_list *timer);
 
Void add_timer(struct timer_list *timer);
 
Void del_timer(struct timer_list *timer);
 
expire 表示期望达到的值，到达这个值后就调用function 函数，并传递data作为参数，这里的data 是一个unsigned long 数据，如果我们要传递多个数据，就可以把几个数据捆绑成一个结构，然后传递结构的指针就可以了。
 
1)在我的pwm 驱动里面就用了内核定时器，其使用过程为：
 
struct pwm_dev *my_pwm_dev；
 
init_timer(&my_pwm_dev->my_timer);
 
my_pwm_dev->my_timer.expires = jiffies + HZ/5; // 定时器超时时的节拍数
 
my_pwm_dev->my_timer.data     = (unsigned long)my_pwm_dev;
 
my_pwm_dev->my_timer.function = my_function; // 定时器超时时调用的函数
 
add_timer(&my_pwm_dev->my_timer);// 这里开始计时了
 
在这里 timet_list 的成员data 本来是一个unsigned long的数，这个是传递的一个指针，即设备的指针。
 
int my_function( unsigned long arg )// 这里的unsigned long arg即为 data。
 
{
 
struct pwm_dev *my_pwm_dev = (struct pwm_dev *)arg;
 
…..
 
}
 
在这个函数里面我们可以看到，在my_function函数里面，我们又把一个长整型的数强制转换成一个设备指针，这样就实现了利用unsigned long 作指针传递数据的过程。
 
3使用过后还得删除定时器
 
del_timer(&my_pwm_dev->my_timer);
 
2) "./kernel/kernel/workqueue.c"
 
static int __init init_workqueues(void)
 
{
 
structglobal_cwq*gcwq = get_gcwq(cpu);
 
spin_lock_init(&gcwq->lock);
 
INIT_LIST_HEAD(&gcwq->worklist);
 
gcwq->cpu = cpu;
 
gcwq->flags |= GCWQ_DISASSOCIATED;
 
INIT_LIST_HEAD(&gcwq->idle_list);
 
for (i = 0; i < BUSY_WORKER_HASH_SIZE; i++)
 
INIT_HLIST_HEAD(&gcwq->busy_hash[i]);
 
init_timer_deferrable(&gcwq->idle_timer);
 
gcwq->idle_timer.function = idle_worker_timeout;
 
gcwq->idle_timer.data =(unsigned long)gcwq;
 
setup_timer(&gcwq->mayday_timer, gcwq_mayday_timeout,(unsigned long)gcwq);
 
.....
 
}
 
二．Ioctl()函数中 unsigned long 的使用。
 
Ioctl函数原型为：
 
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
 
在驱动函数中表现为：
 
ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 
这里也有一个unsigned long arg；同样，我们也可以用这个参数传递一个数或者结构体的指针，只用方法和上面的 timer_list 一样，传递时，使用地址，在ioctl 函数里，将arg 强制转换成原来的数或者结构体的指针。

在C语言中，默认的基础数据类型均为signed,如定义变量为int,long等，都为有符号的。如果要定义无符号类型，必须显式地在变量类型前加unsigned
 
char 和 unsigned char 区别
 
相同点：在内存中都是一个字节，8位（2^8=256），都能表示256个数字
不同点：char的最高位为符号位，因此char能表示的数据范围是-128~127，unsigned char没有符号位，因此能表示的数据范围是0~255
 
实际使用中，如普通的赋值，读写文件和网络字节流都没有区别，不管最高位是什么，最终的读取结果都一样，在屏幕上面的显示可能不一样。
 
但是要把一个char类型的变量赋值给int、long等数据类型或进行类似的强制类型转换时时，系统会进行类型扩展，这时区别就大了。对于char类型的变量，系统会认为最高位为符号位，然后对最高位进行扩展，即符号扩展。若最高位为1，则扩展到int时高位都以1填充。对于unsigned char类型的变量，系统会直接进行无符号扩展，即0扩展。扩展的高位都以0填充。所以在进行类似的操作时，如果char和unsigned char最高位都是0，则结果是一样的，若char最高位为1，则结果会大相径庭。
 使用的下面的小程序验证一下：
 
#include <stdio.h>

static void func(unsigned char uc)
{
    char c;
    int i, j;
    unsigned int ui, uj;

    c = uc;
    i = (int)c;
    j = (int)uc;
    ui = (unsigned int)c;
    uj =(unsigned int)uc;
    printf("%%c: %c, %c\n", c, uc);
    printf("%%x: %x, %x\n", c, uc);
    printf("%%u: %u, %u\n", ui, uj);
    printf("%%d: %d, %d\n", i, j);
}

int main(int argc, char *argv[])
{
    func(0x80);
    func(0x7f);

    return 0;
}
 
运行结果如下：
 
 
对于char来说，0x80用二进制表示为1000 0000，当它作为char赋值给unsigned int或 int 时，系统认为最高位是符号位，会对最高位进行扩展。而0x7F用二进制表示为0111 1111，最高位为0，不会扩展。对于unsigned char来说，不管最高位是0，还是1，都不会做扩展。
  
 
char* 和 unsigned char*的区别
 
char* 和 unsigned char* 也具有类似的区别，如下面测试程序所示：
 
#include <stdio.h>

int main(int argc, char *argv[])
{
    unsigned char k = 0;
    int i = -1;
    short a = -12345;
    char *p;
    unsigned char *q;

    printf("sizeof(i) = %d\n",sizeof(i));
    printf("sizeof(a) = %d\n",sizeof(a));
    printf("-----------------------------\n");
    printf("begin p(char):\n");
    p = (char*)&a;
    printf("a = %u | %d\n",a,a);
    for(k=0;k<sizeof(a);k++)
    {
        printf("0x%x ",*(p++));
    }
    printf("\n");
    p = (char*)&i;
    printf("i = %u | %d\n",i,i);
    for(k=0;k<sizeof(i);k++)
    {
        printf("0x%x ",*(p++));
    }
    printf("\n");
    printf("-1 > 0u: %s\n",(-1>0u ? "true":"false"));

    printf("-----------------------------\n");
    printf("begin q(unsigned char):\n");
    q = (unsigned char*)&a;
    printf("a = %u | %d\n",a,a);
    for(k=0;k<sizeof(a);k++)
    {
        printf("0x%x ",*(q++));
    }
    printf("\n");
    q = (unsigned char*)&i;
    printf("i = %u | %d\n",i,i);
    for(k=0;k<sizeof(i);k++)
    {
        printf("0x%x ",*(q++));
    }
    printf("\n");
    printf("-1 > 0u: %s\n",(-1>0u ? "true":"false"));

    return 0;
}
 
输出结果为：
 
 
char*是有符号的，如果大于127即0x7F的数就是负数了，使用%x格式化输出，系统自动进行了符号扩展，就会产生变化。
 
所以在涉及到类型提升的上下文中，要注意使用char*和unsinged char*的区别。