რას იცნობთ გამონაკლისების უსაფრთხოების გარანტიებზე?

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

1. ძირითადი გარანტია (Basic guarantee): თუ ფუნქცია ნետავს გამონაკლისს, პროგრამა რჩება ვალიდურ მდგომარეობაში. რესურსები არ იკარგება (მაგალითად, მეხსიერება თავისუფლდება), მაგრამ ობიექტების ზუსტი მდგომარეობა შეიძლება იყოს უცნობი. შესაძლებელია პროგრამის მუშაობის გაგრძელება:

   // ძირითადი გარანტიის მაგალითი
   void basic_guarantee_function(std::vector<int>& vec, int value) {
       // გამონაკლისი შეიძლება მოხდეს ჩასმაზე
       vec.push_back(value); 
       // თუ გამონაკლისი მოხდა, vec შეიძლება იყოს გაურკვევლობაში (ნახევრად შეცვლილი),
       // მაგრამ vec-ისთვის გამოყოფილი მეხსიერება სწორად თავისუფლდება გამოსვლისას:
   } 
   

2. მკაცრი გარანტია (Strong guarantee): თუ ფუნქცია ნეტავს გამონაკლისს, პროგრამის მდგომარეობა რჩება იგივე, როგორც ფუნქციის გამოძახებამდე. ყველა ცვლილება უკან იხევს:

   // მკაცრი გარანტიის მაგალითი
   // Copy-and-Swap მეთოდის გამოყენებით გარანტიის უზრუნველყოფა
   class Resource {
       int* data;
       size_t size;
   public:
       Resource(size_t s) : size(s), data(new int[s]) {}
       ~Resource() { delete[] data; }
       Resource(const Resource& other) : size(other.size), data(new int[other.size]) {
           std::copy(other.data, other.data + size, data); // გამონაკლისი შეიძლება მოხდეს
       }
       Resource& operator=(Resource other) // ღირებულების გადაცემა კოპირებას იწვევს
       {
           swap(*this, other); // გამონაკლისი არ იწვევს
           return *this;
       }
       friend void swap(Resource& first, Resource& second) noexcept {
           using std::swap;
           swap(first.data, second.data);
           swap(first.size, second.size);
       }
       // ... სხვა წევრები
   };
   
   void strong_guarantee_function(Resource& res, size_t new_size) {
       Resource temp(new_size); // თუ აქ გამონაკლისი მოხდება, res არ შეიცვლება
       res = temp;               // გამოიყენება გადატვირთული ოპერატორი =, რომელიც უზრუნველყოფს მკაცრ გარანტიას
   }
   

3. გამონაკლისების არყოფნის გარანტია (No-throw guarantee): ფუნქცია აუცილებლად არ ნეტავს გამონაკლისს. ასეთი ფუნქციები აღნიშნულია noexcept-ით:

   // გამონაკლისების არყოფნის მაგალითი
   void no_throw_function() noexcept {
       // არ არსებობს ოპერაციები, რომლებიც შეიძლება გამოიწვიოს გამონაკლისი
       int a = 5;
       int b = 10;
       int c = a + b;
   }
   

4. წარუმატებლობის გარანტია (Failure guarantee): გამონაკლისების უსაფრთხოების კონტექსტში, ეს დონე ნიშნავს, რომ ფუნქცია შეიძლება დატოვოს პროგრამა არაზუსტი მდგომარეობაში, რესურსების გაჟონვა ან შეცდომები. ეს ფაქტობრივად გარანტიების არქონია. ასეთი ქცევა უნდა იქნას თავიდან აცილებული:

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

შედარებითი სია გარანტიების:

გარანტია	მდგომარეობა გამონაკლისის დროს	მონაცემთა მთლიანობა	რესურსების გაჟონვა
ძირითადი	ვალიდური, მაგრამ უცნობი	გარანტირებული არა	არა
მკაცრი	არ იცვლება (როგორც ადრე)	ინახება	არა
გამონაკლისების არყოფნა	არასოდეს ხდება (არ არის გამონაკლისები)	N/A	N/A
წარუმატებლობის (არ არის)	უცნობი, შესაძლებელია დაზიანება ან შეცდომები	გარანტირებული არა	შესაძლებელია