C++

ლოგო

C++ (ჩვეულებრივ ქართულად გამოითქმის „სი-პლუს-პლუსი“) — საერთო დანიშნულების პროგრამირების ენა. მისი განვითარება დაიწყო ბიარნ სტრუსტრუპმა 1979 წელს ბელ-ლაბში C პროგრამული ენის გასაძლიერებლად. თავდაპირველად მას C with Classes ერქვა, ხოლო 1983 წელს C++ ეწოდა. 1990-იანი წლებიდან C++ გახდა ერთ-ერთი ყველაზე პოპულარული კომერციული პროგრამირების ენებიდან. C++ პროგრამული ენის სტანდარტის რატიფიკაცია მოხდა 1998 წელს, როგორც ISO/IEC 14882:1998; მისი თანამედროვე ვერსიაა 2003 წლის, ISO/IEC 14882:2003. ამჟამად დამუშავების პროცესშია სტანდარტის ახალი ვერსია (არაფორმალურად ცნობილი როგორც C++0x).

პროგრამირების არსი

პროგრამა შედგება ორი მთავარი ნაწილისგან: მონაცემებისა და ინსტრუქციებისგან. უმცირესი მონაცემი, რომლის აღქმაც შეუძლია კომპიუტერს, არის 0 ან 1, ან უფრო ზუსტად „-“ ან „+“, რისი ჩაწერა და წაკითხვაც მას შეუძლია ფიზიკური მეხსიერების უმცირეს ერთეულში. ეს იმის გამო, რომ ჯერჯერობით ელექტრონულ სქემებს მხოლოდ ორ მდგრად მდგომარეობაში შეუძლიათ ყოფნა. მონაცემთა ამ უმცირეს ერთეულს ეწოდება ბიტი (ინგლისური ტერმინი bit წარმოადგენს „binary digit-ის“ ანუ ორობითი ციფრის შემოკლებას). ნებისმიერი მონაცემი, რომელიც მუშავდება კომპიუტერის მიერ, წარმოიდგინება ნულებისა და ერთების კომბინაციით და მის დასამახსოვრებლად საჭიროა ბიტების გარკვეული რაოდენობა. შემდეგ, შედარებით მარტივი ტიპის მონაცემებისგან შესაძლებელია უფრო რთული კონსტრუქციების შექმნა, მათგან კიდევ უფრო რთულის და დახვეწილის და ა.შ. C++-ში ჩაშენებულია რამდენიმე მარტივი საბაზო ტიპი მონაცემებისთვის. თითოეული ტიპისთვის გამოყოფილია ბიტების მკაცრად დადგენილი რაოდენობა. ამათგან აიგება ყველა დანარჩენი. ზოგადად, მონაცემები და ინსტრუქციები ანალოგიურია მათემატიკის სიმრავლეებისა და ფუნქციებისა. ამიტომ, ვიდრე C++ -ის მონაცემთა ტიპებსა და ფუნქციებზე ვისაუბრებთ, ჯერ უნდა გავარკვიოთ რა ცოდნა შეგვიძლია გამოვიყენოთ მათემატიკიდან. მანამდე მოკლედ შევეხოთ კომპიუტერში რიცხვების წარმოდგენის საკითხს.

ძველი და ახალი ვარიანტი

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

ძველი სტილი - პრეპროცესორით (#define) შემოტანილია სათაურის ფაილები, რომლებიც .h-ით მთავრდება:

  #include <iostream.h>
  int main()
  {
    printf("Hello World\n");
    return 0;
  }

ახალი სტილი - საჭირო აღარაა, ყველა შემოტანილი ფაილი ერთიანდება ერთ std სახელსივრცეში:

  #include <iostream>
  using namespace std;  
  int main()
  {
    cout<<"Hello World"<<endl;
    return 0;
  }

იდეალური პროგრამა

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

• მრავალჯერადი, გამოყენების თვალსაზრისით;
• ადვილად გაუმჯობესებადი გადაკეთების თვალსაზრისით და მარტივი ექსპლოატაციაში;
• საიმედოდ დაწერილი (მაგალითად, ნაკლებად დამოკიდებული კონკრეტულ სისტემაზე);
• ადვილად გასარჩევი;
• კარგად დოკუმენტირებული (ანუ ახლდეს ყველა საჭირო კომენტარი და ახსნა-განმარტება).

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

#include <iostream>   // მიმართვა შეტანა–გამოტანის 
using namespace std;  // სტანდარტულ კლასებზე
// პროგრამის მთავარი ფუნქცია
int main()
{ 
	// მონაცემებზე განაცხადი 
	// და შესრულებადი ინსტრუქციები
}

მაგალითად, ქვემოთ მოყვანილი პროგრამა იპოვის და დაბეჭდავს ორი მთელი რიცხვის ჯამს:

#include <iostream>   
using namespace std;  

int main()
{
   int number1(9), number2(-4), sum;
   sum = number1 + number2;
   cout<<"Sum = "<<sum<<endl;
   return 0;
}

შემოკლებული ოპერატორები

C++–ში არის არაერთი ოპერატორი, რომლის შესრულება ნიშნავს ორი სხვა ოპერატორის ან ინსტრუქციის შესრულებას. როგორც წესი, ამ ოპერატორების უმრავლესობა აგრეთვე გადატვირთულია სხვადასხვა საბაზო ტიპზე. უფრო მეტიც, მომხმარებლის მიერ განსაზღვრულ სხვადასხვა ტიპისთვის (კლასისთვის) ხშირად ძალიან მოსახერხებელია შემოკლებული და სხვა ოპერატორების (ნაწილის მაინც) გადატვირთვა. მაგალითად, ძალიან ხშირად არის საჭირო რომელიმე ცვლადის, მთელის ან ნამდვილის, (ვთქვათ, counter) მნიშვნელობის ერთით გაზრდა. თუ ამას მინიჭების შეტყობინებით გავაკეთებთ, გვექნება:

   counter = counter +1;

იგივე შედეგს მოგვცემს ++ (მომატების ოპერატორი ანუ ინკრიმენტი) ოპერატორის გამოყენება:

   ++counter;

ანალოგიური მოქმედებისაა -- (მოკლების ოპერატორი ანუ დენკრიმენტი) ოპერატორი, რომელიც ერთით ამცირებს ცვლადის მნიშვნელობას. თუ გვინდა არა ერთით, არამედ 3–ით გავზარდოთ ცვლადის მნიშვნელობა, უნდა გამოვიყენოთ += ოპერატორი, ანუ შემდეგი ორი შეტყობინება აკეთებს ერთი და იგივე რამეს:

   counter = counter + 3;
   counter += 3;

ცხრილში მოყვანილია რამდენიმე მაგალითი:

ოპერატარები	შეტყობინება	ეკვივალენტური შეტყობინება
+=	x += 2;	x = x + 2;
-=	x -= 2;	x = x - 2;
*=	x *= 2;	x = x * 2;
/=	x /= 2;	x = x / 2;
%=	x %= 2;	x = x % 2;

რესურსები ინტერნეტში

• JTC1/SC22/WG21
• Standard C++ Foundation