ფილმები,მუსიკები,თამაშები,ვიდეოები,ყველაფერი იმისთვის რომ არ მოიწყინოთ

http://www.softutorials.com/oneadmin/_files/linksdir/3006_C___Language_Tutorial.png

შესავალი

ცოტა რამ C++ ისტორიიდან. სანამ C++ მოევლინებოდა ქვეყანას მის ადგილს პროგრამირების სამყაროში მეთოდური ენა C იკავებდა. C++ ცვლის თავისი ობიექტებზე ორიენტირებული მიდგომით თავის წინამორბედს და ხდება ერთერთი მოწინავე ენა. მისი დაუფლების სურვილი გამოწვეული იყო იმ მოტივით რომ თავისი არსით ჰიბრიდული ენა გამოვიდა, რომელშიც შესაძლებელია როგორც მეთოდური მიდგომით ასევე ობიექტებზე ორიენტაციით პროგრამული პროდუქტების შექმნა. მას არ დაუკარგავს თავისი წინამორბედის არცერთი მეთოდი თუ სტრუქტურა, ისინი წარმატებით გამოიყენება დღესაც და არანაირ უხერხულობას არ ქმნის. თუმცა ითვლებოდა რომ პროგრამირების გამოცდილების გარეშე არ იყო მიზანშეწონილი C++ ის სწავლა და ურჩევდნენ დამწყებებს ჯერ C ესწავლათ, მაგრამ თუკი გავითვალისწინებთ C++ ის ჰიბრიდულობას, არანაირი საფუძველი არ არსებობს იმისა რომ უარი ითქვას C++ ის სწავლაზე საწყის ეტაპზეც კი. ჩემი სასწავლო კურსიც ამ სტრუქტურის მატარებელია. იგი დაიწყება პირველყოფილი C ით და ისე გადავალთ C++ ზე რომ ამას ვერც გავიგებთ. ერთადერთი რისი გაგებაც ცოტა ძნელდება და დიდ ძალისხმევას მოითხოვს ეს არის მისამართები რაზეც გთხოვდით დიდი ხანი გაგემახვილებინათ ყურადღება, რადგანაც მათ შესახებ უმეტეს სახელმძღვანელოებში ისეთი აბრა-კადაბრაა რომ შეიძლება კაცმა თავი დაკარგო და სულ დაგეკარგოს სწავლის სურვილი. მაშ ასე მობრძანდით C++ ის მაღაროებში.
P.S. სანამ დავიწყებდე ღაღადისს C++ ზე მანამდე მინდა ტექნიკური საკითხებიც შევათანხმო. ყველა კოდები რაც აქ იქნება განხილული ტრანსლირებულია visual studio 6.00 იგივე კოდები შეიძლება ტრანსლირებული იქნეს შემდგომ ვერსიებში მაგრამ უფრო ძველი ვერსიებისთვის დასჭირდება პროექტის ახალი შექმნა ხოლო კოდი მაინც უცვლელი დარჩება.

ცვლადები და ოპერატორები

ცვლადების გამოცხადება ხდება ოპერატორის მიშვეობით ანუ იმ სპეციალური სიტყვებით რომლებიც ტრანსლიატორშია რეზერვირებული და მას ტრანსლიატორი გამოყოფილი ფერით აფერადებს. ჯერ იწერება ოპერატორის დასახელება რომელიც ამასთანავე ცვლადის ტიპსაც განსაზღვრავს, ხოლო შემდეგ მოდის ცვლადი. ცვლადი შეიძლება იყოს ნებისმიერი სიტყვა გარდა ზემოთ აღნიშნული რეზერვირებული სიტყვებისა, აგრეთვე არ შეიძლება ცვლადი იწყებოდეს რიცხვით ან პუნქტუაციის ნიშნებით. მისაღებია მხოლოდ ხაზგასმის ნიშანი რომლითაც შეიძლება რომ დაიწყოს ცვლადის დასახელება.
მაგ

char string; // მისაღები გამოცხადება

char -არის ოპერატორი string - არის ცვლადი

int 1a; //მიუღებელი გამოცხადება

int a1; //მისაღებია

double _Mani; //მისაღებია

float < fg ; //მიუღებელი გამოცხადება

float fg _ ; //მისაღებია

ცვლადის სიგრძე ასოებში არ არის შეზღუდული მაგრამ მისაღებია კომპაქტური და ამასთანავე ინტუიციურად გასაგები სახელების დარქმევა ცვლადებზე, რაც პროგრამის კოდს ადვილად საკითხავს ხდის. სანამ გავარჩევდეთ თუ რას ნიშნავს ცვლადის გამოცხადება, მანამდე უნდა გავარკვიოთ რა წონა აქვს თითოეულ ოპერატორს და რატომ არის საჭირო ოპერატორის არსებობა ცვლადის წინ; ყოველ ოპერატორს აქვს დატვირთვა რომ პროგრამის გაშვების დროს სისტემას მოსთხოვოს იმ ბაიტების რაოდენობა მეხსიერებაში რამდენი ბაიტის მატარებელიც არის თითოეული მათგანი, ეს ადგილი მეხსიერებაში შეიძლება ცარიელი იყოს მაგრამ პროგრამის მსვლელობი პერიოდში შეიძლება შიგ რაღაც ჩაიწეროს ანუ ის ცვლადი რომელსაც ოპერატორის შემდეგ გამოვაცხადებთ ხდება იგივე ტიპის რაც მისი ოპერატორია . მაგალითად როდესაც გვინდა რომ შევკრიბოთ ორი მთელი რიცხვი ამისათვის უნდა გამოცხადდეს მთელი რიცხვების ოპერატორი , თუ ვიცით რომ საქმე ათწილადებთან გვექნება მაშინ ათწილადების ოპერატორი, ხოლო თუ ტექსტებთან გვინდა მანიპულაციები მაშინ მის ოპერატორს მივმართავთ. ქვემოთ განვიხილოთ თითოეული მათგანი;
char _text; // char ოპერატორი დარეზერვირებულია ტექსტებთან სამუშაოდ და იგი მეხსიერებაში იკავებს 1 ბაიტს
int num; // int ოპერატორი დარეზერვირებულია მთელ დადებით და უარყოფით რიცხვებთან სამუშაოდ და იგი მეხსიერებაში იკავებს 4ბაიტს;
double man; და float mani //double და float ოპერატორი განკუთვნილია უარყოფით და დადებით ათწილადებთან სამუშაოდ და იგი მეხსიერებაში იკავებს 8 ბაიტს;
void Free // void ოპერატორი არის ცარიელი ოპერატორი რომელიც შესაძლებელია გამოყენებული იქნას ნებისმიერი ცვლადის გამოსაცხადებლად და მას ეკავება 4 ბაიტი მეხსიერებაში. თუმცა არანაირი მანიპულაცია მასზე არ შეიძლება იქნას ჩატარებული თუ არ მოხდება რომელიმე სხვა ტიპზე გადაყვანა, რომელსაც შემდგომში განვიხილავთ .
bool Refl; // ბინარული ანუ ორობითი ოპერეტორი რომელსაც შეუძლია მიიღოს მხოლოდ ორი მნიშვნელობა true და false;
unsigned // unsigned არის ოპერატორი რომელიც იწერება რომელიმე ოპერატორის წინ და განსაზღვრავს რომ მისი მომდევნო ოპერატორი არის განკუთვნილი მხოლოდ დადებითი ნიშნის მქონე რიცხვებისათვის და მცდელობა რომ მას მივანიჭოთ უარყოფითი მნიშვნელობა ტრანსლიატორის შეცდომას გამოიწვევს, მისი სინტაქსისი შემდეგნაირია
unsigned char text; unsigned int num; თუმცა მარტო unsigned-იც შეიძლება რომ იქნეს რომელიმე ცვლადის ოპერატორი, ამ შემთხვევაში იგი ასოცირებული იქნება unsigned int - თან; ასევე ოპერატორებია + - = * / ; მიმატება , გამოკლება ტოლობა, გამრავლება და გაყოფა;

ირველი პროგრამის ნაირი

იმისათვის რომ უფრო თვალნათლივ დავინახოთ ოპერატორების მიერ გამოყოფილი ადგილის სიდიდეები გავაკეთოთ პატარა პროგრამა. გაუშვათ visual studio და მენიუ file ავირჩიოთ new გამოჩნდება ფანჯარა კონსტრუქტორების ჩამონათვალით .

მოვნიშნოთ Win32 Console Aapplication და მინიშნებულ ადგილას დავარქვათ რამე ჩვენ პროექტს , როგორც ჩემს შემთხვევაში MyProg , ქვედა ფანჯარაში ავირჩიოთ ლოკაციის ადგილი თუ სად შეიქმნას დირექტორია რომელშიც ჩვენი პროექტი განთავსდება. არჩეულ ადგილას შეიქმნება ახალი საქაღალდე იმავე სახელით რაც პროექტს დავარქვით ანუ MyProg . ყველა მოთხოვნის შემდეგ ღილაკი OK და კონსტრუქტორი შემოგვთავაზებს პროგრამის ტიპის არჩევას ამ ფანჯარაში არაფრის შეცვლა არ არის საჭირო უბრალოდ დავასრულოთ ღილაკი FINISH ით პროექტის შექმნა. კონსტრუქტორი გვიპატაკებს რომ შექმნის მარტო პროექტს და დანარჩენი თქვენ იცითო, ჩვენც არ ვეკამათებით და ვეთანხმებით, სხვანაირად არაფერი არ გამოვა. ბოლოსდა ბოლოს პროექტი შექმნილია მაგრამ მასში არაფრის გაკეთება არ შეიძლება რადგანაც დასამატებელია ფაილი რომელშიც კოდი უნდა ჩაიწეროს.
ამიტომაც მენიუ Project -ში ვირჩევთ პუნქტს Add Tu project -> New რის შემდეგაც გამოჩნდება ფაილთა სია რომლის დამატებაც შესაძლებელია პროექტში

მოვნიშნავთ C++ Source File და ფანჯარაში File name ვარქმევთ ფაილს სახელს რაც მოგვეხასიათდება. ვადასტურებთ ყოველივე ჩვენს მიერ ჩადენილს და ფაილი პროექტში გამოჩნდება აი ასე

მართალია პროექტს ფაილი დავუმატეთ მაგრამ სამწუხაროა რომ ფაილში არაფერი არ წერია . თუ არ ჩავწერეთ არც ჩაიწერება. ჩვენც ვიწყებთ წერას.
მაკროპროცესორი # include განაპირობებს მის შემდეგ მითითებული ფაილის ჩართვას ტრანსილირებულ ტექსტში. მისი სინტაქსია;
# include < iostream.h >
//ამ შემთხვევაში მიცემულია ფაილი რომელიც visual studios სპეციალურად განკუთვნილ საქაღალდეშია მოთავსებული ამ საქაღალდესაც იგივე სახელი აქვს რაც მაკროპროცესორს და მისი ნახვა შეიძლება visual studios პროგრამფაილების საქაღალდეში ასეთი ფრჩხილების გაკეთება თავისთავად მიანიშნებს იმაზე რომ პროექტსი ჩართულია სათაო ფაილი ( header File) visual studios სისტემიდან
# include "MyClass.h"// ამ სახით ჩართული ფაილი შეიძლება იყოს როგორც visual studios სისტემიდან ასევე საკუთარი, ჩვენს მიერ შექმნილი სათაო ფაილი იმ შემთხვევაში თუ ის ფაილი რომელსაც მაკროპროცესორის შემდეგ ვწერთ იმყოფება იმავე საქაღალდეში რომელშიც ტრანსლირებული პროექტია მოთავსებული(ეს არ ეხება visual studios ფაილებს), სხვა შემთხვევაში უნდა მიეთითოს მთლიანი გზა ფაილამდე თუკი იგი სხვა საქაღალდიდან არის ჩართული.
მას შემდეგ რაც ფაილი დავამატეთ პროექტს უკვე შეგვიძლია ჩავწეროთ მაკროპროცესორი რათა მისახწევი გახდეს იმ ფუნქციათა გამოყენება რომელიც ვიზუალ სტუდიოს სტანდარტულ ბიბლიოთეკაშია რეალიზებული.

#include < iostream.h >
void main()

{

cout <<" \t\t**************** HELOO C++ **************** "< < endl;

int a=0,B;

char Tx='s';

double Doi=8.9;

float mani=10.45;

B=sizeof(Tx);

cout<<"char mexsierebaSi ikavebs --- "< < B < <" baits "< < endl;

B=sizeof(a);

cout <<"Int mexsierebaSi ikavebs --"< < B < <" baits" < < endl;

B=sizeof(Doi);

cout << "double mexsierebaSi ikavebs --- "< < B < <" baits"< < endl;

B=sizeof(mani);

cout << "float mexsierebaSi ikavebs --- "< < B < <" baits"< < endl;

}

მივყვეთ და განვიხილოთ კოდი ნაბიჯ-ნაბიჯ. პირველ ხაზში ჩავრთეთ სათაო ფაილი რომელშიც რეალიზებულია ეკრანზე გამოყვანის ფუნქციები აქედან მაქვს საშუალება გამოვიყენო ფუნქცია cout<< ამის გარდა კიდევ ბევრი ფუნქციაა რეალიზებული ამ სათაო ფაილში მაგრამ მე ჯერ სხვა არ მჭირდება. შემდეგ ხაზში იწყება პროგრამა ფუნქცია main() როგორც მისი დასახელებიდანაც ჩანს არის მთავარი ფუნქცია, იგი გლობალურია და რაიმე სათაო ფაილს არ მოითხოვს, მისი მოქმედება იწყება გახსნილი ფიგურული ფრჩხილიდან და მთავრდება დახურულ ფრჩხილთან. შეიძლებოდა უბრალოდ დაგვეწერა მარტო ფუნქცია მაინი თავისი ფრჩხილებით და პროგრამა უკვე გაეშვებოდა თუმცა არაფერს არ გააკეთებდა. შემდეგ ხაზში უბრალოდ გამოგვყავს მისალმება სუფთა ესთეთიკური თვალსაზრისით. როგორც ხედავთ ტექსტი ბრჭყალებშია მოთავსებული რაც მის უცვლელად გამოყვანის გარანტიაა და თანაც ბრჭყალების გარეშე იგი არ აღიქმება ტრანსლიატორის მიერ როგორც ტექსტი. ტექსტის თავში \t\t გაკეთებულია ტაბულაციის მიზნით რათა ტექსტი მარცხენა კიდედან ეკრანის ცენტრისკენ გადმოადგილდეს, ბოლო სიტყვა endl - ს მიზანია კურსორის შემდეგ ხაზზე გადმოტანა , წინააღმდეგ შემთხვევაში ყველა ტექსტი ერთ ხაზზე გამოვიდოდა რაც მაინცდამაინც ლამაზი არ იქნებოდა. შემდეგი ხაზიდან იწყება ცვლადების გამოცხადება, ოპერატორის შემდეგ შეიძლება ცვლადების ჩამონათვალი გაკეთდეს, ოღონდ ისინი ერთმანეთისაგან მძიმით უნდა გამოიყოს. ცვლადების გამოცხადების ბოლოს აუცილებლად უნდა დაისვას წერტილ მძიმე რომელსაც ცარიელი ოპერატორი ქვია და ყოველი გამოცხადების ბოლოში ისმევა. ასევე გლობალური ფუნქცია B=sizeof(ცვლადი) არ საჭიროებს რაიმე სათაო ფაილს . მისი მიზანია გაზომოს მის ფრჩხილებში მოთავსებბული ცვლადის სიდიდე მეხსიერებაში და აბრუნებს მთელ რიცხვს ცვლადის ზომას ბაიტებში, ამიტომაც იგი int ს გაუტოლე , ყოველი გამოძახების შემდეგ B ს მნიშვნელობა გამოგვყავს ეკრანზე.

მასივები

მასივები ერთ-ერთი ფუნდამენტალური მცნებაა პროგრამირების სამყაროში, ეს არის მეხსიერების ბლოკების(ბაიტების) თანმიმდევრული გამოყოფა. როგორც ვიცით (და თუ არ ვიცით ეხლა გავიგებთ) წინა თემებიდან ოპერატორის მეშვეობით შეგვიძლია გამოვაცხადოთ ცვლადი რომელიც მეხსიერებაში რაღაც ადგილს დაიკავებს, ყოველი შემდგომი ცვლადის გამოცხადებისას ჩვენ არა გვაქვს გარანტია რომ ცვლადები რომლებიც გამოვაცხადეთ, ერთმანეთის მიყოლებით განლაგდებიან მეხსიერებაში, და თუკი დაგვჭირდება მეხსიერებიდან ამ ცვლადების წაკითხვა ჩვენ უნდა სახელებით მივმართოთ მათ, სხვანაირად მათი მოძებნა შეუძლებელია. მასივი ამ მხრივ უნიკალურია რადგანაც ყოველი ცვლადი რომელიც მასივში იქნება, გარანტირებულად ერთმანეთის მიყოლებით იქნება მეხსიერებაში ჩაწერილი და მეხსიერებიდან შეიძლება ასევე მიმდევრობით წაკითხვა; მასივი შეიძლება არსებობდეს ნებისმიერი ტიპის;
მაგ
int masivi [10]; // int არის ოპერატორი რომელიც განსაზღვრავს რომ მასივი რომელიც გამოიყოფა და ჩვენს შემთხვევაში მასივს ქვია masivi მის თითოეულ წევრს ექნება 4 ბაიტის სიდიდე. აქ გამოყოფილი არის 10 წევრიანი მასივი(ანუ 10 არის მასივის სიგრძე) და თითოეული წევრის სიდიდე ოთხი ბაიტია;
ჩვენ შეგვიძლია მის თითოეულ წევრს ცალცალკე მივანიჭოთ მნიშვნელობა
მაგ:

masivi[2] = 18;

masivi[0]=100;

masivi [5]=20;

masivi [9]=43;

masivi [10]=234; //EROR!!!

საგულისხმოა ერთი რამ რომ , თუმცა მასივის სიგრძე 10 ის ტოლია ჩვენ არშეგვიძლია მივმართოთ მასივის მე 10 ელემენტს, რადგანაც მასივის ათვლა იწყება 0 დან და ამიტომაც მისი ბოლო წევრი არის მეათ ელემენტი ინდექსით 9; თუმცა მასივის გამოცხადებისას რიცხვი 10 განსაზღვრავს მასივის სიგრძეს მინიჭებისას ოთხკუთხედ ფრჩხილებში მოთავსებული რიცხვები უკვე მიუთითებენ არა სიგრძეს არამედ ინდექსს თუ მასივის რომელ წევრთან ხდება მოქმედება;
განვიხილოთ ტექსტური მასივი;
char TeMas[20]; // char არის ოპერატორი რომელიც განსაზღვრავს რომ მასივი რომელიც გამოიყოფა და ჩვენს შემთხვევაში მასივს ქვია TeMas მის თითოეულ წევრს ექნება 1 ბაიტის სიდიდე. აქ გამოყოფილი არის 20 წევრიანი მასივი(ანუ 20 არის მასივის სიგრძე) და თითოეული წევრის სიდიდე ერთი ბაიტია;
განსხვავებით სხვა მასივებისა, რომლებიც რიცხვებთან სამუშაოთაა განკუთვნილი, char მასივების ინიციალიზაცია (ანუ მნიშვნელობის მინიჭება) გამოცხადებისთანავეა შესაძლებელი; გამოვიყენებ იგივე მასივს;
char TeMas[20]="Hello C++"; //მართალია მასივი 20 ბაიტიანია მაგრამ ჩვენ მხოლოდ 9 ბაიტი შევავსეთ, თითოეული ასო მეხსიერებაში იკავებს 1 ბაიტს. ცხრა ბაიტის შემდეგ ისე რომ ჩვენ არც ვიცით თავისთავად ეწერება დასასრულის აღმნიშვნელი \0. ეს ხდება იმ მიზეზით რომ წაკითხვისას წაკითხული იქნეს მხოლოდ მეხსიერების ის ნაწილი რომელიც შევსებულია და დანარჩენი იგნორირებული იქნება. აუცილებელი პირობაა ტექსტის ბრჭყალებში მოთავსება, სხვანაირად ტრანსლიატორისთვის გაუგებარი ხდება მინიჭების მოქმედება.
ისევე როგორც სხვა მასივებში აქაც არის საშუალება რომ ცალცალკე მივანიჭოთ მნიშვნელობა მასივის წევრებს

TeMas[0] = "H";

TeMas[1]="e";

TeMas[2]="l";

TeMas[3]="l";

TeMas[4]="o";

TeMas[5]=" ";

და ასე შემდეგ.
მართალია ჩვენი მასივი თავიდანვე 20 ბაიტი გამოვყავით და აქედან მხოლოდ 9 ბაიტი შევავსეთ, სინამდვილეში 10 ბაიტია შევსებული. მეათე არის დასასრულის ნიშანი "\0". თუკი ჩვენ გამოვყოფდით აი ასე ;
char TeMas[9]="Hello C++"; // თითქოს გამართლებულია რომ გვაქვს 9 სიმბოლო და ამიტომაც 9 ბაიტი მოვითხოვეთ, მაგრამ ტრანსლიატორი შეცდომას აფიქსირებს რადგანაც არ რჩება ადგილი დასასრულის აღმნიშვნელი სიმბოლოსათვის:

ისეთი შემთხვევებისათვის როცა არა აქვს მნიშვნელობა მასივის სიგრძეს, შეგვიძლია გამოვაცხადოთ მასივი წინასწარ განსაზღვრული სიდიდით, რომელიც ტრანსლიაციის დროს შემოწმდება და გამოიყოფა იმხელა მეხსიერება რამდენი სიმბოლოც არის ტოლობის შემდეგ. ამ სახის მასივი გამოცხადებისთანავე უნდა იქნეს ინიცირებული, მისი დინამიური ინიციალიზაცია არ მოხდება. მაგ:
char TeMas[ ] ="gamarjoba Cemo Tbilis qalaqo";
როდესაც არანაირი მანიპულაციების ჩატარება არ იგეგმება ტექსტურ მასივთან და უბრალოდ ეკრანზე გამოსაყვანად გვჭირდება მასივი, მაშნ მიზანშეწონილია ამ სახით მასივის გამოცხადება, თუმცა არც ეს მასივია ურიგო მანიპულაციებისთვის, რასაც შემდეგ თავებში გავარკვევთ; ტექსტური მასივების გარდა ყველა სხვა დანარჩენი მასივები შეიძლება განხილულ იქნას ერთ ჯგუფში, ამიტომ ყველაზე ცალ ცალკე აღარ შევჩერდები;
არაფრის შეცვლა არ არის საჭირო, ბოლო ხაზის შემდეგ დავწეროთ ეს კოდი

cout < <"/////////////////////////////////////////////////////////////////////////////////////////////////////////////////"< < endl;

int array[10];

double darray[5];

char TextMas[20];

char Text2[]="ganusazgvreli sididis masivi";

array[0]=10;

array[1]= 15;

array[8]=25;

darray[2]=9.27;

darray[1]=23.5;

darray[4]=22.87;

flomas[2]=22.987;

flomas[8]=12.55;

flomas[0]=10;

TextMas[0]='I';

TextMas[1]='L';

TextMas[2]='I';

TextMas[3]='A';

cout < < "1.int masivis pirveli elementi = "< < array[0 ] < < endl;

cout < < "2.int masivis meore elementi = " << array[1 ]< < endl;

cout < < "3.int masivis meSvide elementi = " < < array[8] < < endl;

array[2]=array[0] + array[8] *array[1];

cout < < "4.int masivis mesame elementi = " < < array[2] < < endl;

cout < < "5.double masivis mesame elementi = " < < darray[2] < < endl;

cout < < "6.double masivis meore elementi = " < < darray[1] < < endl;

cout < < "7.double masivis mexuTe elementi = " < < darray[4] < < endl;

darray[0]=(darray[2] + darray[4] )/(darray[1] + 30.76);

cout < < "8.double masivis pirveli elementi = " < < darray[0] < < endl;

cout < < "9.char masivis pirveli elementi = " < < TextMas [0] < < endl;

cout < < "10.char masivis meore elementi = " < < TextMas [1] < < endl;

cout < < "11.char masivis mesame elementi = " < < TextMas [2] < < endl;

cout < < "12.char masivis meotxe elementi = " < < TextMas [3] < < endl;

cout < < "13.ganusazgvreli masivi = "< < Text2 < < endl;

ციკლები და პირობითი ოპერატორები

თუკი რაიმე შეხება გვქონია რომელიმე პროგრამირების ენასთან, ყველგან არსებობს ციკლის და პირობის ოპერატორები, C++ შიც არის ასეთი მცნებები. განვიხილოთ ყველა ცალ ცალკე.
1. პირობის ოპერატორები:

if()

else

2. ციკლის ოპერატორები
for ()

while()

do while();

დავიწყოთ პირობის ოპერატორების განხილვით, რადგანაც ყველა ციკლი რაღაც პირობამდე სრულდება
ოპერატორი IF()
if() ოპერატორის ფრჩხილებში იწერება პირობა თუ რა უნდა დაკმაყოფილდეს რომ შეიძლებოდეს ოპერატორის შემდგომი კოდის რეალიზაცია
თუკი პირობა სრულდება if ოპერატორს გადაეცემა მნიშვნელობა true, ყველა სხვა შემთხვევაში false;
if(a < b) //თუ პირველი ცვლადი ნაკლებია მეორეზე პირობა არის true თუ არა false

if(a > b) //თუ პირველი ცვლადი მეტია მეორეზე პირობა არის true თუ არა false

if(a <= b) //თუ პირველი ცვლადი ნაკლებია ან ტოლია მეორეზე პირობა არის true თუ არა false

if(a >= b) //თუ პირველი ცვლადი მეტია ან ტოლია მეორეზე პირობა არის true თუ არა false

if(a == b) //თუ პირველი ცვლადი ტოლია მეორესი პირობა არის true თუ არა false

if(a != b) //თუ პირველი ცვლადი არ უდრის მეორეს პირობა არის true თუ არა false
if(bool cvladi romelic tolia an false an true) //თუ ცვლადს არა აქვს მნიშვნელობა true

განვიხილოთ ბოლო მაგალითი;
bool rafika = true;

if(rafika)

{

rafika =false;

}
აქ რაკი ცვლადს აქვს მნიშვნელობა true, if ოპერატორიც მიიღებს მნიშვნელობას true და შესრულდება ოპერატორის ფიგურულ ფრჩხილებში განთავსებული მოქმედება, თუმცა თუკი მეორეთ მიმართავს პროგრამა ამ ბლოკს პირობა უკვე აღარ იქნება შესრულებული და ეს ბლოკი გამოიტოვება, თუ არ მოხდა ცვლადისათვის ისევ trues მინიჭება; არის საშუალება რომ false მნიშვნელობამ ცვლადისა გამოიწვიოს true მნიშვნელობის გადაცემა if ოპერატორში; მაგ;
bool iden=false;

if( ! iden)

{

iden =true;

}
ამ შემთხვევაში if ოპერატორი მიიღებს მნიშვნელობა trues რადგან ცვლადის წინ დაწერილი ძახილის ნიშანი განსაზღვრავს შემდეგ პირობას თუ ცვლადს არა აქვს მნიშვნელობა true მაშინ პირობა შესრულებულია. ანუ შემდეგი მიმართვისას (რაკი ფრჩხილებში ხდება ცვლადისთვის trues მინიჭება ) პირობა უკვე აღარ შესრულდება და ბლოკი გამოიტოვება. ოპერატორი else სრულდება იმ შემთხვევაში თუ if ოპერატორის პირობა არ სრულდება , მარტო else oპერატორი არ მუშაობს, იგი ყოველთვის თანმდევია if ოპერატორის. მაგ
bool iden=false;

int a=10, b=20;

if( ! iden)

{

iden =true;

}

else

{

a=a+b;

}
განვიხილოთ ციკლები თანმიმდევრობით
დავიწყოთ for ით. ამ ოპერატორის მოქმედება სრულდება მანამ სანამ მისი მეორე წევრი რომელიც პირობაც არის არ შესრულდება;
მისი სინტაქსისი;
for(int i=0; i<100; i++)

{

moqmedeba romelic unda Sesruldes

}
პირველი წევრი როგორც უკვე ვიცით არის მთელი რიცხვი და მრიცხველის როლს ასრულებს , ციკლის მუშაობის დაწყებისას მოწმდება პირველი წევრი და შემდეგ საფეხურებზე მისი შემოწმება აღარ ხდება, მოწმდება მხოლოდ მეორე წევრის პირობა. რაც შეეხება მესამე წევრს ეს ახალი მცნებაა და ცოტა ფართოდ გავაშუქებთ; ორი პლუსი ცვლადის შემდეგ განაპირობებს ცვლადის ერთით გაზრდას ეს იგივეა რაც i=i+1; ამიტომ აუცილებელია თავიდან ცვლადს რაიმე მნიშვნელობა ჰქონდეს მიღებული, წინააღმდეგ შემთხვევაში არ მოხდება ცვლადის სიდიდის გაზრდა; მოქმედება შემდეგნაირად მიმდინარეობს; შემოწმდა პირობა და შემდეგ გაიზარდა ინკრემენტი ანუ ცვლადი i ; თუმცა არსებობს შემდეგი სინტაქსისიც ++i რაც იგივეს ნიშნავს მაგრამ აქ უკვე ჯერ სრულდება მომატება და შემდეგ მოწმდება პირობა; იგივე სინტაქსისი აქვს დეკრემენტს ოღონდ მინუს ნიშნით i-- ან --i და ნიშნავს i=i-1;
მეორე ციკლის ოპერატორია while()

while(ცვლადი ან პირობა)

{

მოქმედება რომელიც უნდა შესრულდეს

}
აქ ციკლის ოპერატორი მუშაობს მანამ სანამ ცვლადი ან პირობა რომელიც ოპერატორის ბრჩხილებშია არ მიიღებენ მნიშვნელობას false
განვიხილოთ ორი მაგალითი;

1) int a=0;

int b=100;

while(a < b)

{

a++;

}
ციკლის დასაწყისში მოწმდება ორივე ცვლადის მნიშვნელობა და ეს ხდება ყოველი შემდგომი გამეორებისას, ჯერ მოწმდება პირობა (a < b) და თუ პირობა სრულდება ციკლიც გრძელდება, რაც გამოიხატება იმაში რომ ფიგურულ ფრჩხილებში მოთავსებული მოქმედება შესრულდება, ცვლადს მოემატება ერთი და ისევ შემოწმდება პირობა, ასე გაგრძელდება მანამ სანამ ოპერატორში მოცემული პირობა არ დაირღვევა; მრიცხველის დაყენება იმითია ნაკარნახევი რომ თუ არ იქნება მრიცხველი და ეს ეხება ამ კონკრეტულ შემთხვევას, მაშინ ციკლი უსასრულოდ გაგრძელდება და გამოიწვევს სისტემის დაკიდებას;
2) bool soo=true;

int a=10;

while(soo)

{>BR>
if(a == 120)

{

soo=false;

}

a++;

}
ეს ის შემთხვევაა როცა ციკლი ტრიალებს მანამ სანამ ცვლადი truea და თან ყოველი შემდგომი ციკლის დროს ამოწმებს ორივე პირობას, როგორც კი soo გახდება false ციკლი მაინც მოუმატებს a - ს ერთს და დაასრულებს თავის მოქმედებას. თუმცა არსებობს ციკლის ხელოვნური გაწყვეტის ოპერატორიც რომელიც რეზერვირებულია ტრანსლიატორში. ეს არის Break; განვიხილოთ იგივე მაგალითზე;
bool soo=true;

int a=10;

while(1)

{

if(a == 120)

{

soo=false;

break;

}

a++;

}
ამ დროს შეიძლება ციკლის პირობა საეთოდ არ არსებობდეს ან უბრალოდ ფრჩხილებში ჩაიწეროს რიცხვი ერთი რაც უსასრულო ციკლს მოგვცემს;
შემდეგი ციკლია do while

int a=6;

do

{

a=a+3;

}

while(a < 5)
ამ შემთხვევაში ჯერ სრულდება ციკლის შიდა ნაწილი ხოლო შემდეგ მოწმდება პირობა, ჩვენს შემთხვევაში ეს ციკლი ერთხელ მაინც შესრულდება რადგანაც დასწყისშივე პირობა დარღვეულია, ცვლადს მაინც მოემატება სამი და დასრულდება; ყოველივე ზემოთ განხილულის უკეთ დასანახად გამოიძახეთ ხელახლა ჩვენი პროექტი, რომელიც განვიხილეთ თემაში 'პირველი მაგალითის ნაირი' გახსენით იგი და შეიყვანეთ შემდეგი კოდი;

cout<<"////////////////////////////////////////////////////////////////////////////////" << endl;

int afo=20;

for(int x=0; x
{

if( x == 15)

{

cout<<"SRULDEBA IF (x == 15) PIROBA x = " << x << endl;

}

else

{

cout << "mimdinareobs ciklis - " << x << " - safexuri \n";

}

}

cout<<"////////////////////////////////////////////////////////////////////////////////"<< endl;

ამით დავამთავრებ ციკლებთან მუშაობას რადგანაც წინ კიდევ ბევრჯერ მოგვიწევს მათთან შეხება, უფრო მეტ კომბინაციებს უკვე პრაქტიკულ სავარჯიშოებზე გამოვცდით; რაც შეეხება cout და endl ფუნქციებს მათ შესახებ არ ვწერ დაწვრილებით რადგანაც ეს ფუნქციები მხოლოდ პროგრამის ტესტირებისათვისაა მოსახერხებელი, ისინი შემდგომ ეტაპებზე დაკარგავენ თავიანთ აქტუალობას და აღარც გაგვახსენდება; პროგრამა დოსის ფანჯარაში მიმდინარეობს მაგრამ ეს მთლად დოსი არ არის რადგანაც ეს პროგრამები მხოლოდ ვინდოუსიდან ეშვებიან, და ეს ფუნქციებიც მხოლოდ დოსისთვისაა განკუთვნილი;

ფუნქციები
ფუნქციათა განსაზღვრა და გამოძახება

საერთოდ ფუნქცია და მისი დანიშნულება პროგრამირების ენებში, ყველგან თითქმის ერთია. ჩვენი თემების ყველა ლექციებში ამ საკითხს უკვე შევეხეთ, განვიხილეთ თითოეული პროგრამირების და ენის მიხედვით მისი დანიშნულება და მისი შემოტანის პრიორიტეტი. ახლაც გვინდა მოკლედ აგიხსნათ ის, თუ რას წარმოადგენს ფუნქცია და რა დანიშნულება გააჩნია მას.
წარმოიდგინეთ წერთ რომელიმე პროგრამის კოდს, სადაც ერთი და იგივე კოდის (ვთქვათ, რაიმე ტექსტური ჩანაწერის) მრავალჯერ გამეორება გიწევთ, რა ხდება ამ დროს? იძულებულები ვართ ეს კოდი ყველგან გავიმეოროთ, ამით რა თქმა უნდა იზრდება პროგრამის კოდი, რაც ხელს უშლის პროგრამის მოქნილობას და ასევე რა საკვირველია ვკარგავთ ბევრ დროს. აი ფუნქციის შემოტანით ამ შრომის აცილება შესაძლებელია და თუ როგორ, ამაზე ქვემოთ.
ფუნქციის გამოყენება აადვილებს აგრეთვე პროგრამაში გაპარული შესაძლო შეცდომის პოვნას და შესაძლებელია აგრეთვე ამ ფუნქციის სხვა ახალ პროგრამაშიც გამოყენება, უბრალოდ კოპირების მეთოდით გადავიტანთ ფუნქციაში შესულ ბრძანებებს და მორჩა.
როგორც ხედავთ, ფუნქციის შემოტანას პროგრამირებაში ბევრი უპირატესობანი გააჩნია, ამიტომ ჩვენი რჩევაა, გულმოდგინეთ მოეკიდოთ ამ საკითხს.
როგორც ცვლადები, ასევე ფუნქციებიც პირველ რიგში უნდა განისაზღვრონ, ჩვენი ფუნქციის განსაზღვრა ხდება main() ფუნქციის წინ, ხოლო მისი გამოძახება შესაძლებელია თვით ამ main() ფუნქციიდან; მარტივად ვწერთ ჩვენი ფუნქციის სახელს და მორჩა.
ფუნქციის განსაზღვრისას პირველ რიგში ვფიქრობთ მის სახელზე და იმაზე, თუ რა დანიშნულება უნდა ქონდეს ამ ჩვენს ფუნქციას, ანუ რა მუშაობა უნდა გაწიოს მან ჩვენს პროგრამაში.
ფუნქციის სახელი სასურველია იყოს ნათელი, რათა შემდეგი მუშაობის შესრულებაში ადვილად შევძლოთ მთლიანი კოდის ანალიზება.
შემოვიტანოთ ერთი მაგალითი ახლა და მივყვეთ მას ნაბიჯ-ნაბიჯ, რათა გავერკვეთ ფუნქციის წესებში.
როგორც ყოველთვის ფუნქციას ეძლევა სახელი; misalmeba(), რომლის ბოლოშიც ვსვამთ ფრჩხილებს, თუ რას წარმოადგენენ ეს ფრჩხილები, ამაზე ქვემოთ გვექნება საუბარი, მოკლედ კი გეტყვით, რომ ეს ფრჩხილები წარმოადგენენ ადგილს სადაც ხდება ფუნქციის პარამეტრების განსაზღვრა.
ახლა მივყვეთ კვლავ ჩვენს მაგალითს. რა მოვალეობა ეკისრება ჩვენს მიერ შექმნილ ახალ ფუნქციას misalmeba(), რა მუშაობა უნდა შესრულოს მან ჩვენს პროგრამაში.
როგორც თვით ფუნქციის სახელი გვეუბნება, საჭიროა მან ჩვენს პროგრამაში შეასრულოს მისალმების ფუნქცია, ანუ როდესაც ჩვენ გვსურს მივესალმოთ ჩვენს მომხმარებელს (მას ვინც ჩვენი დაწერილი პროგრამით იხელმძღვანელებს).
როგორც უკვე წინა ლექციებიდან ვიცით, ტექსტური ჩანაწერების გადმოცემას ვახდენთ ბრძანებით cout, რომელსაც მიეთითება აუცილებლად ეს ნიშანი <<, რომლის შემდეგაც ვათავსებთ ჩვენთვის სასურველ ტექსტს, რომელსაც ვხურავთ კვლავ ამ ნიშნით <<, და ბოლოს ვუთითებთ ბრძანებას endl, ამ უკანასკნელის დანიშნულებაა, შემოიტანოს ახალი სტრიქონის დასაწყისი.
cout << "gamarjobaT xalxooo!" << endl; //არ დაივიწყოთ, რომ C++ პროგრამირებაში, ასევე ჯავა ენაში ყოველი საპროგრამო სტრიქონი მთავრდება წერტილ-მძიმეთი, ანუ ასე ;
ფუნქციებს შეუძლიათ საბოლოო შედეგების უკუ ასახვა მოახდინონ, რომლებსაც ენიჭებათ ტიპაჟები, ანუ იმ ტიპების სახეობები, რომელი სახისაც უნდა იყოს შედეგის მნიშვნელობა. (int, duble ან string). ამიტომ ყოველ ფუნქციას მისი განსაზღვრისას ფუნქციის სახელის წინ მიეთითება შესაბამისი ტიპაჟი. ხოლო იმ შემთხვევაში, როდესაც არაა საჭირო ფუნქციის ბოლო შედეგის გადმოცემა, როგორც ამ ჩვენს მაგალითში, მაშინ მიეთითება სპეციალური ბრძანება void
მაშასადამე ჩვენი ფუნქციის განსაზღვრა ხდება ასე:
void misalmeba()
ახლა ავდგეთ და მოვათავსოთ ჩვენი ტექსტური ჩანაწერი ფუნქციის სპეციალურ ბლოკში.

კატეგორია: ვებმასტერებისთვის | ნახვა: 627 | დაამატა : gura | Рейтинг: 0.0/0 |

კომენტარები: 0