目录

一、边界计算与不对称边界

1.栏杆错误

2.程序简化

3.编写程序

4.移动字符

5.打印元素

二、求值顺序

一、边界计算与不对称边界

在C语言中，这个数组的下标范围是从0到9。一个拥有10个元素的数组中，它的元素的下标范围是从0到n-1。

例如，让我们仔细地来看看本书导读中的一段代码：
int i，a=[10];
for(i=1;i<=10;i++)
a[i]=0;

这段代码本意是要设置数组a中所有元素为0，

在for语句的比较部分本来是i<10,却写成了i<=10，循环体内将并不存在的a[10]设置为0，这就陷入了一个死循环。

1.栏杆错误

在所有常见的程序设计错误中，最难于察觉的一类是“栏杆错误”，也常被称为“差一错误”

100英尺长的围栏每隔10英尺需要一根支撑用的栏杆，一共需要多少根栏杆呢？

(1)最“显而易见”的答案是将100除以10，得到的结果是10.当然这个答案是错误的，正确答案是11。
(2)要支撑10英尺长的围栏实际需要2根栏杆，两端各一根。

(3_除了最右侧的一段围栏，其他每一段10英尺长的围栏都只在左侧有一根栏杆；而例外的最右侧一段围栏不仅左侧有一根栏杆，右侧也有一根栏杆。

实际上提示了我们避免“栏杆错误”的两个通用原则：

(1)首先考虑最简单情况下的特例，然后将得到的结果外推，这是原则一。
(2)仔细计算边界，绝不掉以轻心，这是原则二。

例如，假定整数x满足边界条件x>=16且x<=37,那么此范围内x的可能取值个数有多少？

根据原则一，我们考虑最简单情况下的特例。这里假定整数x的取值范围上界与下界重合，即x>=16且x<=16,显然合理的x取值只有1个整数，即16。

再考虑一般的情形，假定下界为1，上界为h。如果满足条件“上界与下界重合”，即1=h,亦即h-1=0。根据特例外推的原则，我们可以得出满足条件的整数序列有h-1+1个元素。就是37-16+1，即22。

造成“栏杆错误”的根源正是“h-1+1”中的“+1”。一个字符串中由下标为16到下标为37的字符元素所组成的子串，

用第一个入界点和第一个出界点来表示一个数值范围。具体而言，前面的例子我们不应说整数x满足边界条件x>=16且x<=37,而是说整数x满足边界条件x>=16且x<38。

注意:

下界是“入界点”，即包括在取值范围之中；

上界是“出界点”，即不包括在取值范围之中。

2.程序简化

对于程序设计的简化效果却足以令人吃惊：
1.取值范围的大小就是上界与下界之差。38-16的值是22，是不对称边界16和38之间所包括的元素数目。
2.如果取值范围为空，那么上界等于下界。这是第1条的直接推论。
3.即使取值范围为空，上界也永远不可能小于下界。
对于像C这样的数组下标从0开始的语言，不对称边界给程序设计带来的便利尤其明显：

这种数组的上界（即第一个“出界点”）恰是数组元素的个数！因此，如果我们要在C语言中定义一个拥有10个元素的数组，那么0就是数组下标的第一个“入界点”（指处于数组下标范围以内的点，包括边界点），而10就是数组下标中的第一个“出界点”（指不在数组下标范围以内的点，不含边界点）。正因为此，我们这样写：
int a[10], i;
for(i=0;i<10;i++)
     a[i]=0;
而不是写成下面这样：
int a[10],i:
      for(i = 0;i <= 9;i++)

a [i] = 0;

那么下面这个语句的含义究竟是什么？
for (i= 0 to 10)
a[i] = 0;

如果10是包括在取值范围内的“入界点”，那么i将取11个值，而不是10个值。如果10是不包括在取值范围内的“出界点”

另一种考虑不对称边界的方式是，把上界视作某序列中第一个被占用的元素，而把下界视作序列中第一个被释放的元素。

当处理各种不同类型的缓冲区时，这种看待问题的方式就特别有用。这种看待问题的方式就特别有用。将长度无规律的输入数据送到缓冲区（即一块能够容纳N个字符的内存)中去，每当这块内存被“填满”时，就将缓冲区的内容写出。缓冲区的声明可能是下面这个样子：
# define N 1024 
static char bufferN 
我们再设置一个指针变量，让它指向缓冲区的当前位置：
static char * bufptr;

按照“不对称边界”的惯例，我们可以这样编写语句：
* bufptr++ = c;
这个语句把输入字符c放到缓冲区中，然后指针bufptr 递增1，又指向缓冲区中第1个未占用的字符。

当指针bufptr 与&buffer [0]相等时，缓冲区存放的内容为空，因此初始化时声明缓冲区为空可以这样写：
bufptr= & buffer[0];
或者，更简洁一点，直接写成：
bufptr = buffer;

任何时候缓冲区中已存放的字符数都是bufptr -buffer ,因此我们可以通过将这个表达式与N作比较，来判断缓冲区是否已满。当缓冲区全部“填满”时，表达式bufptr -buffer 就等于N,可以推断缓冲区中未占用的字符数为N-(bufptr -buffer )。

3.编写程序

我们就可以开始编写程序了，假设这个函数的名称是bufwrite 。函数bufwrite 有两个参数，第一个参数是一个指针，指向将要写入缓冲区的第1个字符；第二个参数是一个整数，代表将要写入缓冲区的字符数。假定我们可以调用函数flushbuffer 来把缓冲区中的内容写出，而且函数flushbuffer 会重置指针bufpur ,使其指向缓冲区的起始位置。如下所示：
 void
 bufwrite( char * p, int n)
  {
          while( --n> 0) {
                   if (bufptr = & buffer[N])
                          flushbuffer();
                 * bu fptr+ + = *p++;
         }
}
重复执行表达式--n>=0只是进行n次迭代的一种方法。

我们注意到前面出现了bufptr 与&buffer [N]的比较，而buffer [N]这个元素是不存在的,数组buffer 的元素下标从0到N-1,根本不可能是N。我们用这种写法：
if (bufptr = & buffer[N)
代替了下面等效的写法：
if (bufptr & buffer[ N 1]>
原因在于我们要坚持遵循“不对称边界”的原则：比较指针bufptr 与缓冲区后第一个字符的地址，而&buffer [N]正是这个地址。

我们并不需要引用这个元素，而只需要引用这个元素的地址，

ANSIC标准明确允许这种用法：数组中实际不存在的“溢界”元素的地址位于数组所占内存之后，这个地址可以用于进行赋值和比较。

4.移动字符

假定我们有一种方法能够一次移动k个字符。即使你的C语言实现没有提供这个函数，自己写一个也很容易：
void 
memcpy( char * dest ,const *char source, int k 
{

          while( --k >= 0)
         * dest++=*source++;
}

我们现在可以让函数bufwrite 利用库函数memcpy 来一次转移一批字符到缓冲区，而不是一次仅转移一个字符。

循环中的每次迭代在必要时会刷新缓存，计算需要移动的字符数，移动这些字符，最后恰当地更新计数器。如下所示：
void 
bufwrite( char * p, int n)
{
       while( n > 0) {
                 int k, rem;
                 if (bufptr == & buffer [ N] )
                                      flushbuffer();
                 rem = N - ( bufptr - buffer);
                  k = n > rem? rem: n ;
                 memcpy (bufptr ,p,k);
                  bufptr += k;
                 p += k;
                 n -= k;
}
}

在循环的入口处，n是需要转移到缓冲区的字符数。因此，只要n还大于0，

上面的代码中，最后四行语句管理着字符转移的过程：

(1)从缓冲区中第1个未占用字符开始，复制k个字符到其中；

(2)将指针bufptr 指向的地址前移k个字符，使其仍然指向缓冲区中第1个未占用字符

(3)输入字符串的指针p前移k个字符；

(4)将n(即待转移的字符数)减去k

5.打印元素

打印当前输入数值（即当前行的最后一个元素)，打印换行符以结束当前行，如果是一页的最后一行还要另起新的一页：
printnum(n);                     /打印当前行的最后一个元素*/
printr1();                          /另起新的一行*/
if = (++ row NROWS) {
            printpage ();
            row = 0 ;                    /*重置当前行号*/
             bufptr =buffer ;          /*重置指针bufptr */
}

因此，最后的print 函数看上去就像这样：
void
print( int n )
{
              if (bufptr = & buffer [ BUFSIZE] ) {
                   static int row = 0;
                    int * p;
                  for (p = buffer+ row; p < bufptr);
                        p += NRONS)
                       printnum(*p);
                       printnum(n);             /*打印当前行的最后一个元素*/
                        printnl();                   /*另起新的一行*/

                          if (++ row = NROWS) {
                          printpage();
                           row = 0               /*重置当前行序号*/
                            bufptr =buffer ;/*重置指针bufptr */
          }
        else 
                * butptr++ = n;
}

只需要编写函数flush ,它的作用是打印缓冲区中所有剩余元素，只需要将其作为内循环，在其上另外套一个外循环（作用是遍历一页中的每一行）
void
flush()
{
int row;

for (row = 0; row NROWS; row++)      {
int * p:
for (p = buffer row; p = bufptr;
                         p += NRONS)
printnum(*p);
printnl ();
}
printpage();
}

事实上，即使最后一页为空，函数flush 仍然还会全部打印出来，只不过一页全是空白而已。为了代码更加简洁，可以改为：

void
flush()
(
int row 
int k = bufptr -buffer ;            /*计算缓冲区中剩余项的数目*/
if (K >NROWS)
           K = NROWS;
if(k>0){
          for (row = 0; row < k; row++) {
int * p;
for (p = buffer + row; p< bufptr:
                        p += NROWS )
printnum(*p);
printnl();
}
printpage();
}
)

二、求值顺序

运算符优先级是关于诸如表达式
a + b * c 

应该被解释成
a + ( b * c) 

而不是
(a+b) * c

可以保证像下面的语句

if (count !=  0 && sum/ count smallaverage)
printf("average < %g\ n" , smallaverage);

即使当变量count 为0时，也不会产生一个“用0作除数”的错误。

例如，考虑下面的表达式：
a < b && c < d 

C语言的定义中说明a<b应当首先被求值。如果a确实小于b,此时必须进一步对c<d求值，以确定整个表达式的值。但是，如果a大于或等于b,则无需对c<d求值，表达式肯定为假。
另外，要对a<b求值，编译器可能先对a求值，也可能先对b求值，在某些机器上甚至有可能对它们同时并行求值。

C语言中只有四个运算符(&&、、？：和，)存在规定的求值顺序。运算符&&和运算符首先对左侧操作数求值，只在需要时才对右侧操作数求值。运算符？有三个操作数：在a?b:c中，操作数a首先被求值，根据a的值再求操作数b或c的值。而逗号运算符，首先对左侧操作数求值，然后该值被“丢弃”，再对右侧操作数求值。
C语言中其他所有运算符对其操作数求值的顺序是未定义的。特别地，赋值运算符并不保证任何求值顺序。

运算符&&和运算符对于保证检查操作按照正确的顺序执行至关重要。例如，在语句
if (y  != 0 && x/ y > tolerance)
            complain ();

中，就必须保证仅当y非0时才对xy求值。

i = 0;
while (i < n)
          y[i] = x[i++];

上面的代码假设y[i]的地址将在i的自增操作执行之前被求值，这一点并没有任何保证！

下面这种版本的写法与前类似，也不正确：
i=0;
while( i < n)
         y[i++]=x[i]:

另一方面，下面这种写法却能正确工作：
i = 0;
while (i < n) {
           y[i]=x[i];
           i++;
}

当然，这种写法可以简写为：
for (i = 0; i < n; i++)
      y[i]=x[i];