Турбо С: руководство пользователя. Часть 2 Автор "" Размер 800673 Байт Страница 14 из 56 СКАЧАТЬ КНИГУ ЦЕЛИКОМ

                                                                                
               Цикл while (пока).                                               
     -----------------------------------------------------------------          
                                                                                
          Этот цикл наиболее близок в обоих языках:                             
                                                                                
          while <булево выраж> do              while (<выраж>)                  
             <оператор>;                          <оператор>;                   
                                                                                
          В обоих языках, вы можете использовать блок для вставки нес-          
     кольких операторов в цикл. Единственная разница в том, что Си об-          
     ладает большей гибкостью в том,  что принимается за  <выражение>.          
     Для примера, сравните следующие два цикла:                                 
                                                                                
                                                                                
         Read(Kbd,Ch);                                                          
         while Ch <> 'g' do begin       while ((ch = getch()) != 'g')           
            Write(Ch); Read(Kbd,Ch);       putchar(ch);                         
         end;                                                                   
                                                                                
                                                                                
                                                                                
               Цикл do...while (выполнять...пока).                              
     ----------------------------------------------------------------           
                                                                                
          Цикл do...while аналогичен циклу repeat...until в Паскале:            
                                                                                
              repeat                     do                                     
                  <операторы>                <оператор>;                        
              until<булево выраж>;       while <выраж>;                         
                                                                                
          Но есть и два важных отличия между двумя циклами:                     
                                                                                
          - Цикл  do...while  выполняется  пока  <выраж>  истино,    а          
            repeat...until до   тех пор,  когда <булево выраж.> станет          
            истинно.                                                            
                                                                                

                         - 111,112 -
                                                                                
                                                                                
          - Оператор repeat...until не требует  блока  для  нескольких          
            операторов, а do...while требует.                                   
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
          Ниже приводятся примеры для каждого цикла:                            
                                                                                
                Турбо Паскаль                     Турбо Си                      
     ----------------------------------------------------------------           
                                                                                
     repeat                           do {                                      
       Write('Введите значение: ');     printf("Введите значение: ");           
       Readln(A)                         scanf("%d",@a); }                      
     until(Low<=A) and (A<=High);     while (a < low || a > high);              
                                                                                
     ----------------------------------------------------------------           
                                                                                
          В дополнение  отметим  важные различия в Си и Паскале:  в Си          
     операции сравнения (<,> и др.) имеют более высокий приоритет, чем          
     логические (&&,  ||). Это позволяет вам не заключать каждое выра-          
     жение сравнения в круглые скобки, как это вы делаете в Паскале.            
                                                                                
                                                                                
                                                                                
               Цикл for (для).                                                  
     -----------------------------------------------------------------          
                                                                                

                         - 113,114 -
                                                                                
          Реализация цикла for наиболее различается при программирова-          
     нии на Паскале и Си.  В Паскале for - цикл более постоянный,  а в          
     Си он более гибкий, разрешающий конструкции, с которыми он теряет          
     всякое сходство с циклом for.                                              
                                                                                
          Формат этого цикла следующий:                                         
                                                                                
     for<индекс>:=<нач>to<кон>do      for(<выраж1>;<выраж2>;<выраж3>)           
            <оператор>;                           <оператор>;                   







Загрузка...








                                                                                
          В Си оператор for - это просто специальный случай оператора           
     while:                                                                     
              <выраж1>                                                          
              while (<выраж2>) {                                                
                  <оператор>;                                                   
                  <выраж3>;                                                     
              }                                                                 
                                                                                
          где <выраж1> используется для инициализации,                          
              <выраж2> для определения конца цикла,                             
              <выраж3> для изменения параметра(ов) цикла.                       
                                                                                
                                                                                
                                                                                
          Ниже приведено несколько примеров,  которые используют  цикл          
     while на Паскале:                                                          
                                                                                
          Турбо Паскаль                   Турбо Си                              
     ----------------------------------------------------------------           
                                                                                
     for I := i to 10 do begin        for (i = i;i<=10;i++) {                   
     Write('I = ',I:2);               printf("i = %2d ",i);                     
     Write(' I*I = ',(I*I):4);        printf("i*i = %4d ",i*i);                 
     Writeln(' I**3 = ',(I*I*I):6)    printf("i**3=%6d\n",i*i*i);               
     end;                             }                                         
                                                                                
     I := 17; K := I;                                                           
     while (I>-450) do begin          for (i=17, k=i; i >-450;                  
     K := K + I;                      k+=i, i-=15)                              
     Writeln('K=',K,'I=',I);          printf("k=%d i=%d\n",k,i);                
     I := I - 15                                                                
     end;                                                                       
                                                                                
     X := D/2.0;                      for(x=d/2; fabs(x*x-d)>0.01;              
     while(Abs(X*X-D)>0.0I) do        x = (x+d/x)/2)                            

                         - 115,116 -
                                                                                
                                                                                
     X := (X + D/X)/2.0;              ;      /*Пустой оператор*/                
     ----------------------------------------------------------------           
                                                                                
          Заметим, что этот цикл позволяет включать внутрь секции  for          
     так много,    что в конце концов может не остаться операторов для          
     выполнения; все действия будут производится внутри заголовка цик-          
     ла.                                                                        
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
          Подпрограммы.                                                         
     -----------------------------------------------------------------          
                                                                                
          И в  Паскале и Си имеются подпрограммы; Паскаль имеет проце-          
     дуры и функции,  в то время как Си имеет только функции.  Однако,          
     вы можете объявить функцию типа void,  что позволит ей не возвра-          
     щать никакого значения; если вы захотите, то можете также игнори-          
     ровать значение, выдаваемое функцией.                                      
                                                                                
          Формат функции в обоих языках следующий:                              
                                                                                
          Турбо Паскаль                       Турбо Си                          
     ----------------------------------------------------------------           
                                                                                
     function FName(<описан.парам>)       <тип> FName(<описан.парам>)           
                :<тип>;                                                         
       <локальные описания>                                                     
     begin                                 {                                    
       <операторы>                            <локальные описания>              
     end;                                     <операторы>                       
                                           }                                    
     ----------------------------------------------------------------           

                         - 117,118 -
                                                                                
                                                                                
          В Паскале <описание параметров> дается в форме <имена пара-           
     метров>:<тип>;  для каждой группы параметров. В Си - <тип><имена           
     параметров>.                                                               
                                                                                
          Другие важные различия видны из примера:                              
                                                                                
          Турбо Паскаль                       Турбо Си                          
     ----------------------------------------------------------------           
                                                                                
     function Max(A,B : Integer):Integer;   int max(int a, int b)               
     begin                                  {                                   
       if A > B                                 if (a > b)                      
       them Max := A                               return(a);                   
       else Max := B                            else                            
                                                   return(b);