C programming sa mga codeblock. Code Blocks IDE - setup at paggamit. Pagpapatakbo ng programa sa labas ng development environment sa kaso ng Windows

Magandang hapon, mahal na mga kaibigan. Sa artikulong ito sinisimulan ko ang isang serye ng mga aralin na nakatuon sa isa sa mga pinakasikat na programming language - C++. Ang mga aralin ay pangunahing nakatuon sa mga gumagamit na hindi pamilyar sa programming, kaya ang mga propesyonal, huwag maging mahigpit, bagaman sinusuportahan ko ang pagpuna, lalo na laban sa aking sarili. Sa aking mga aralin gagamitin ko ang Code::Blocks development environment, na libre upang i-download at gamitin. Magsimula tayo siyempre sa klasikong Hello, world =)

Umaasa ako na na-download at na-install mo na ang Code::Blocks, kung gayon, magsimula tayo. Paglulunsad ng kapaligiran sa pag-unlad

Una sa lahat, lumikha ng isang bagong walang laman na proyekto File->Bago->Proyekto at piliin ang Empty project

i-click ang Pumunta, pagkatapos ay Susunod

at sa lalabas na window, sa field ng Project title, i-type ang pamagat ng proyekto, sa Project filename ang pangalan ng proyekto at muli Susunod.

Sa susunod na window, alisin ang dir ng Objects mula sa configuration ng Create "Debug" at mga seksyon ng configuration na "Release", tulad ng ipinapakita sa screenshot sa itaas at i-click ang Finish button. Ang isang proyektong tinatawag na "Hello world" ay dapat lumitaw sa kanan.

Ang susunod na hakbang ay idagdag ang file na File->New->FIle... sa proyekto at piliin ang c/c++ source sa lalabas na window.

Pumunta, Susunod muli, piliin ang C++, Susunod at tingnan ang sumusunod na window

dito kailangan nating tukuyin ang pangalan ng file (pinangalanan ko ang pangunahing) at ang landas nito, mas mabuti ang folder na may proyekto. Lagyan ng check ang Debug at Release box at i-click ang Tapos na.

At nakatanggap kami ng isang walang laman na C++ file kung saan isusulat namin mismo ang program code.

Ngayon nagsisimula kaming isulat ang code ng programa mismo. Upang magpakita ng impormasyon sa screen, kailangan namin ang iostream I/O library.

#isama

gamit ang namespace std ;

Pagkatapos ay isusulat namin ang pangunahing pag-andar na isasagawa kapag nagsimula ang programa

int main()

dapat itong tawaging "pangunahing" at ipinapahiwatig natin ang uri nito int (pag-uusapan natin ito sa susunod na mga aralin). Sa pagitan ng curly braces at magiging program code. Magsusulat kami ng isang simpleng programa na magpapakita ng pagbati na "Kumusta, mundo!"

cout<<"Hello, mundo!" ;

Pagkatapos ng bawat utos dapat kang maglagay ng ";", ito ay nagsasabi sa compiler na ang utos ay tapos na at ang susunod ay maaaring maproseso. cout - Nagpi-print ng mga variable na halaga o mga string sa command line.

Buong listahan ng programa.

#isama

gamit ang namespace std;

int pangunahing ()

cout<< "Hello, world!" ;

bumalik 0 ;

Inilunsad namin ang proyekto at nakikita ang resulta.

Sa ibaba ay nag-attach ako ng isang aralin sa video sa artikulong ito.

Kung mayroon kang anumang mga katanungan, mangyaring sumulat ng mga komento sa Ang email address na ito ay protektado mula sa mga spambots. Dapat ay pinagana mo ang JavaScript upang matingnan ito. ,">Ang email address na ito ay pinoprotektahan mula sa mga spambots. Dapat ay pinagana mo ang JavaScript upang matingnan ito., Pipino ko ang mga aralin o tumulong na lang sa pag-aaral ng mga materyales.

< Назад

Ang Code::Blocks ay isang libreng cross-platform development environment. Ang Code::Blocks ay nakasulat sa C++ at ginagamit ang wxWidgets library. Ang pagkakaroon ng isang bukas na arkitektura, maaari itong i-scale sa pamamagitan ng mga plug-in. Sinusuportahan ang mga programming language C, C++, D (na may mga limitasyon).
Code::Blocks ay binuo para sa Windows, Linux at Mac OS X. Ang kapaligiran ay maaaring i-compile mula sa source code para sa halos anumang Unix-like system. [ http://ru.wikipedia.org/wiki/Code::Blocks ]

Upang paganahin ang wikang Ruso kailangan mong gawin ang mga sumusunod:

1. Dapat i-unpack ang archive sa subfolder ng program (kung saan ito naka-install), halimbawa C:\Program Files (x86)\CodeBlocks\share\CodeBlocks
2. Pagkatapos simulan ang programa, piliin ang Mga Setting -> Kapaligiran -> Tingnan, lagyan ng tsek ang kahon ng "Internationalization" at piliin ang "Russian" mula sa listahan.

3. I-restart ang CodeBlocks program at kumuha ng Russification.

Ang wikang Ruso ay matagumpay na naikonekta sa Code::Blocks na bersyon 13.12.

Ang archive ay naglalaman na ng locale\ru_RU folder structure (ilalagay sa \CodeBlocks\share\CodeBlocks)

Katayuan ng pagsasalin:
Mga Mensahe: 2173
Isinalin: 2173 (100.0%)
Hindi naisalin: 0 (0.0%)
Ibinahagi sa pagitan ng Ubuntu at upstream: 2173 (100.0%)
Iba ang pagsasalin sa pagitan ng Ubuntu at upstream: 0 (0.0%)
Isinalin lamang sa panig na ito: 0 (0.0%)

Ang integrated development environment (IDE) Code::Blocks (simula dito ay tinutukoy bilang CB) ay isang ganap na produkto para sa pagbuo ng mga application sa C/C++ na wika. Ang CB ay isang cross-platform framework na binuo gamit ang wxWidgets tool library. Mayroong mga bersyon ng kapaligiran para sa parehong Windows at iba pang mga operating system (OS) - Linux at Mac OS. Ang IDE na ito ay ganap na libre, open source at ganap na binuo gamit ang mga open source na teknolohiya. Ang isa sa pinakadakilang lakas ng CB ay ang suporta nito sa paglikha ng mga wxWidgets application—iyon ay, software na gumagamit ng OS API para mag-render ng graphical user interface (GUI). Sa madaling salita, pinapayagan ka ng CB na lumikha ng cross-platform software para sa bawat panlasa.

Maaaring gumana ang CB sa isang malaking bilang ng mga compiler. Kung may ilan sa mga ito na naka-install sa system, madali kang makakalipat sa pagitan ng mga ito, depende sa iyong mga pangangailangan. Dagdag pa, sa yugto ng pag-install, ang IDE mismo ay i-scan ang system para sa mga magagamit na compiler at mag-aalok na gamitin ang isa bilang pangunahing isa. Posibleng baguhin ang mga setting na ito sa ibang pagkakataon, sa buong mundo at indibidwal para sa mga proyekto. Para sa mga pandaigdigang setting ng kapaligiran, mayroong isang buong seksyong "Mga Setting" sa pangunahing menu ng CB. Upang gumawa ng anumang partikular na setting na partikular sa isang partikular na proyekto, kailangan mong buksan ang window ng mga katangian ng proyekto. Upang gawin ito, kailangan mong tawagan ang menu ng konteksto ng proyekto sa pamamagitan ng pag-right-click dito at pagpili sa "Properties". Ang mga proyekto mismo (kasalukuyang bukas sa IDE) ay ipinapakita bilang isang puno sa "Pamamahala" dock panel, sa tab na "Mga Proyekto". Ngayon, sa window ng mga property na bubukas, maaari mong i-configure ang isang malawak na iba't ibang mga parameter, mula sa pag-edit ng mga target ng build hanggang sa pagkonekta ng mga third-party na library. Ang button na "Mga opsyon sa build ng Project" sa tab na "Mga Setting ng Proyekto" ng parehong window ng mga property ay nagbibigay-daan sa iyong napaka-flexible na i-configure ang configuration ng build para sa isang partikular na proyekto: mga key ng compiler, piliin ang mismong compiler, ikonekta ang mga library para sa linker, atbp. Lahat ito ay maaaring gawin para sa mga indibidwal na mode: "Bitawan" "Pag-debug".

Ang CB GUI ay binuo sa paligid ng mga lumulutang at nababanat na dock panel na maaaring i-dock sa anumang bahagi ng pangunahing IDE window sa pamamagitan lamang ng pag-drag sa mga ito gamit ang mouse. Dahil dito, maaari mong napaka-flexible na i-configure ang iba't ibang mga layout ng interface para sa iba't ibang laki ng screen, na na-optimize ang ergonomya ng GUI. Kung mayroong ilang mga monitor, ito ay maginhawa upang paghiwalayin ang ilang mga panel mula sa pangunahing window at ilagay ang mga ito sa mga katabing monitor.

Ang pag-highlight, pagkumpleto ng code at mga tool sa pag-edit sa CB ay ginagawang madali at komportable ang proseso ng pagtatrabaho sa code. Ang isang malaking arsenal ng mga setting ay nagbibigay-daan sa iyo na napakahusay na i-customize ang kapaligiran "para sa iyong sarili." Napaka-kapaki-pakinabang na magkaroon ng suporta para sa pagtatrabaho sa mga variable ng kapaligiran. Salamat sa tampok na ito, ang CB ay maaaring maisama nang malapit sa system at ang mga kakayahan nito ay maaaring mapalawak, halimbawa, sa ganitong paraan maaari mong ikonekta ang wxWidgets library.

Sa pamamagitan ng paraan, upang bumuo ng mga aplikasyon ng GUI batay sa wxWidgets, ang CB ay may built-in na RAD tool para sa disenyo ng GUI - wxSmith. Ito ay isang medyo malakas na utility, kahit na hindi lubos na madaling matutunan.

Ang Code::Blocks ay isang libre, open source integrated development environment (IDE) na sumusuporta sa paggamit ng iba't ibang compiler. Bilang default, ginagamit ng Code::Blocks ang MinGW compiler, na kasama sa kit (maaari mong i-download ang pamamahagi nang walang built-in na compiler). Ang MinGW ay isang variant ng GNU C/C++ compiler para sa Windows. Ang MinGW ay maikli para sa "Minimalist GNU para sa Windows". Kasama sa MinGW suite ang mga open source na tool sa programming na hindi umaasa sa anumang mga bayad na third party na library. Ito ay ginagamit ng maraming development environment (Visual Studio ay gumagamit ng sarili nitong compiler). Kasama sa MinGW ang GNU Compiler Collection (GCC), kasama ang C, C++, ADA, at Fortran compiler. Code::Blocks ay may isang bukas na arkitektura, na nagbibigay-daan ito upang masukat gamit ang mga plug-in (maaari kang sumulat ng mga programa para sa Windows, Linux, at iba't ibang microprocessor tulad ng avr at stm32). Ang code debugger sa Code::Blocks ay sumusuporta sa mga breakpoint sa source code o sa data na pinoproseso ng program.

Code::Blocks ay available para sa Windows, Linux at Mac OS X. Ang website ng proyekto ay codeblocks.org.

Pag-install ng MinGW compiler

Pag-install ng Code::Blocks mismo ay hindi mahirap. Maipapayo lamang na i-install ito sa isang folder kung saan walang mga puwang o Cyrillic character sa landas. Tingnan natin ang pag-install ng MinGW compiler. Bilang panuntunan, ang pamamahagi ng Code::Blocks ay naglalaman ng lumang bersyon ng MinGW compiler, kaya ipinapayong i-download ang Code::Blocks nang walang MinGW compiler at i-install ang compiler nang hiwalay. Una, i-download ang installer mula sa website ng proyekto mingw.org. Pagkatapos ng paglunsad, lilitaw ang sumusunod na window.

I-click I-install at makuha namin ang sumusunod na window.

Dito sa field Direktoryo ng Pag-install ipahiwatig ang lokasyon ng mga file ng compiler. Ang default ay C:\MinGW, iwan na natin. I-click Magpatuloy at magsisimula ang pag-download at pag-install ng manager para sa pag-install ng MinGW.

I-click Magpatuloy at makuha namin ang sumusunod na window.

Para sa programming sa C++, pumili ng mga package na ii-install mingw32-base-bin (Isang Pangunahing Pag-install ng MinGW) At mingw32-gcc-g++-bin (Ang GNU C++ Compiler), at pagkatapos ay mag-click sa menu Pag-install -> Ilapat ang Mga Pagbabago. Lilitaw ang isang window na nagpapakita ng pag-download ng mga napiling package.

Kapag na-download ang mga pakete, mag-click sa pindutan Isara

Sa unang pagkakataon na patakbuhin mo ang Code::Blocks, awtomatiko nitong makikita ang naka-install na compiler. Kung lumitaw ang mga problema, kailangan mong pumunta sa menu Mga Setting -> Compiler... at sa tab Mga executable ng Toolchain suriin ang kawastuhan ng landas sa MinGW, pati na rin ang mga pangalan ng mga file ng compiler at linker. Ngayon ay maaari kang lumikha ng isang proyekto.

Paglikha ng isang Proyekto

Upang lumikha ng isang proyekto kailangan mong pumunta sa menu File -> Bago -> Proyekto...

Sa window na lilitaw, piliin ang kinakailangang uri ng proyekto. Dito makikita natin na ang Code::Blocks ay may malaking bilang ng mga template ng proyekto. Sa aming kaso ito ay Application ng console(aplikasyon ng console).

Sa susunod na window, piliin ang programming language na gagamitin. Piliin ang C++ at mag-click sa pindutan Susunod.

Sunod sa field Pamagat ng Proyekto ipasok ang pangalan ng proyekto. Sa aming kaso ito ay Pagsubok. Agad naming ipinapahiwatig ang lokasyon ng proyekto sa disk (field Folder para likhain ang proyekto). Sa folder na aming tinukoy, ang Codeblcoks ay awtomatikong gagawa ng isang folder na may dating tinukoy na pangalan ng proyekto. Pagkatapos tukuyin ang pangalan ng folder at pangalan ng file, mag-click sa pindutan Susunod.

Sa susunod na window, piliin ang compiler. Bilang default, napili ang GNU GCC Compiler, na siyang gagamitin namin.

I-click Tapusin at nakakakuha kami ng isang minimal na programa, ang tinatawag na Hello World!

Pindutin ang F9 upang i-compile at patakbuhin ang programa at makuha ang sumusunod na window.

Cyrillic support sa console

Ang karaniwang code ng proyekto na nabuo ng Code::Blocks environment ay hindi sumusuporta sa input at output ng mga Cyrillic na character sa console. Upang malutas ang problemang ito, kailangan mo munang gumawa ng maliliit na pagbabago sa code ng proyekto. Ang isang halimbawa ng source code ay ipinapakita sa ibaba.

Source code

#isama #isama gamit ang namespace std; int main() ( SetConsoleCP(1251); // pagtatakda ng win-cp code page 1251 sa input stream SetConsoleOutputCP(1251); // pagtatakda ng win-cp code page 1251 sa output stream cout

Susunod, kailangan mong patakbuhin ang programa, mag-left-click sa pamagat ng window (kung saan ipinapakita ang landas sa tumatakbong .exe file) at piliin ang item sa menu ng konteksto Mga Katangian. Pagkatapos ay sa tab Font i-install ang font Lucida Console at pumili ng maginhawang laki ng font. Pagkatapos nito, susuportahan ng mga mensahe sa mga console application ang mga Cyrillic na character.

Preliminary (unfinished) version

1 Pag-install at pagsasaayos ng kapaligiran sa pag-unlad

1.1 Pangkalahatang impormasyon

Una kailangan mong mag-install ng development environment, na magiging integrated software environment Code::Blocks. Ang mga pangunahing benepisyo ng Code::Blocks ay kinabibilangan ng:

libreng lisensya GPL v3.0, sa partikular, ang libreng pamamahagi at paggamit ay pinahihintulutan;
ang kapaligiran ay maaaring gumana sa mga operating system ng Windows, Linux, OS X na pamilya (iyon ay, ito ay cross-platform);
kakayahang magtrabaho sa iba't ibang mga compiler.

Ini-install ng file na ito ang Code::Blocks environment at ang MinGW environment, na nagbibigay ng GCC family of compiler. Ang kapaligiran ng MinGW ay libreng software din.

1.2.1.2 Proseso ng pag-install

Kailangan mong patakbuhin ang codeblocks-10.05mingw-setup.exe file. Lilitaw ang window ng installer.

Kailangan mong i-click ang "Next". May lalabas na window na may teksto ng libreng lisensya GPL v3.0.

Ang pag-click sa pindutang "Sumasang-ayon Ako" ay nangangahulugang sumasang-ayon ka sa mga tuntunin ng lisensya at pinapayagan kang magpatuloy sa pag-install ng program, kung saan lilitaw ang window ng pagpili ng bahagi. Sa window na ito kailangan mong piliin ang uri ng pag-install na "Buong: Lahat ng plugin, lahat ng tool, lahat lang".

Pagkatapos nito, kailangan mong i-click ang pindutang "Next". Lilitaw ang isang window na may pangalan ng direktoryo ng pag-install. Mas mainam na ang buong pangalan ng direktoryo ay hindi naglalaman ng mga puwang o titik maliban sa Latin. Samakatuwid, halimbawa, mas mainam na palitan ang pangalang C:\Program Files\CodeBlocks ng ibang bagay, halimbawa, C:\CodeBlocks o C:\Programs\CodeBlocks .

Pagkatapos nito, maaari mong i-click ang pindutang "I-install", na magsisimula sa proseso ng pag-install mismo.

Sa pagtatapos ng proseso, lalabas ang isang window na humihiling sa iyong ilunsad ang Code::Blocks. Mas mainam na i-click ang "Hindi" dito at pagkatapos ay suriin na ang Code::Blocks ay nagsisimula sa karaniwang paraan.

Pagkatapos nito, kailangan mo lamang i-click ang pindutang "Next" at pagkatapos ay "Tapos na" upang makumpleto ang proseso ng pag-install.

1.2.1.3 Unang paglulunsad

Ang isang shortcut upang ilunsad ang Code::Blocks ay dapat na lumabas sa Quick Launch toolbar. Gayundin, dapat lumitaw ang isang katulad na shortcut sa desktop.

Code::Maaaring ilunsad ang mga bloke gamit ang mga shortcut na ito, pati na rin ang paggamit ng karaniwang menu ng system program.

Sa una Kapag sinimulan mo ang Code::Blocks, dapat lumitaw ang isang window upang awtomatikong mahanap ang compiler.

Tandaan na ang unang linya ay dapat maglaman ng salitang "Natukoy". Nangangahulugan ito na ang compiler ay natagpuan. Dapat mong i-click ang "OK". Ang proseso ng unang pagtakbo ay magpapatuloy at ang kapaligiran ng pag-unlad ay ilulunsad. Ang isang window na may dulo ng araw ay lilitaw.

Kung hindi mo gustong lumitaw ang window na ito sa tuwing sisimulan mo ang Code::Blocks, pagkatapos ay alisan ng check ang checkbox na "Ipakita ang mga tip sa pagsisimula sa window na ito." I-click ang "Isara" upang isara ang window na ito.

Pagkatapos nito, maaaring lumitaw ang sumusunod na window.

Narito ito ay mas mahusay na i-click ang "OK" upang ang C/C++ kaugnay na mga file ay naka-link sa Code::Blocks.

Maaari mo ring isara ang window ng "Scripting console."

1.2.2 Pag-install para sa isang Linux operating system

Sa kaso ng Linux, maaari mong i-install ang Code::Blocks gamit ang package para sa iyong nais na pamamahagi mula sa mga nakalista sa pahinang ito.

Maaari mo ring subukang maghanap para sa Code::Blocks sa repository ng iyong pamamahagi ng Linux. Halimbawa, ang Code::Blocks package (10.05-1) ay available sa Ubuntu 11.04 repository.

1.3 Pag-setup

Upang magsimula, maaari mong ipamahagi ang mga toolbar nang mas compact sa tuktok ng window.

Pagkatapos nito, kailangan mong gumawa ng ilang mga pagbabago sa mga pangunahing setting.

Piliin ang menu na "Mga Setting => Compiler at debugger...". Lilitaw ang isang window ng mga setting.

Sa window na ito kailangan mo ilagay lagyan ng check ang kahon para sa "Gumawa ng mga simbolo ng pag-debug". Ang pagbabagong ito ay magbibigay-daan sa iyong magsagawa ng debug mode, na tatalakayin sa susunod na lecture.

Nang hindi isinasara ang window na ito, kailangan mong i-click ang tab na "Iba pang mga opsyon."

At sa patlang ng pag-edit kailangan mong idagdag ang sumusunod na linya.

Finput-charset=CP1251 -fexec-charset=CP866

Papayagan nito ang Cyrillic alphabet na maipakita nang tama sa console sa kaso ng Windows operating system. Kapag gumagamit ng Code::Blocks sa ibang mga operating system (halimbawa, Linux), hindi mo kailangang idagdag ang linyang ito.

Nang hindi isinasara ang window na ito, kailangan mong mag-click sa larawan sa kaliwa na may inskripsyon na "Mga setting ng Debugger", at pagkatapos ilagay lagyan ng tsek ang kahon para sa "Suriin ang expression sa ilalim ng cursor".

Pagkatapos nito, i-click ang "OK". Dapat magkabisa ang lahat ng pagbabagong ginawa.

2 Unang proyekto

2.1 Paglikha ng isang proyekto

Ngayon subukan nating lumikha ng isang programa sa C.

Upang gawin ito kailangan mong lumikha ng isang proyekto. Sa pangkalahatan, kailangan ang isang proyekto upang pagsamahin ang ilang mga file sa isang solong kabuuan. Ngunit sa kasong ito ito ay mas maginhawa upang lumikha ng isang proyekto para sa isang file. Bilang karagdagan, sa hinaharap ay magiging mas karaniwan na magtrabaho kasama ang proyekto.

Kaya, upang lumikha ng isang proyekto, piliin ang menu na "File", pagkatapos ay piliin ang "Bago" mula sa listahan na lilitaw, pagkatapos ay piliin ang "Proyekto" mula sa listahan na lilitaw (para sa maikli, ang pagkilos na ito ay maaaring italaga bilang "File => Bago =>Proyekto", at sa hinaharap ay gagamit ng mas maikling mga notasyon). Bilang resulta, dapat lumitaw ang isang dialog box.

Sa loob nito, piliin ang "Console application" at i-click ang "Go". Lumilitaw ang Bagong Project Wizard.

I-click ang "Next". Ang sumusunod na window ay lilitaw.

Dito kailangan mong piliin ang C (hindi C++) at i-click ang "Next". Ang sumusunod na window ay lilitaw.

Sa linya ng "Pamagat ng proyekto", ilagay ang pangalan ng proyekto, halimbawa, Project01. Tandaan na sa linya ng "Project filename" ay makokopya ang pangalang ito. Ang pangalan ng file na ito ay maaaring mabago (upang maging iba sa pangalan ng proyekto), ngunit para sa kaginhawahan mas mahusay na iwanan ang mga ito nang pareho. Pagkatapos, sa linya na "Folder upang lumikha ng proyekto sa" (folder upang lumikha ng isang proyekto sa loob nito), kailangan mong tukuyin ang folder kung saan matatagpuan ang folder na may proyekto. Maaari kang pumili ng isang folder mula sa mga magagamit gamit ang "..." na buton, o manu-manong i-type ang pangalan ng folder, halimbawa, C:\Projects.

Pagkatapos ay isang folder na may pangalan ng proyekto ay malilikha sa napiling folder, kung saan ang proyekto mismo ay matatagpuan. Maaari mong suriin ito sa pamamagitan ng pagbibigay pansin sa linyang "Resultang filename".

Kapag tumutukoy ng pangalan ng proyekto at pangalan ng folder para sa isang proyekto, huwag payagan ang mga pangalan ng folder na may mga puwang o titik na hindi Latin.(Ang linya ng "Resultang filename" ay hindi dapat maglaman ng mga puwang sa mga pangalan ng folder, at hindi rin dapat maglaman ng mga titik maliban sa Latin).

I-click ang Susunod. Ang sumusunod na window ay lilitaw.

Iwanan ang mga setting na ito na hindi nagbabago. I-click ang "Tapos na". Gagawin ang proyekto.

Sa itaas na kaliwang bahagi (sa window ng "Pamamahala") ang proyekto na may folder na "Mga Pinagmulan" ay ipapakita.

Kailangan mong mag-click sa "+" (o mag-double click sa isang folder) at magbubukas ang folder na ito.

Maglalaman ito ng isang main.c file. Kailangan mong i-double-click ito, pagkatapos ay magbubukas ang field ng pag-edit sa kanan, kung saan ipapakita ang mga nilalaman ng file na ito (sa itaas ay magkakaroon ng isang bookmark na may pangalan ng file).

Ipapakita ng window sa pag-edit ang teksto ng unang programa na may pag-highlight. Pakitandaan na ang iba't ibang bahagi ng teksto ay gumagamit ng iba't ibang kulay upang gawing mas madaling basahin ang teksto.

Ito ang unang simpleng programa na nagpapakita ng tekstong "Hello world!" ("Kumusta, mundo!"). Ayon sa kaugalian, ito ang programa na ginagamit bilang unang programa kapag nakikilala ang isang programming language. Sa kaso ng Code::Blocks, awtomatikong nagagawa ang program na ito kapag lumikha ka ng bagong proyekto.

Ang laki ng font sa window ng pag-edit ay maaaring mabago nang napakadaling. Upang gawin ito, paikutin ang gulong sa mouse habang pinipigilan ang Ctrl key.

Maaari mo ring gamitin ang menu na "Mga Setting => Editor" at, sa pamamagitan ng pag-click sa pindutang "Pumili" sa kanang bahagi sa itaas, baguhin hindi lamang ang laki ng font, kundi pati na rin ang font mismo. Tandaan lamang na kapag nagsusulat ng mga programa ay mas mahusay na gumamit ng mga font kung saan ang lahat ng mga titik ay may parehong lapad. Ang mga naturang font, halimbawa, ay kinabibilangan ng mga sumusunod na font: Courier New, Courier, Liberation Mono, Lucida Console, Monospace, atbp.

Kung lumalabas na ang window ng "Pamamahala" o ilang iba pang kinakailangang window ay nawawala sa screen, kailangan mong piliin ang View menu at sa menu na lilitaw, piliin ang item na naaayon sa nais na window.

Kung biglang nagsara ang proyekto, halimbawa, kapag lumabas at muling ipinasok ang Code::Blocks, maaari itong muling buksan. Upang gawin ito, piliin ang menu na "File => Recent projects", kung saan, pagkatapos, sa listahan na lilitaw, piliin ang nais na proyekto. O maaari mong gamitin ang menu na "File => Open", at pagkatapos ay piliin ang file na Project01.cbp.

2.2 Pagbuo at pagpapatakbo ng programa

Ang program na ito ay tatalakayin nang detalyado sa ibang pagkakataon, ngunit ngayon subukan nating patakbuhin ito.

Upang gawin ito, dapat itong gawin compilation teksto ng programa (Pag-compile), at paggamit layout(Pagli-link) ng isang executable na file na may extension na .exe ay dapat malikha, na ilulunsad. Ang buong proseso ng pag-compile at pag-link ay tinatawag pagpupulong(Gusali).

Dapat pansinin na ang proseso na tinutukoy dito ng salitang Compiling ay madalas ding tinatawag na proseso mga broadcast. Mayroong iba't ibang mga pagkakaiba-iba ng terminolohiya sa lugar na ito. Halimbawa, ang proseso ng pagpupulong sa itaas ay maaaring tawaging compilation, na binubuo naman ng mga hakbang sa pagsasalin at pag-uugnay. Ngunit ngayon ay hindi na namin susuriin ang mga isyu ng terminolohiya, at gagamitin lamang ang Ingles na bersyon ng mga termino bilang batayan, natural, sa pagsasalin sa Russian. Kaya pag-uusapan natin pagpupulong(Gusali), na binubuo ng mga yugto compilation(Pagsasama-sama) at layout(Pag-uugnay). Ang pagpipiliang ito sa kasong ito ay tila mas maginhawa, dahil ang kaukulang mga pangalan sa Ingles ay maaaring maobserbahan sa panahon ng proseso ng pagpupulong.

Ang pinagsama-samang development environment Code::Blocks ay nagpapahintulot sa iyo na i-automate ang pagpupulong at paglunsad (Run) ng programa. Upang buuin at patakbuhin ang programa, isagawa lamang ang utos na "Bumuo at patakbuhin" sa pamamagitan ng pagpindot sa pindutan o sa F9 key. Ang isa pang opsyon ay piliin ang menu na "Build => Build and run".

Sa ibabang window (mga mensahe tungkol sa proseso ng pagbuo) ang mga salitang "Pag-compile", "Pag-link", atbp. ay lilitaw, na sumasalamin sa pag-unlad ng pag-compile at pag-link ng programa.

Bilang isang resulta, dapat lumitaw ang isang console window, kung saan sa itaas ang pangungusap na tinukoy sa programa sa mga quote ay ipapakita, lalo na ang pangungusap na "Hello world!"

Kaya, ipinapakita ng programa ang ibinigay na string sa screen.

Sa ilalim ng linyang ito ay magkakaroon ng dalawang linya. Ang una ay nagpapakita ng return code ng programa at ang oras na ginugol sa pagpapatupad ng programa. Ang pangalawa ay nagpapakita ng mensahe na dapat mong pindutin ang anumang key upang magpatuloy. Ang dalawang linyang ito ay awtomatikong nabuo kung ang programa ay tatakbo mula sa Code::Blocks.

Ang font na ginamit sa console window ay maaaring baguhin kung kinakailangan. Halimbawa, sa kaso ng Windows operating system, maaari mong subukan ang mga sumusunod na hakbang.

I-click tama mag-click sa icon sa kaliwang sulok sa itaas ng console window. Dapat lumitaw ang isang pop-up menu kung saan kailangan mong piliin ang item na "Mga Default".

Lilitaw ang isang window ng mga setting.

Sa window na ito kailangan mong piliin ang nais na font (halimbawa, Lucida Console). Pagkatapos, para sa font na ito kailangan mong piliin ang nais na laki (halimbawa, 14). Pagkatapos nito, kailangan mong i-click ang "OK" upang i-save ang mga setting.

Pagkatapos, kailangan mong isara ang console window sa pamamagitan ng pagpindot sa anumang key.

Pagkatapos nito, kailangan mong i-restart ang programa sa pamamagitan ng pagpindot sa pindutan o sa F9 key (o pagpili sa menu na "Build => Build and run").

Dapat ay mayroon na ngayong bagong font ang console window.

2.3 Pagpapaliwanag ng programa

Ngayon, pagkatapos na matagumpay na ilunsad ang programa at suriin ang pagpapatakbo nito, maaari mong tingnan ang mga bahagi ng programa na awtomatikong nilikha kapag lumilikha ng proyekto. Tingnan natin ang teksto ng programang ito.

#isama #isama int main() { printf("Kumusta mundo!\n" ); bumalik 0; }

Ibinibigay ang salitang pangunahing kung saan magsisimula ang pagpapatupad ng anumang programa. Nangangahulugan ito ng pangunahing pag-andar kung saan nagsisimula ang lahat. Maaaring may mga tawag sa iba pang mga function sa loob ng function na ito, ngunit ang lahat ay nagsisimula sa pagpapatupad ng mga nilalaman ng main . Pagkatapos ng pangalan ng function na ito ay may mga panaklong na walang pagitan. Nangangahulugan ito na ang function na ito ay walang anumang mga argumento. Ang bawat function ay dapat may mga panaklong, kahit na wala itong mga argumento.

Ang mga nilalaman ng function, at sa kasong ito ang mga nilalaman ng buong programa, ay matatagpuan sa pagitan ng mga kulot na tirante. Ang mga ito ay tumutugma sa simula at pagtatapos bilang inilapat sa wikang Pascal.

Bago ang pangunahing pangalan ay ang salitang int, na tumutukoy sa uri ng halaga na ibinalik ng function. Sa kasong ito, ito ay isang uri ng integer (sa hinaharap, ang iba't ibang uri ng data ay tatalakayin nang hiwalay). Ang pangunahing function (iyon ay, mahalagang pangunahing programa) ay nagbabalik ng exit code ng programa. Karaniwang pinaniniwalaan na ang isang programa ay dapat magbalik ng halagang 0 sa panahon ng normal na pagpapatupad.

Gayundin sa pagitan ng mga kulot na braces ay isang tawag sa isang function na tinatawag na printf . Ang function na ito ay ginagamit sa kasong ito upang ipakita ang teksto sa screen. Ang mga panaklong para sa function na ito ay nagpapahiwatig ng mga argumento nito. Dito ang tanging argumento ay isang string na nakapaloob sa double quotes. Ito ang linyang ito na naka-print sa screen ng printf function. Ngunit ang kumbinasyon ng mga character \n ay hindi ipinapakita sa screen. Ang kumbinasyong ito ay nagpapahiwatig ng isang bagong linya na character, na hindi naka-print sa screen, ngunit nangangahulugan na ang isang bagong linya ay dapat gumanap sa lokasyong iyon.

Upang maunawaan ang kahulugan ng bagong linyang karakter, subukang alisin ang kumbinasyong \n mula sa linya, patakbuhin ang programa at tingnan ang resulta. Subukan din na gamitin ang kumbinasyon \n ilang beses sa isang hilera, patakbuhin ang program at tingnan ang resulta. Pagkatapos ay ibalik ang orihinal na bersyon ng programa.

Mayroong semicolon pagkatapos ng printf function na tawag. Pinapayagan nito ang mga indibidwal na operator na ihiwalay sa isa't isa. Sa partikular, pinaghihiwalay nito ang printf function na tawag mula sa return statement.

Nananatili itong maunawaan kung bakit kailangan ang linya sa programang ito. Nang hindi pumunta sa mga detalye, maaari nating sabihin na ang linya ay kailangan upang gawing posible na gamitin ang printf function, dahil ginagawang posible ng linyang ito na makakuha ng impormasyon tungkol sa function na ito. Kasama sa linyang ito ang stdio.h file, na ang pangalan ay nakasaad sa panaklong bilang mga character< и >. Ang #include command ay nagpapahiwatig ng pagsasama ng file na ito. Ang koneksyon na ito ay nagpapahintulot sa iyo na gamitin ang mga function na ipinahayag sa file na ito, lalo na ang printf function.

Ang linya sa program na ito ay karaniwang hindi kailangan, ngunit ang prinsipyo ng pagpapatakbo nito ay magkatulad, isa lamang na file (stdlib.h) ang kasama dito.

2.4 Pagbabago ng programa

Ngayon ay maaari mong i-edit ang main.c file.

Maaari kang mag-type ng anumang teksto sa field ng pag-edit, tulad ng sa isang regular na editor. Sa hinaharap, ang mga halimbawa ng programa at mga fragment ng programa ay maaaring i-paste lamang sa patlang ng pag-edit gamit ang regular na pagkopya ng mga bloke ng teksto. Isaalang-alang natin ang isang katulad na aksyon sa sumusunod na halimbawa.

Ang mga nilalaman ng main.c file ay awtomatikong nabuo. Ngunit ang naturang programa ay maaaring maisulat nang kaunti pa, at binago din ng kaunti sa pamamagitan ng pagdaragdag ng mga tandang padamdam. #isama int main()( printf("Kamusta mundo!!!\n" );

Ngayon ang program na ito ay dapat ilipat sa window ng pag-edit gamit ang regular na pagkopya. Upang gawin ito, kailangan mong piliin ang teksto ng programa at kopyahin ang napiling teksto sa clipboard, halimbawa, sa pamamagitan ng pag-click sa kanang pindutan ng mouse at pagpili sa "Kopyahin" mula sa menu). Pagkatapos, kailangan mong lumipat sa Code::Blocks editing window, i-highlight ang teksto doon, at i-paste ang teksto mula sa clipboard, halimbawa, sa pamamagitan ng pagpili sa menu na "I-edit=>I-paste" o sa pamamagitan ng pagpili, pagkatapos ng pag-right-click, ang menu na "I-edit=>I-paste." Ang bersyon na ito ng program ay dapat na lumabas sa window ng pag-edit.

I-save ang bagong bersyon ng programa. Upang gawin ito, pindutin lamang ang Ctrl-S (o piliin ang menu na "File => I-save ang file"). Sanayin ang iyong sarili na i-save ang file pagkatapos ng bawat, kahit maliit, pagbabago sa teksto ng programa. Kung hindi, kapag nag-freeze ito, maaaring mawala ang ilang trabaho.

Subukang patakbuhin ang bagong bersyon ng mga program na ito.

Mga gawain sa pagpipigil sa sarili

Baguhin ang text na "Hello world!!!" sa ibang wika, habang gumagamit ng Russian. Patakbuhin ang programa upang suriin ang mga pagbabago.
Baguhin ang halaga 0 pagkatapos bumalik sa ilang iba pang numeric na halaga, halimbawa, 5. Patakbuhin ang program at suriin na pagkatapos ng "Ibalik ang Proseso" isang bagong numerong halaga ang ipinapakita sa console window.
Siguraduhin na kapag sinimulan mo ang programa, bago i-print ang linyang "Hello world!!!" nagkaroon ng shift pababa ng isang linya sa screen. Upang gawin ito, ilagay ang \n sa pinakadulo simula ng linyang ginamit bilang argumento sa printf function. Patakbuhin ang programa upang matiyak na ang gawain ay nakumpleto nang tama.
Siguraduhin na kapag sinimulan mo ang programa, bago i-print ang linyang "Hello World!"
nagkaroon ng shift pababa ng ilang linya sa screen. Upang gawin ito, ilagay ang kumbinasyon \n ilang beses sa isang hilera sa pinakadulo simula ng linya na ginamit bilang argumento sa printf function (ibig sabihin ang string na matatagpuan sa loob ng mga panaklong sa mga panipi). Patakbuhin ang programa upang matiyak na ang gawain ay nakumpleto nang tama.
I-print ang linyang "Hello world!!!" tatlong beses sa tatlong magkakasunod na linya sa screen (isang kopya bawat linya), paglalagay ng \n kumbinasyon sa mga tamang lugar.
Magpakita ng tatlong magkakaibang salita nang sabay-sabay sa tatlong lugar sa screen: sa itaas na sulok at sa gitna ng screen. Gumamit ng dalawang printf na tawag sa isang hilera na may magkakaibang mga string bilang mga argumento, gamit ang \n at mga puwang sa isang espesyal na paraan sa bawat kaso.

2.5 Pagpapatakbo ng program sa labas ng development environment sa kaso ng Windows

Ang folder ng proyekto, ang landas kung saan tinukoy kapag lumilikha ng proyekto (tingnan), ay dapat maglaman ng bin/Debug folder. At sa folder na ito dapat mayroong isang maipapatupad na file na Project01.exe, na nakuha bilang resulta ng pagbuo ng programa.

Ang executable file (application) na ito ay maaaring ilunsad gamit ang karaniwang paraan (halimbawa, gamit ang Explorer), iyon ay sa labas Code::Bina-block ang development environment. Gayundin, halimbawa, maaari kang gumawa ng isang shortcut sa file na ito at ilagay ito sa iyong desktop upang mailunsad mo ito mula doon.

Ngunit kapag inilunsad sa ganitong paraan, ang console window na may linya ng output ay lilitaw at agad na nawala, dahil ang programa ay nagtatapos kaagad, nang hindi naghihintay para sa utos ng gumagamit. Bakit ito nangyayari? Ang bagay ay na kapag inilunsad mula sa Code::Blocks, isang paghihintay para sa pagpindot sa anumang key ay awtomatikong idinagdag, ngunit ang application mismo ay hindi nagbibigay nito.

Upang ipatupad ang paghihintay para sa isang pinindot na key (sa kaso ng Windows), kailangan mong baguhin ang programa sa pamamagitan ng pagdaragdag ng ilang linya. Pagkatapos ay kukuha ito ng sumusunod na anyo.

Subukang patakbuhin ang program na ito mula sa Code::Blocks. Upang gawin ito, ilagay ang tinukoy na programa sa patlang ng pag-edit sa halip na magagamit, at patakbuhin ang programa sa pamamagitan ng pagpindot sa pindutan o sa F9 key (o pagpili sa menu na "Build => Build and run").

Pansinin na pagkatapos i-print ang "Hello world!!!" Ngayon ay wala nang ibang naka-print dahil naghihintay ito ng isang key na pinindot. Ngunit pagkatapos ng pagpindot sa isang key, ang pamilyar na dalawang linya ay output ("Ibinalik ang proseso ... " at "Pindutin ang anumang key upang magpatuloy."). Pagkatapos ng mga linyang ito, muli kaming naghihintay para sa isang key press (na ibinibigay ng Code::Blocks environment).

Ngayon kung pinapatakbo mo ang program na ito sa labas Code::Blocks, sa pamamagitan ng pagpapatakbo ng file na Project01.exe, ang tinukoy na teksto ay ipapakita sa window at ang programa ay maghihintay para sa isang key na pinindot upang makumpleto.

Upang baguhin ang program sa ganitong paraan, dalawang linya ang kinakailangan: isa na naglalaman ng conio.h at isa na naglalaman ng getch . conio.h ay kinakailangan upang gawing posible na tawagan ang getch function. Ito ay katulad ng pagkonekta sa stdio.h upang matawagan ang printf function. Ang getch function ay naghihintay para sa isang keypress.

Ang mga naturang pagbabago ay hindi ipahiwatig sa hinaharap, ngunit kung kinakailangan, maaari mong palaging gawin ang mga ito upang matiyak na hihintayin mong pindutin ang isang key bago wakasan ang programa.

2.6 Mga mensahe tungkol sa mga babala at error sa programa

Kapag gumagawa ng program (kapag sinusubukang patakbuhin ito pagkatapos ng mga pagbabago), maaaring lumitaw ang mga babala at error. Tingnan natin kung paano ito nangyayari sa isang halimbawa. Subukang patakbuhin ang sumusunod na programa.

Ang program na ito ay hindi naglalaman ng isang pagbabalik, ngunit ito ay tatakbo. Subukan mong patakbuhin ito.

Gayunpaman, sa panahon ng compilation, isang babala ay ibibigay dahil sa katotohanan na walang return statement. Kapag sinimulan mo ang programa, mawawala ang babalang ito dahil hindi ito nakakaapekto sa pagsisimula ng programa. Ngunit mababasa ito kung bubuo ka lamang ng file (nang hindi pinapatakbo ang application). Upang gawin ito, kailangan mong lumikha ng command na "Build" sa pamamagitan ng pagpindot sa Ctrl-F9, o sa pamamagitan ng pag-click sa button, o sa pamamagitan ng pagpili sa menu na "Build => Build".

Ngunit kung ang programa ay hindi nagbago mula noong nakaraang build o paglunsad, ang bagong build ay hindi isasagawa. At sa window sa ibaba ay ipapakita ang isang mensahe na nagsasaad na ang pagpupulong ay ang pinakabago, at wala nang iba pang kailangang gawin para sa utos na ito ("Ang target ay napapanahon. Walang dapat gawin.").

Sa kasong ito, kailangan mong muling buuin ito. Upang gawin ito, kailangan mong lumikha ng command na "Muling Buuin" sa pamamagitan ng pagpindot sa Ctrl-F11, o sa pamamagitan ng pag-click sa pindutan, o sa pamamagitan ng pagpili sa menu na "Bumuo => Muling Buuin". Matapos mabuo ang command na ito, lalabas ang isang window upang kumpirmahin ito. Upang kumpirmahin ang utos na ito, i-click ang "Oo" sa tinukoy na window.

Pagkatapos ay sa ibabang window maaari kang makakita ng linya ng babala (asul), pati na rin ang isang mensahe tungkol sa pagkakaroon ng isang babala (1 babala).

Sa pangkalahatan, pinahihintulutan ng isang babala ang programa na maisakatuparan, ngunit inaalerto ang programmer sa mga posibleng pagkakamali o kamalian.

Sa hinaharap, ang return statement para sa pangunahing function ay hindi maaaring gamitin para sa ikli, gaya ng ginagawa sa . Ngunit dapat nating isaalang-alang na nagiging sanhi ito ng paglitaw ng babala.

Ngayon subukang patakbuhin ang sumusunod na programa.

Tandaan na ang programa ay hindi magsisimula. Sa halip, lalabas ang mga linya sa pulang font sa ibabang window na nagpapahiwatig ng mga error.

Ang linya sa programa kung saan mayroong isang error ay naka-highlight sa isang pulang parisukat.

Dapat itong isaalang-alang na ang isang wastong error ay maaaring humantong sa ilang mga mensahe ng error nang sabay-sabay. Sa halimbawang ito, 5 error ang nabuo, kaya 5 linya ang ipinapakita sa pulang font.

Ang paghahambing ng programa, hindi mahirap maunawaan na ang error ay nangyayari dahil sa ang katunayan na ang mga panipi ay hindi tinukoy. Alinsunod dito, ipinapakita ang error na "Hello" na hindi ipinahayag. Ang salitang "hindi idineklara" ay nangangahulugang "hindi idineklara", ibig sabihin, sinusubukan ng compiler na maunawaan kung ano ang ibig sabihin ng Hello at kung ano ang dapat nitong gawin. Hindi nito mahahanap ang salitang ito sa mga kilalang salita, kaya nagkakamali ito. Kung ang salitang ito ay nasa dobleng panipi, kung gayon ito ay itinuturing bilang isang string, sa loob kung saan ang anumang bagay ay maaaring maging. Maaaring ipakita ang string sa screen. Samakatuwid, pagkatapos iwasto ang programa (pagdaragdag ng mga quote kung kinakailangan), ang lahat ay dapat na maayos.

Iwasto ang program at suriin kung gumagana ito nang tama.

Mga gawain sa pagpipigil sa sarili

Subukang tanggalin ang huling curly brace at patakbuhin ang program. Pansinin na ang error ay nabanggit sa linyang naglalaman ng printf , na siyang naunang linya. Ibalik ang tamang programa.
Subukang tanggalin ang dalawang panaklong pagkatapos ng main . Pansinin na ang error ay nabanggit sa linyang naglalaman ng kulot na brace, na siyang susunod na linya.
Ibalik ang tamang programa.

Subukang tanggalin ang unang panaklong pagkatapos ng main . Pansinin na ang error ay nabanggit sa linyang naglalaman ng main , na parehong linya. Ibalik ang tamang programa.

Isinasaalang-alang ang mga gawain sa pagpipigil sa sarili, madaling makita na ang isang error ay maaaring nasa tabi ng linya na minarkahan ng pulang parisukat. Samakatuwid, kapag may naganap na error, dapat ding suriin ang mga katabing linya.

3 Pangunahing impormasyon

3.1 Mga integer

Upang gumana sa data, lalo na sa mga integer, kakailanganin mo ng mga variable na ginagamit upang mag-imbak ng mga naturang numero. Una, kailangan mong magdeklara ng isang variable upang magsimulang magtrabaho kasama nito.

Ang deklarasyon ng variable ay ginagawa tulad ng sumusunod.

variable_type variable_name;

Halimbawa, ang integer variable a ay idineklara bilang mga sumusunod.

int a ;

Sa kasong ito, ang variable a ay nasa uri int , na nagsasaad ng isang uri ng integer.

Ang isang variable na deklarasyon ay tumutukoy sa isang bloke ng memorya upang mag-imbak ng data ng tinukoy na uri. Naturally, maaari kang pumili ng ilang katulad na mga bloke. Upang makilala ang mga ito mula sa bawat isa, ang mga bloke na ito ay pinangalanan. Halimbawa, ang deklarasyon ng int a ay naglalaan ng isang bloke na may pangalang a, ang deklarasyon ng int b ay naglalaan ng isang bloke na may pangalang b, atbp. Sa kasong ito, maaari mong sabay na magdeklara ng ilang mga variable, iyon ay, pumili ng ilang mga bloke ng parehong uri na may iba't ibang pangalan. Upang gawin ito, ang mga pangalan ng mga bloke na ito ay nakalista na pinaghihiwalay ng mga kuwit pagkatapos ng pagtatalaga ng uri.

Tinutukoy ng deklarasyon na ito ang tatlong magkakaibang bloke ng parehong uri na may iba't ibang pangalan.

Upang magsulat ng isang halaga sa isang napiling bloke ng data, kailangan mong italaga ang halagang ito sa kaukulang variable, halimbawa, ang expression

nagtatalaga ng variable a ang value 10. Maaari mo ring italaga ang isang variable ng value ng isa pang variable, halimbawa, ang expression

nagtatalaga ng variable a ang halaga ng variable b. Maaari kang magtalaga ng parehong halaga sa ilang mga variable nang sabay-sabay. Upang gawin ito, halimbawa, maaari mong gamitin ang sumusunod na expression.

X = y = z = 100;

Tandaan na ang isang variable ay maaari lamang magtalaga ng isang halaga kung ang variable ay idineklara na (partikular, ang uri nito ay tinukoy).

Ang halaga ng isang variable ay maaaring i-print sa screen gamit ang printf function. Bilang halimbawa, suriin ang pagpapatupad ng sumusunod na programa.

Mangyaring tandaan na sa programa mayroong isang komento na "nagdedeklara ng variable a". Ang komento ay isang fragment na kailangan upang ilarawan ang isang partikular na bahagi ng programa. Ang komento ay hindi nakakaapekto sa panghuling programa; ito ay isang karagdagan lamang sa teksto, na pagkatapos ay hindi ginagamit kapag isinasagawa ang programa. Ang isang komento ay dapat magsimula sa kumbinasyon ng character /* at magtatapos sa kumbinasyon ng character */. Sa kasong ito, ang komento ay maaaring matatagpuan sa ilang linya; ang komento.

Sa pinakadulo simula ng pangunahing function, variable a. Pagkatapos ang variable na ito ay may value na 10. Sa susunod na linya, gamitin ang printf function para i-print ang value ng variable sa screen. Upang gawin ito, magdagdag ng karagdagang argumento sa printf function, na pinaghihiwalay ng kuwit pagkatapos ng sinipi na string. Ang karagdagang argument na ito ay ang variable a mismo, ang halaga nito ay dapat i-print sa screen. Upang sabihin sa printf function kung saan ipi-print ang halaga ng isang variable, isang kumbinasyon ng dalawang character, lalo na %d , ay idinagdag sa output string. Ang mga character na ito mismo ay hindi ipapakita sa screen, ngunit sa halip na ang mga ito ay ipapakita ang halaga ng variable na pinaghihiwalay ng kuwit pagkatapos ng linya. Patakbuhin ang programa at suriin ang operasyon nito.

Kapag nagta-type ng isang programa, tandaan na ang maliliit at malalaking titik ay magkaibang mga titik mula sa punto ng view ng compiler. Samakatuwid, halimbawa, ang pag-type ng Main sa halip na pangunahing ay magreresulta sa isang error.

Mga gawain sa pagpipigil sa sarili

Baguhin ang halaga ng variable a sa ibang halaga at
Subukang magdagdag ng mga komento sa iba't ibang bahagi ng programa. Tiyaking hindi ito makakaapekto sa pagpapatupad ng programa. Suriin ang paggamit ng mga komento na sumasaklaw sa maraming linya.
Suriin kung ano ang mangyayari kapag binago mo ang kaso ng isang partikular na titik, iyon ay, halimbawa, kapag pinalitan ang isang maliit na titik sa isang malaking titik at vice versa.

Upang ideklara ang variable a at simulan ito, dalawang magkasunod na linya ( at ) ang nakuha. Ngunit maaari mong pagsamahin ang variable na deklarasyon at pagsisimula. Sa halip na dalawang linya na ipinahiwatig, maaari kang sumulat lamang ng isang linya ng sumusunod na uri.

int a = 10;

Suriin kung gumagana nang tama ang programa pagkatapos ng naturang pagbabago.

Ang printf function ay maaari ding i-print ang mga halaga ng maramihang mga variable nang sabay-sabay. Upang subukan ang posibilidad na ito, magdeklara ng variable b at magtalaga ng ilang value sa variable na iyon bago tawagan ang printf function. Mahalagang tandaan na ang isang variable na deklarasyon ay maaaring mangyari kahit saan sa loob ng mga kulot na brace ng isang function, partikular na ang pangunahing function. Pagkatapos nito, i-convert ang printf function string bilang mga sumusunod.

Printf("a = %d, b = %d \n" , a, b);

Suriin kung gumagana nang tama ang programa.

Kaya, upang ipakita ang mga halaga ng ilang mga variable nang sabay-sabay, kailangan mong ayusin ang mga na-format na output character %d sa linya ng output nang naaayon, at ilista din ang mga variable na pinaghihiwalay ng mga kuwit kaagad pagkatapos ng linya ng output sa pagkakasunud-sunod ng output. Pagkatapos, sa halip na bawat kumbinasyong %d, ang halaga ng susunod na variable mula sa listahan ng mga variable, na pinaghihiwalay ng mga kuwit, ay papalitan.

Sa kasong ito, maaari mo ring tukuyin ang isang expression bilang argumento sa printf function. Halimbawa, upang parisukat at kubo ang isang variable, maaari mong gamitin ang * sign upang ipahiwatig ang multiplikasyon. Idagdag ang sumusunod na snippet pagkatapos ng umiiral nang printf function na tawag.

Printf( "a = %d\n(a squared) = %d\n(a cubed) = %d\n", a, a * a, a * a * a);

Suriin kung gumagana nang tama ang programa.

Tandaan na kung ang isang function na tawag ay isang napakahabang linya, kung gayon ito ay maginhawa upang hatiin ito sa ilang mga linya, na pinaghihiwalay ng mga kuwit. Halimbawa, tulad ng ginawa sa tekstong ito, ngunit ang parehong fragment ay maaaring isulat sa isang linya sa kahilingan ng programmer.

3.2 Arithmetic expression

Ngayon, upang i-square o i-cube ang isang integer, sapat na upang itama ang paunang pagtatalaga sa variable a at muling patakbuhin ang programa. Eksperimento dito. Bilang karagdagan sa pag-squaring at cubed, maaari kang gumamit ng iba't ibang mga expression batay sa mga operasyon ng aritmetika: +, -, *, /.

Mga gawain sa pagpipigil sa sarili

Ipatupad ang pagkalkula ng ilang formula na gumagamit ng lahat ng 4 na operasyong arithmetic. Itakda ang halaga ng variable sa programa. Suriin na ang formula na ito ay kinakalkula nang tama.
Kalkulahin ang isang formula mula sa dalawang variable. Itakda ang mga halaga ng mga variable sa programa.

Ang wikang C ay mayroon ding kakayahang sumulat ng ilang madalas na ginagamit na mga konstruksyon nang mas maigsi. Kaya, upang madagdagan ang isang variable sa pamamagitan ng isang ibinigay na halaga, ang += na operasyon ay ginagamit. Yun pala ang expression

A += 10;

ay katumbas ng expression

A = a + 10;

sa kasong ito, sa katulad na paraan, sa halip na ang + sign ay maaari ding magkaroon ng mga palatandaan -, *, /, pati na rin ang ilang iba pang mga palatandaan ng operasyon.

Ang sumusunod na fragment ng programa ay naglalarawan ng mga halimbawa ng paggamit ng mga tampok na ito, na may mga komento na nagpapahiwatig ng mga halaga na kinukuha ng variable bilang resulta ng pagkalkula ng aritmetika na expression.

int i = 10; i = (i * 2 + 1) / 3 - 5; /* i = 2 */ i += 5; /* i = 7 */ int j = 3; ako *= j; /* i = 21 */ i /= 7; /* i = 3 */

Pagpipigil sa sarili na gawain

Ipatupad ang pagkalkula ng ilang formula na gumagamit ng mga tinukoy na kakayahan (isang mas maigsi na paraan ng pagsulat ng ilang mga expression na aritmetika).

Bukod dito, ang ekspresyon

nagsasaad ng pagtaas sa variable a ng 1, na katumbas ng expression

A = a + 1;

Gayundin, ang ekspresyon

dito ay nangangahulugan ng pagbaba ng 1.

Mahalagang tandaan na mayroon ding mga expression ng form

A++; a--;

Ipinapahiwatig din ng mga ito ang pagtaas ng 1 at pagbaba ng 1.

Gayunpaman, mayroong pagkakaiba sa pagitan ng prefix (++a) at postfix form (a++) sa mas kumplikadong mga expression.

Kung sakali unlapi ang form (++a) ay unang tumataas (bumababa) ng 1, at pagkatapos ay sinusuri ang natitirang bahagi ng expression.

Kung sakali postfix form (a++), ang expression ay unang sinusuri at pagkatapos ay dinadagdagan (decremented) ng 1.

Ang sumusunod na halimbawa ay naglalarawan ng pagkakaibang ito.

Tingnan natin ang parehong fragment kung saan ginagamit ang ++y (prefix form).

int x = 10;

int y = 2;

x = x * (++y);

printf("x = %d y = %d\n" , x, y);

X = 30 y = 3

Dito, unang y dahil sa ++y ay makakatanggap ng halaga 3, at pagkatapos nito ay magaganap ang multiplikasyon ng 10 sa 3.

Tingnan natin ang parehong fragment kung saan ginagamit ang y++ (postfix form).

int x = 10;

Dapat tandaan na sa mga fragment na ito ay hindi na kailangang maglagay ng mga panaklong sa paligid ng ++y at y++ .

Mga gawain sa pagpipigil sa sarili

Suriin ang pagpapatupad ng tinukoy na mga fragment ng programa. Dapat tandaan na ang mga ito ay mga fragment lamang ng mga programa. Dapat silang idagdag sa loob ng mga kulot na tirante ng pangunahing pag-andar.
Subukang alisin ang mga panaklong sa paligid ng ++y at y++ sa mga fragment na ito.

Siguraduhing hindi magbabago ang resulta.

3.3 Mga uri ng integer

Sa ngayon ay isinasaalang-alang lamang namin ang uri ng int para sa mga integer. Ano ang mga maximum na halaga na maaaring itakda para sa isang int variable? Garantisado maaari kang magtakda ng mga halaga sa saklaw mula -32768 hanggang 32767, dahil ang isang int variable ay inilalaan walang kulang

16 bit.

Ngunit sa mga araw na ito ay madalas kang makakita ng mga pagpapatupad ng compiler na naglalaan ng 32 bits sa isang int variable, ibig sabihin, ang variable ay maaaring kumuha ng mga value sa range -2147483648 hanggang 2147483647.

Gayunpaman, maaari kang maging ganap na sigurado na ang saklaw ng mga wastong halaga para sa variable na x ay hindi bababa sa hanay mula -32768 hanggang 32767.

Kapag ginagamit ang iminungkahing bersyon ng Code::Blocks at ang gcc compiler na kasama nito (o isang dating naka-install na katulad na compiler), malamang na makikita mo ang iyong sarili sa isang sitwasyon kung saan ang isang int variable ay maaaring kumuha ng mga value mula sa range -2147483648 sa 2147483647.

int main () ( int x1 = -2147483648; int x2 = 2147483647; printf("x1 = %d x2 = %d\n" , x1, x2); )

X1 = -2147483648 x2 = 2147483647

Kung gayon, ipinapakita nito na ang isang variable ng uri ng int ay maaaring tumagal ng mga ganoong halaga.

int main () ( int x1 = -2147483648; int x2 = 2147483647; ++x2; printf("x1 = %d x2 = %d\n" , x1, x2); )

Kapag pinatakbo mo ang program na ito, malamang na mai-print ang sumusunod na linya.

X1 = -2147483648 x2 = -2147483648 Pansinin na ang halaga ng x2 ay naging negatibong halaga ng limitasyon. Masasabi nating kapag sinusubukang magdagdag ng 1 sa maximum na positibong value (value 2147483647), lumabas ang value sa range at ang value na "round" ay napunta sa maximum na negatibong value (value -2147483648). Ang tinatawag na nangyari.

umaapaw

Kung dinadagdagan mo ang x2 hindi ng 1, ngunit ng 3, ang variable na x2 ay kukuha ng halaga -2147483646 (na 2 ay naiiba sa maximum na negatibong halaga). Suriin ito.

Kaya, mauunawaan mo ang prinsipyo ng pag-uugali ng mga variable ng integer sa kaso ng overflow.

Mga gawain sa pagpipigil sa sarili

Katulad nito, suriin ang overflow ng variable x1 patungo sa matinding negatibong halaga, iyon ay, kapag binabawasan ang isang tiyak na numero mula sa variable na ito.
Nagaganap din ang overflow kapag sinubukan mo lang magtalaga ng value sa isang variable na nasa labas ng pinapayagang range. Suriin ito.

Bilang karagdagan sa uri ng int, mayroong iba pang mga uri ng integer para sa pagdedeklara ng mga variable.

Halimbawa, ang mahabang uri ay nagbibigay-daan sa iyo na garantiya -2147483648 hanggang 2147483647 (ang uri ng int ay hindi nagbibigay ng garantiyang ito para sa lahat ng mga compiler).

Gayundin sa mga modernong C language compiler, ang mahabang mahabang uri (nakasulat sa dalawang salita) ay lumitaw, na naglalaan ng 64 bits para sa isang variable. At ito ay tumutugma sa hanay ng mga numero mula -9223372036854775808 hanggang 9223372036854775807.

Suriin natin ang ganitong uri gamit ang sumusunod na programa bilang isang halimbawa.

X1 = -9223372036854775808 x2 = 9223372036854775807

Tandaan na sa kasong ito, kapag tumatawag sa printf function, ang kumbinasyon ng character ay %lld , hindi %d . Ito ay kinakailangan upang ang printf function ay maipakita nang tama ang malalaking numero na naaayon sa mahabang mahabang uri.

Mga gawain sa pagpipigil sa sarili

Katulad nito, suriin para sa pag-apaw ng mga variable ng uri ng mahabang haba sa halimbawang ito (tulad ng kaso sa mga variable ng uri int).
Subukang gumamit ng %d sa halip na %lld sa printf function sa halimbawang ito.

Bilang karagdagan, maaari kang lumikha ng mga bagong uri ng integer sa pamamagitan ng pagdaragdag ng hindi nalagdaan na keyword bago ang pangalan nito, na inililipat ang hanay ng mga posibleng halaga sa positibong rehiyon, iyon ay, ginagawang hindi pinirmahan ang uri. Ipinapaliwanag ito ng sumusunod na halimbawang programa.

Kapag ang program na ito ay naisakatuparan, ang isang string ay dapat na i-print.

X1 = 0 x2 = 4294967295

Tandaan na sa kasong ito, kapag tumatawag sa printf function, ang kumbinasyon ng character ay %u, hindi %d. Ito ay kinakailangan para sa printf function na maipakita nang tama ang mga numero na naaayon sa isang hindi nakapirmang uri.

Mga gawain sa pagpipigil sa sarili

Katulad nito, suriin para sa pag-apaw ng mga variable ng uri ng unsigned int sa halimbawang ito (tulad ng kaso sa mga variable ng uri ng int).
Subukang gumamit ng %d sa halip na %u sa printf function sa halimbawang ito.
Batay sa halimbawang ito, subukang ipakita ang maximum na halaga na maaaring isulat sa isang variable ng uri na hindi pinirmahan ang haba (ibig sabihin, ang numerong 18446744073709551615). Para sa tamang display, ginagamit ng printf function ang kumbinasyon ng character na %llu (sa halip na %u).

3.4 Mga tunay na numero

Upang tukuyin ang mga tunay na numero, maaari mong gamitin ang float type o ang double type. Sa kasong ito, ang isang variable ng uri ng float ay sumasakop sa 4 na byte, at isang variable ng uri ng double ay sumasakop sa 8 byte. Samakatuwid, sa pangkalahatan, ang dobleng uri ay nagbibigay ng mas malawak na hanay ng mga posibleng numero at higit pang mga decimal na lugar pagkatapos ng decimal point, ngunit mayroon itong disadvantage na dalawang beses sa memory consumption ng float type.

Mayroon ding mahabang double type, at ang isang variable ng ganitong uri ay maaaring sumakop mula 8 hanggang 16 bytes, depende sa pagpapatupad ng compiler. Samakatuwid, ang mahabang double type ay kadalasang nagbibigay ng mas higit na katumpakan bilang kapalit ng mas maraming memory consumption.

Suriin natin ang pagpapatupad ng sumusunod na programa.

Ipapakita ng screen ang:

X = 10.500000

Tandaan na ang %f ay ginagamit sa halip na %d, dahil sa paggamit ng isang tunay na uri sa halip na isang integer. Suriin kung ano ang mangyayari kung inilagay mo ang %d sa halip na %f .

Paano mag-alis ng mga dagdag na zero kapag nagpapakita ng isang numero? Upang gawin ito, maaari mong tukuyin ang bilang ng mga digit pagkatapos ng decimal point, halimbawa, tulad ng sumusunod.

Printf("x = %.1f \n" ,x);

Sa kasong ito, ang numero pagkatapos ng tuldok ay nagpapahiwatig ng bilang ng mga digit pagkatapos ng decimal point. Eksperimento dito.

Bilang karagdagan, maaari mong itakda ang bilang ng mga character na ginamit upang ipakita ang numero, halimbawa, maaari mong itakda ang numerong ito sa 10 tulad ng sumusunod.

Printf("x = %10.1f \n" ,x);

Suriin upang makita kung ano ang mga pagbabago.

Bilang karagdagan, sa halip na letrang f, na kasama ng %, maaari mong gamitin ang letrang e upang magpakita ng numero sa exponential form, gayundin ang letrang g upang awtomatikong piliin ang format ng output depende sa halaga ng numero. Bukod pa rito, maaari ding gamitin ang mga letrang E at G.

Mga gawain sa pagpipigil sa sarili

Subukan ang iba't ibang variant ng pagsusulat ng totoong numero at tingnan kung ano ang mangyayari (kabilang ang paggamit ng mga letrang e at g sa halip na f na may kumbinasyon ng %).
Tukuyin para sa iyong sarili kung ano ang mga kahihinatnan ng paggamit ng mga titik E at G ay inihambing sa mga titik e at g.
Ipatupad ang parisukat at kubo ng isang tunay na numero, na tinitiyak na ang mga resultang halaga ay ipinapakita sa screen. Piliin ang naaangkop na real number na format ng output.