欧美三级午夜理伦三级中视频,91久久精品国产91性色tv,亚洲一区二区三区在线看

Signed to unsigned conversion in C - is it always safe? (from stackoverflow)

Snape — Thu, 16 Aug 2012 18:32:00 GMT

Suppose I have the following C code.

unsigned int u = 1234;
int i = -5678;

unsigned int result = u + i;

What implicit conversions are going on here, and is this code safe for all values of u and i? (Safe, in the sense that even though result in this example will overflow to some huge positive number, I could cast it back to an int and get the real result.)

Answer:

Short Answer

Your i will be converted to an unsigned integer by adding UINT_MAX + 1, then the addition will be carried out with the unsigned values, resulting in a large result (depending on the values of u andi).

Long Answer

According to the C99 Standard:

6.3.1.8 Usual arithmetic conversions
If both operands have the same type, then no further conversion is needed.
Otherwise, if both operands have signed integer types or both have unsigned integer types, the operand with the type of lesser integer conversion rank is converted to the type of the operand with greater rank.
Otherwise, if the operand that has unsigned integer type has rank greater or equal to the rank of the type of the other operand, then the operand with signed integer type is converted to the type of the operand with unsigned integer type.
Otherwise, if the type of the operand with signed integer type can represent all of the values of the type of the operand with unsigned integer type, then the operand with unsigned integer type is converted to the type of the operand with signed integer type.
Otherwise, both operands are converted to the unsigned integer type corresponding to the type of the operand with signed integer type.

In your case, we have one unsigned int (u) and signed int (i). Referring to (3) above, since both operands have the same rank, your i will need to be converted to an unsigned integer.

6.3.1.3 Signed and unsigned integers
When a value with integer type is converted to another integer type other than _Bool, if the value can be represented by the new type, it is unchanged.
Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or subtracting one more than the maximum value that can be represented in the new type until the value is in the range of the new type.
Otherwise, the new type is signed and the value cannot be represented in it; either the result is implementation-defined or an implementation-defined signal is raised.

Now we need to refer to (2) above. Your i will be converted to an unsigned value by adding UINT_MAX + 1. So the result will depend on how UINT_MAX is defined on your implementation. It will be large, but it will not overflow, because:

6.2.5 (9)
A computation involving unsigned operands can never overflow, because a result that cannot be represented by the resulting unsigned integer type is reduced modulo the number that is one greater than the largest value that can be represented by the resulting type.

Bonus: Arithmetic Conversion Semi-WTF

#include 

int main(void)
{
  unsigned int plus_one = 1;
  int minus_one = -1;

  if(plus_one < minus_one)
    printf("1 < -1");
  else
    printf("boring");

  return 0;
}

You can use this link to try this online: http://codepad.org/yPhYCMFO

Bonus: Arithmetic Conversion Side Effect

Arithmetic conversion rules can be used to get the value of UINT_MAX by initializing an unsigned value to -1, ie:

unsigned int umax = -1; // umax set to UINT_MAX

This is guaranteed to be portable regardless of the signed number representation of the system because of the conversion rules described above. See this SO question for more information: Is it safe to use -1 to set all bits to true?

Snape 2012-08-17 02:32 发表评论

chapter 7(可移植性缺�?

Snape — Sun, 24 Jun 2012 23:10:00 GMT

1.标示�W�名�U�的限制

ANSI C标准只保证了C实现必须能够区别出前6个字�W�不同的外部名称。而且�q�个定义中�ƈ没有区分大写字母与其对应的小写字母�?/span>
因此�Q�编写可�U�L��E�序必须��心�q�一炏V�?br />
2.字符是有�W�号的整敎ͼ��q�是无符��L��整数
只有把一个字�W��D�{�?span style="color: red; ">��Z��个较大的整数�Ӟ��才重要。在其他情况下，�l�果都是�Q�多余的位被��单的“丢弃”�?br />
在�{换过�E�中�Q�应该将字符作�ؓ有符��h��q�是无符��h��Q?br />如果有符��P��~�译器将char数据�Q�扩展到int时候，应该复制�W�号位�?br />如果无符��P��~�译器只需在多余的位上填充0.

#include

int main()
{
    char c='a';
    c=c+40;
//    printf("%c\n", -1);
    printf("c %d\n", c);
    printf("unsigned c %u\n", (unsigned char)c);
}

�l�果�Q?br />

c -119
unsigned c 137

说明在gcc中，��char当做有符��h��。在c+40的时候，��过�?128~127范围�Q�因此溢出。如果是无符号char�Q�范围是0~255.应该是输�?37.

如果�~�程者关注一个最高位�?的字�W�是正还是负�Q�可以设�|?span style="color: red; ">为无�W�号字符�?/span>。这��h��有编译器都会转换为整数时候，填充�?.

3.一个常见错误是�Q�如果c是一个字�W�变量，使用�Q�unsigned�Q�c可以得到与c�{��h的无�W�号整数�?span style="color: red; ">�q�是会失败的。因为在��c转换为无�W�号整数时候，c��首先首先被转换为int型整数。而此时可能得到非预期的结果�?br />正确�Ҏ��?/span>�Q?unsigned char )c�Q�直接进行�{换�?br />
例如上个例子中，最后一句改�?

printf("unsigned c %u\n", (unsigned )c);

那么�l�果�?

c -119
unsigned c 4294967177

c被先转换为int�?119�Q�再求他的无�W�号表达形式�Q?span style="font-size: 13px; background-color: #eeeeee; ">4294967177

4.�U�M��q�算�W?br /> 1.向右�U�M��Ӟ��I�出的位�?填充�Q�还是由�W�号位的副本填充�?br /> 2.如果是无�W�号敎ͼ��?填充。如果是有符��h��Q�既可以�?也可以用�W�号位的副本。（如果��x��右移时候空出的位，可以声明为无�W�号�c�d��Q�那么空出的位都会被讄��?�Q?br />
如果被移位对象�ؓn位，那么�U�M��计数必须大于或等�?�Q�而严格小于n.
即��C实现��符号位复制到空出的位中�Q�有�W�号数的向右�U�M��Q?span style="color: red; ">也�ƈ不等于除�?的某�ơ幂。例如（-1�Q?gt;>1�l�果�?1�Q�而不�?1/2 == 0

5.随机数最大��|��RAND_MAX在limits中定义。我��试�l�果�{�于INT_MAX

6.除法�q�算的截�?br />q=a/b;
r=a%b;
假定b>0.
C语言定义只保证q*b+r=a,以及a>=0 �?b>0�Ӟ��保证|r|<|b|以及r>=0.
�Q�如果a<0, 那么r也可能小�?�Q?/span>
例如�Q?br />

int main() {
    // Start typing your code here

    cout<<(-3)/2<    return 0;
}

�l�果商�ؓ-1�Q�余��C��?1

Snape 2012-06-25 07:10 发表评论

chapter 6�Q�预处理器）

Snape — Sun, 24 Jun 2012 18:26:00 GMT

使用预处理器的两个主要原因：
�Q?一�ơ修改变量，出现的所有的值都会修攏V�?br />讲所有常量定义集中在一赗��?br />
�Q?避免函数调用开销�?br />
3.宏定义注意点
1.不能忽视定义中的�I�格
2.最好将宏定义中每个参数都用括号括�v来。整个表辑ּ�的结果页用括��h��h��?br /> 3.��保调用宏的参数中，不存在有副作用的代码

4.assert宏。可以在出错信息中包含文件名和断�a��p�|处的行号。很有用�?br />
5.宏�ƈ不是�c�d��定义�?br />#define T1 struct foo *
typedef struct foo * T2;
T1 a,b; //struct foo * a, b;
T2 a,b; //a ,b都是指向�l�构的指针�?img src ="http://m.shnenglu.com/chenglong7997/aggbug/180104.html" width = "1" height = "1" />

Snape 2012-06-25 02:26 发表评论

chapter 5

Snape — Sun, 24 Jun 2012 18:10:00 GMT

1.getchar

getchar�q�回整�Ş

#include

int main()
{
    char c;
    while( (c=getchar())!=EOF )
        putchar(c);
}

应该��c声明为int。否则，c可能无法容下EOF

2.更新文�g
��L��作之后，文�g指针会偏�U�M��D�c��这时候，讲文件更新后�Q�写入源文�g之前�Q�应该fseek讲文件指针调回去�?br />
3.使用setbuf讄��输出的缓冲区大小。可以是stdout和file

4.正确使用errno��错�?br />errno=0;
/*调用库函�?/
if(�q�回的错误�? //�q�个错误值可能不是由当前�q�个函数引�v的。而是由当前函敎ͼ�又调用的另外一个函数引��L��?br /> ��查errno;

5.signal处理函数唯一安全�Q�可�U�L��的操作就是打��C��条错误信息，然后使用longjmp或者exit立即退出程序�?br />

Snape 2012-06-25 02:10 发表评论

chapter 4

Snape — Sun, 24 Jun 2012 17:41:00 GMT

1.如果一个函��C��仅被同一个源文�g中的其他函数调用�Q�我们就应该声明该函��Cؓstatic

2.extern int n;
在两外一个文件中�Q?long n�Q?br />�q�是一个无效的�E�序�Q�因为同一个外部变量名在两个不同的文�g中被声明��Z��同的�c�d��。然后大多数c语言实现不能��出�q�种错误�?br />
3.一个程序由多个模块�l�成�Q�每个模块都需要知道一个特定的文�g名。我们希望能够做到只在一处改动这个文件名�Q�所有模块中的文件名��p��同时得到更新�?br />可以�Q�先创徏一个文�Ӟ��叫做file.h�Q�它包含了声�?span style="color: red; ">extern char filename[];
需要用到外部对象filename的每个c源文仉��应该加上�Q?#include "file.h"�Q?br />最后选择一个C源文�Ӟ��在其中给出filename的初始倹{��如在file.c�?br />#include "file.h";
char filename[]="/etc/passwd";

�q�样��׃��证了filename的类型是正确的。解决了2中的问题�?img src ="http://m.shnenglu.com/chenglong7997/aggbug/180101.html" width = "1" height = "1" />

Snape 2012-06-25 01:41 发表评论

整数溢出

Snape — Sun, 24 Jun 2012 17:15:00 GMT

整数溢出
c语言中存在两�c�L��数算术运��，有符可��和无符可��?span style="color: #ff00ff; ">在无�W�号�q�算里，没有了符号位�Q�所以是没有溢出的概�늚��?/p>

所有的无符�?span style="color: red; ">�q�算都是�?的n�ơ方为模。如果算术运��符的一个操作数是有�W�号书，另一个是无符��h��Q�那么有�W�号�?/p>

会被转换为无�W�号�?/span>(表示范围��的��L��被�{换�ؓ表示范围大的)�Q�那么溢��Z��不会发生。但是，当两个操作数都是有符��h��

�Ӟ��溢出��有可能发生。而且溢出的结果是未定义的�?span style="color: red; ">当一个运��的�l�果发生溢出�Ӟ��M��假设都是不安全的�?/span>

例如�Q�假定a和b是两个非负的整型变量(有符�?�Q�我们需要检查a+b是否溢出�Q�一�U�想当然的方式是:

if (a + b < 0)

溢出�Q?/p>

实际上，在现实世界里�Q�这�q�不能正常运行。当a+b��实发生溢出�Ӟ��所有关于结果如何的假设均不可靠。比如，在某�?/p>

机器的cpu�Q�加法运��将讄��一个内部寄存器为四�U�状�?正，负，零和溢出。在�q�种机器上，c�~�译器完全有理由实现以上

的例子，使得a+b�q�回的不是负�Q�而是�q�个内存寄存器的溢出状态。显�Ӟ��if的判断会��p�|�?/p>

一�U�正��的方式是将a和b都强制�{换�ؓ无符��h��敎ͼ�

if ( (unsigned)a + (unsigned)b > INT_MAX)

溢出;

�q�里的int_max��gؓ有符��h��型的最大倹{��在一般的�~�译器里是一个预定义的常量。ANSI C在limits里定义了INT_MAX�Q��gؓ

2�?1�ơ方-1.

不需要用到无�W�号��数�q�算的另一�U�可行方法是�Q?/p>

if (a > INT_MAX - b )

溢出�Q?nbsp;

Snape 2012-06-25 01:15 发表评论

关于判断无符��h��数想加溢出（转闲��堂）

Snape — Sun, 24 Jun 2012 17:11:00 GMT

Snape 2012-06-25 01:11 发表评论

chapter 3(语义陷阱)

Snape — Sun, 24 Jun 2012 15:53:00 GMT

1.int a[10]; 除了a被用作运��符sizeof()的参数这一情况�Q�在其他所有的情�Ş中，数组名a都代表指向数�l?span style="color: red; ">a中下标�ؓ0的元素的指针�?/span>
因此�Q�int *p=a; //right
int *p=&a; //error, (&a已经是一个指向整个数�l�的指针)

2.为main函数提供�q�回�?br />main�Q�）
{}
隐含着main�q�回整数�Q?span style="color: red; ">一个返回整数的函数如果�q�回��p�|�Q�实际上隐含�q�回某个“垃圾”整数�Q�只要该��g��被用刎ͼ��无关紧要�?br />然而，在某些情况下�Q�main的返回值却�q��无关紧要�Q�大多数C语言实现通过main的返回��|��来告知操作系�l�该函数的执行是成功�q�是�?/span>�?/span>。如果一个程序的main函数�q�不�q�回��M��|��那么有可能看上去执行��p�|。所以最好提供返回�?br />
3.边界计算与不对称边界�?br />适合c中以下标�?开始的计算�?/span>

Snape 2012-06-24 23:53 发表评论

chapter 1

Snape — Fri, 22 Jun 2012 22:21:00 GMT

1.y=x/*p; //p指向除数
error.
/*会被当做注释的开始。应该y=x / *p;
或者y = x/(*p);

2.如果一个整形常量第一个字�W��ؓ数字0.那么�q�个帔R��会被当做8�q�制数�?img src ="http://m.shnenglu.com/chenglong7997/aggbug/179858.html" width = "1" height = "1" />

Snape 2012-06-23 06:21 发表评论