КОМПЬЮТЕРНАЯ ЛИТЕРАТУРА - Турбо С: руководство пользователя. Часть 2 - Стр. 19

Индекс материала
Турбо С: руководство пользователя. Часть 2
Стр. 2
Стр. 3
Стр. 4
Стр. 5
Стр. 6
Стр. 7
Стр. 8
Стр. 9
Стр. 10
Стр. 11
Стр. 12
Стр. 13
Стр. 14
Стр. 15
Стр. 16
Стр. 17
Стр. 18
Стр. 19
Стр. 20
Стр. 21
Стр. 22
Стр. 23
Стр. 24
Стр. 25
Стр. 26
Стр. 27
Стр. 28
Стр. 29
Стр. 30
Стр. 31
Стр. 32
Стр. 33
Стр. 34
Стр. 35
Стр. 36
Стр. 37
Стр. 38
Стр. 39
Стр. 40
Стр. 41
Стр. 42
Стр. 43
Стр. 44
Стр. 45
Стр. 46
Стр. 47
Стр. 48
Стр. 49
Стр. 50
Стр. 51
Стр. 52
Стр. 53
Стр. 54
Стр. 55
Стр. 56
Все страницы
                                                                                
                                                                                
                                                                                
               Приведение типов.                                                
     -----------------------------------------------------------------          
                                                                                
          Паскаль, как правило,  позволяет использовать только ограни-          
     чение типов. Функция Ord() переводит из любого порядкового (пере-          
     числимого) типа  в Integer; Chr() переведит из Integer (или родс-          
     твенных типов) в Char. Турбо Паскаль допускает некоторые добавоч-          
     ные типы при переводе (так называемое retyping)  между всеми  по-          
     рядковыми типами (Integer,  Char, Boolean и переменным типам дан-          
     ных). Си  более свободен и позволяет вам пробовать  смену  одного          
     типа на любой другой, но без гарантии благоприятного исхода.               
                                                                                
          Турбо Паскаль                           Турбо Си                      
     ----------------------------------------------------------------           
                                                                                
         ;                                         
                                                                                
          Элементы данных,  нуждающиеся более  чем  в  одной  величине          
     (массивы, структуры)  должны иметь значения, заключенные в фигур-          
     ные скобки и отделенные запятыми ({like_this, and_this, and_this_          
     too}).                                                                     
                                                                                
         int  x = 1, y = 2;                                                     
         char name []="Франк";                                                  
         char answer ='Y';                                                      
         char key = 3;                                                          
         char list[2] [10] = {"Первый", "Второй"};                              
                                                                                
                                                                                
                                                                                
                                                                                
               Переменные памяти.                                               
     -----------------------------------------------------------------          
                                                                                
          Си определяет  несколько  классов памяти для переменных; два          
     наиболее важных - external (внешний)  и automatic (local)  (мест-          
     ный). Глобальные  переменные (которые описываются вне любой функ-          
     ции, включая основную) являются внешними по умолчанию. Это подра-          
     зумевает, что    им  присваивается  начальное значение 0 в начале          
     выполнения программы, если вы сами не присвоили им значения.               
                                                                                
          Переменные, указываемые в пределах функций (в том числе  ос-          
     новной), принимаются  по умолчанию automatic. Им не присваиваются          
     значения, если вы не сделали это, и они теряют свои величины меж-          
     ду вызовами этой функции. Однако вы можете указать такие перемен-          
     ные static; им будет присвоен 0 (сразу, в начале выполнения прог-          
     раммы) и они сохранят свои значения между вызовами функций.                
                                                                                
          Рассмотрим следующий пример                                           
                                                                                
          init test (void)                                                      
          {                                                                     
            int i;                                                              

                         - 157,158 -
                                                                                
            static int count;                                                   
            ...                                                                 
          }                                                                     
                                                                                
          Переменная i находится в стеке и может быть инициализирован-          
     на функцией test каждый раз,  когда вызывается программа.  Cтати-          
     ческая переменная count,  c другой стороны находится в глобальной          
     зоне данных и инициализируется нулем, когда программа выполняется          
     впервые. Count  сохраняет свое предыдущее значение при  следующем          
     вызове функции test.                                                       
                                                                                
                                                                                
                                                                                
               Динамическое распределение памяти.                               
     -----------------------------------------------------------------          
                                                                                
          В Турбо Паскале есть несколько методов для управления  кучей          
     (динамической областью памяти). Дадим следующее описание на Турбо          
     Паскале:                                                                   
                                                                                
       type                                                                     
         ItemType=Integer;                                                      
                                                                                
         ItemPtr=^ItemType;                                                     
                                                                                
       var                                                                      
         p : ItemPtr;                                                           
                                                                                
           На практике используется три различных метода распределения          
     и освобождения динамической памяти:                                        
                                                                                
         (* New и Dispose*)                                                     
                                                                                
         New(p);                   {Автоматическое размещение                   
                                                   требуемой памяти}            
         ...                                                                    
         Dispose(p);               {Автоматическое освобождение                 
                                              задействованой памяти}            
                                                                                
         (*New, Mark и Release*)                                                
                                                                                
         New (p);                  {Автоматическое размещение                   
                                                   требуемой памяти}            
         ...                                                                    
         Mark(p);                                                               

                         - 159,160 -
                                                                                
         Release(p)                {Освобождение всей динамической              
                                   памяти, начиная с p до конца кучи}           
                                                                                
         (*FreeMem и GetMem*)                                                   
                                                                                
         GetMem(p, Sizeof(ItemType));  {Определение объема памяти               
                                                     для размещения}            
         ...