[Powered by Google Translate] Rob BOWDEN: sabihin makipag-usap tungkol sa mga compiler.
Hanggang sa puntong ito, na iyong nai-type ang iyong source code sa
ilang mga file, ay nagpadala ng mga ito sa pamamagitan ng malaking itim na kahon na
Kumalatong, at out ay ang iyong executable file na ginagawa
eksakto kung ano ang iyong sinulat ni sa iyong source code.
Bilang kahima-himala bilang na naging, kami ay pagpunta sa ng malapitan
tumingin sa kung ano ang aktwal na nangyayari
kapag namin ipunin ang isang file.
Kaya kung ano ang ibig sabihin upang makatipon ng isang bagay?
>> Well, sa pinaka-pangkalahatang kahulugan, ito lamang ay nangangahulugan
pagbabago ng code na nakasulat sa isang
mga programa ng wika papunta sa isa pa.
Ngunit karaniwang kapag ang mga tao sabihin sila makatipon ng isang bagay, sila
ibig sabihin ng mga ito ay ang pagkuha ito mula sa isang mas mataas na antas ng programming
wika sa isang mas mababang antas ng wika programming.
Mga ito ay maaaring mukhang tulad ng napaka subjective na mga tuntunin.
Halimbawa, marahil ay hindi sa tingin ng C bilang isang mataas na
antas ng programming language, ngunit mo makatipon ito.
Subalit ang lahat ng kamag-anak.
Tulad ng makikita namin makita, ang assembly code at kalaunan machine
ang code na namin makatipon down sa undeniably isang mas mababang antas
kaysa C.
Kahit na makikita namin ginagamit kumalatong sa demonstration ngayon,
maraming ang mga ideya dito dalhin sa iba pang mga compiler.
>> Kumalatong, mayroong apat na pangunahing hakbang sa pangkalahatang
compilation.
Ito ang isa, preprocessing ginawa ng Preprocessor; dalawang,
compilation tapos ng tagatala; tatlong, assembling
ng assembler; at apat,
nagli-link tapos ng linker.
Maaari itong nakakalito na ang isa sa ang mga substeps ng pangkalahatang
Kumalatong compiler ay tinatawag na tagatala, ngunit
namin iyon.
Namin gamit ang isang simpleng kumusta mundo ng programa bilang aming halimbawa
sa buong ang video na ito.
Natin tingnan.
>> Ang unang hakbang ay preprocessing.
Ano ang Preprocessor gawin?
Medyo magkano ang bawat C programa nabasa mo na o nakasulat,
ginamit mo ang mga linya ng code na nagsisimula sa isang hash.
Tatawag ako ito na hash, ngunit maaari ka ring tumawag ito ng pounds, ang bilang
mag-sign, o matalim.
Anumang naturang linya ay isang Preprocessor panuto.
Malamang iyong nakita # tukuyin at # include bago, ngunit may
ilang higit pa na kinikilala ang Preprocessor.
Natin magdagdag ng # tukuyin sa aming kumusta Halimbawa ng mundo.
Ngayon sabihin patakbuhin lamang ang Preprocessor sa ang file na ito.
Sa pamamagitan ng pagpasa ng clage sa-E-flag, ka nagtuturo ito na tumakbo
lamang ang Preprocessor.
Natin makita kung ano ang mangyayari.
Mukhang kumalatong lamang spits ang lahat
sa linya ng command.
Upang i-save ang lahat ng ito output sa isang bagong file na tinatawag na
hello2.c, makikita namin ikabit ang> hello2.c sa aming utos.
Ngayon sabihin tingnan sa aming preprocessed file.
>> Whoa, kung ano ang nangyari sa aming maikling maliit na programa?
Kung pumunta namin ang lahat ng mga paraan sa ibaba ng file na ito, gagamitin namin ang
ilan sa ang code na namin ang aktwal na sinulat ni.
Pansinin na ang # tukuyin ay nawala at ang lahat ng mga pagkakataon ng mga pangalan
ay pinalitan ng kung ano mismo ang tinukoy namin sa
ang # tukuyin ang linya.
Kaya kung ano ang lahat ng mga typedefs at mga function na pagdeklara
sa tuktok ng file?
Pansinin na ang # tukuyin ay hindi lamang ang Preprocessor
panuto na aming tinukoy.
Din kami ng # include stdio.h.
Kaya lahat ng mga nakatutuwang linya ay talagang lamang stdio.h kinopya
at ilagay sa tuktok ng file na ito.
Iyon ay kung bakit ang header file ay kaya kapaki-pakinabang para sa function na
deklarasyon.
Sa halip na nangangailangan upang kopyahin at i-paste ang lahat ng pag-andar
pagdeklara ng plano mong sa paggamit sa tuktok ng iyong mga file, ang
Preprocessor ay kopyahin at i-paste ang mga ito mula sa header
-file para sa iyo.
>> Ngayon na tapos na kami preprocessing, ilipat namin patungo sa daloy ng mga sasakyan sa
compilation.
Ang dahilan Tinatawag namin ang hakbang na ito compilation ay dahil ito ay
ang mga hakbang na kung saan kumalatong aktwal ay nito kino-compile ang mula sa C upang
assembly code.
Upang magkaroon ng kumalatong makatipon ng isang file sa pagpupulong, ngunit
patuloy na walang karagdagang, ipasa ang mga ito ang-S bandila
sa linya ng command.
Natin ng hitsura sa pagpupulong
file na outputted.
Mukhang pa ng ibang wika.
Assembly code ay napaka processor tukoy na.
Sa kasong ito, dahil ang CS50 appliance ay tumatakbo sa isang
virtual x86 processor, ito ay x86 assembly code.
Napakakaunting mga tao sumulat nang direkta sa assembly code mga araw na ito,
ngunit ang bawat C programa sakaling sumulat ay makakakuha transformed pababa
sa pagpupulong.
Muli, tawagan namin ang hakbang na ito kino-compile ang C sa assembly
dahil kami ay pagpunta mula sa isang mas mataas na antas sa isang mas mababang antas
mga programa wika.
>> Kung bakit ang assembly mas mababang antas kaysa sa C?
Well, sa pagpupulong, napaka namin ay limitado sa kung ano ang maaari naming gawin.
May ay walang kung, habang ang, ang, o loop ng anumang uri.
Ngunit maaari mong maisagawa ang parehong mga bagay na mga kontrol
kaayusan ay nag-aalok gamit ang limitadong mga pagpapatakbo na
pagpupulong ginagawa magbigay.
Ngunit upang makita lamang kung paano ang mababang antas ng assembly ay talagang ay, sabihin pumunta
isang hakbang karagdagang sa aming compilation, assembling.
Trabaho ang assembler na baguhin ang code sa pagpupulong
sa bagay o machine code.
Tandaan na ang assembler hindi output assembly;
sa halip, ito ay tumatagal ng sa pagpupulong at output machine code.
Code ng machine ay ang aktwal na 1 at 0 na isang CPU maaari
maunawaan, kahit na mayroon pa rin kaming isang napakaliit na bit ng trabaho na pakaliwa
bago namin patakbuhin ang aming programa.
Sabihin magtipon ng aming pagpupulong code sa pamamagitan ng pagpasa
Kumalatong ang-c bandila.
Ngayon sabihin makita kung ano ang sa binuo file.
>> Well, na ay hindi makakatulong sa amin na talaga.
Tandaan na ang code ng machine ay ang mga bago at mga zero na
sa iyong computer ay maaaring maunawaan.
Na ay hindi nangangahulugan na ito ay madali para sa atin na maunawaan.
Kaya eksakto kung paano mababang antas ay pagpupulong?
Ito ay halos katulad sa object code.
Pagpunta mula sa pagpupulong sa code ng bagay ay higit pa ng isang
pagsasalin sa isang pagbabago, na ang dahilan kung bakit
hindi isa ay maaaring isaalang-alang ang assembler sa
gawin ang anumang aktwal na kino-compile.
Sa katunayan, ito ay medyo madali upang mano-manong isalin mula
pagpupulong sa machine code.
Naghahanap sa pagpupulong para sa isang pangunahing function na, na ang unang linya
mangyayari sa tumutugma sa hexadecimal 0x55.
Sa binary, na 1,010,101.
Ang pangalawang linya ay mangyayari sa tumutugma ang hexadecimal 0x895.
At sa susunod, 0x56.
Naibigay na may simpleng talahanayan, maaari mong i-translate ang
pagpupulong sa code na machine ay maaaring maunawaan masyadong.
>> Kaya may isang natitirang hakbang sa
compilation, na nagli-link.
Pag-uugnay Pinagsasama ng grupo ng mga file ng bagay sa isang malaking file
na maaari mong aktwal na execute.
Pag-uugnay ay napaka sistema nakasalalay.
Kaya ang pinakamadaling paraan upang makakuha ng kumalatong sa lamang link ng bagay
file nang magkasama upang tawagan ang kumalatong sa lahat ng mga file na
nais mong i-link nang magkasama.
Kung tinukoy mo ang file o, hindi ito kailangan sa reprocess,
makatipon, at magtipon ang lahat ng iyong source code.
Natin magtapon ng matematika function sa aming file, kaya kami ay may
isang bagay na i-link.
Ngayon sabihin makatipon ito pabalik down sa object code at
tawagan ang kumalatong dito.
Oops.
Dahil namin isinama ang isang matematika function na, kailangan namin na mag-link sa
ang matematika library na may-lm.
>> Kung gusto naming i-link nang magkasama ang grupo ng. O mga file na namin
sinulat ni sa aming sarili, nais naming lamang tukuyin ang lahat ng ito sa
linya ng command.
Ang paghihigpit na isa lamang sa mga file na ito ay dapat
aktwal na tukuyin ang isang pangunahing function, o tao ang
nagreresulta executable ay hindi alam kung saan magsisimula
pagpapatakbo ng iyong code.
Ano ang pagkakaiba sa pagitan ng pagtukoy ng isang file upang i-link sa
may-l at pagtukoy ng isang file nang direkta?
Walang.
Kumalatong na mangyayari malaman kung ano mismo ang file
isang bagay tulad ng-lm mangyayari sumangguni sa.
Kung alam mo na file sa iyong sarili, maaari mong tukuyin ang mga ito
tahasan.
Tandaan lamang na ang lahat-l flag ay may dumating sa dulo
ng pangangailangan ng iyong kliyente.
>> At na ang lahat ng may ito.
Kapag ikaw lang patakbuhin ang kumalatong sa ilang mga file, ito ay kung ano ito
aktwal na paggawa.
Ang pangalan ko ay Rob Bowden, at ito ay CS50.