Лекции по увод в програмирането



страница12/16
Дата25.07.2016
Размер0.96 Mb.
#5224
ТипЛекции
1   ...   8   9   10   11   12   13   14   15   16

26 ноември

22. Разделно компилиране.


Разделното компилиране е възможност за самостоятелно компилиране на отделни първични файлове, които образуват една програма; те се наричат модули и могат да се редактират и компилират по общоприетите правила; на етапа свързване, обектните файлове на всички модули се обединяват в един общ изпълним файл на програмата;

за всички модули главната функция е точно една; функциите в различните модули могат да обменят информация по два начина:



за да се направи една външна променлива, дефинирана в един модул, обща и за други модули тя трябва да бъде повторно описана като се декларира в тях по следния начин:

Синтаксис:

extern име_на_тип име_на_променлива;
ключовата дума extern трябва задължително да присъства; това описание информира компилатора, че променливата е дефинирана в друг модул; това повторно описание се нарича деклариране, и то е различно от дефинирането; докато при дефинирането се разпределя памет от компилатора за променливата, при декларирането това не се прави, но свързващият редактор разпределя за нея същата памет, която е разпределена за съответната дефинирана променлива;
инструкциите към компилатора за разделно компилиране зависят от средата:

в Turbo C и Borland C това става в проектен файл, където са записани имената на първичните файлове;

това че една променлива е обща за няколко модула, означава, че всеки модул има достъп до нея и тя може да бъде променяна във всеки модул; ако декларирането на една променлива като extern е извън функциите в модула, то важи за всички функции след декларацията; една променлива може да бъде декларирана като extern във функция или блок и тогава нейната област на действие започва от декларацията и свършва в края на функцията или блока;
когато един масив се посочва като extern, не е задължително да се задава първата размерност; другите размерности не могат да се пропускат, за да може по индексите на елементите еднозначно да се попадне в паметта, разпределена за съответния елемент от масива;

Пример:


extern float a[ ];

extern int b [ ][10];


когато срещне ключовата дума extern, свързващият редактор преглежда най-напред дефинициите в текущия модул; ако не намери съответната външна променлива в този модул, свързващият редактор търси съответствие в другите модули на програмата; ако не намери подходяща дефиниция и там, тогава търсенето продължава в указаните или приетите по подразбиране библиотеки;

Пример с два модула:


file1.cpp file2.cpp
#include #include

unsigned array[20]; extern unsigned array[];

void main () void fun3()

{ extern double x; { extern char ch;

int a; extern double x;

a = 5; array[3] = 100;

array[0] = 25; ch = ‘F’;

x = 1.5; x = 3.14;

… …

} }


char ch; void fun4 ()

void fun1 () { int a;

{ int a; extern char ch;

a = 8; ch = ‘I’;

ch = ‘K’; array[4] = 125;

array[1] = 50; …

… }

}

double x;



void fun2 ()

{ int a;


a = 10;

ch = ‘A’;

array[2] = 75;

x = 2.5;


}
първи модул:

областта на действие на външния масив array е всички функции в модула;

функция main:

деклариране на променливата x – свързващият редактор търси външна променлива със същото име и я открива – тя има област на действие функцията fun2 и за нея памет е разпределил компилатора; свързващият редактор разпределя за нея същата памет като тази за намерената външна променлива x; областта на действие на декларираната x е функцията main;

променливите a са различни и са локални за фунцкиите в които са дефинирани, те не могат да се използват в други функции;

променливата ch е външна и има област на действие функциите fun1 и fun2;

втори модул:

деклариране на масив array – свързващият редактор търси дефиницията на външен масив със същото име – най-напред в същия модул, след това в другите модули и го намира; след това разпределя за него същата памет, която компилатора е разпределил в първия модул; декларираният array има област на действие целия втори модул;

функция fun3:

деклариране на ch, която е вътрешна за fun3 - свързващият редактор я намира в първи модул; аналогично за декларирането на променливата x;

функция fun4:

деклариране на ch, която е вътрешна за fun4 – свързващият редактор я намира в първи модул; дефиниране на локална променлива a, която може да се използва само във fun4;
по подразбиране имената на функциите са външни, т.е. в един модул можем да се обръщаме към функция, която е дефинирана в друг модул; в този случай, обаче, трябва да се опише прототипа на извикваната функция, като в началото на това описание се поставя ключовата дума extern; в C++ тя може да се пропусне;

въпросът стои по същия начин и за стандартните функции, които се разглеждат като дефинирани в друг модул;

за удобство, прототипите на потребителските функции могат да се оформят в потебителски заглавен файл, който да се включва в модула;

ако една функция (или променлива) е дефинирана като static, то към нея може да има обръщение само в модула, в който тя е дефинирана;


Пример:
modul1.cpp modul2.cpp

#include extern int mas[];

int mas[10]; int max (int size)

extern int max (int); { int comp; int i;

void main () comp = mas[0];

{ int br, i; for (i=0; i < br; i++)

printf(“Въведете броя на числата: “); if (mas[i]>comp)

scanf(“%d”, &br); comp = mas[i];

for (i = 0; i < br; i++) return comp;

{ printf(“Въведете mas[%d]: “); }

scanf(“%d”,&mas[i]);

}

printf (“Максималният елемент е %d\n”, max(br));



}




Сподели с приятели:
1   ...   8   9   10   11   12   13   14   15   16




©obuch.info 2024
отнасят до администрацията

    Начална страница