რა ჭკვიანი მაჩვენებლები არსებობს C++-ში?

std::unique_ptr, std::shared_ptr, std::weak_ptr.

• std::unique_ptr:

  • ობიექტის ექსკლუზიური მფლობელობა.
  • ვერ შეიძლება იყოს კოპირებული, მაგრამ შეიძლება გადატანილი იყოს (std::move).
  • ავტომატურად წაშლის ობიექტს გამოყოფის დროს ან unique_ptr განადგურებისას.
  • მსუბუქია, არ აქვს დამატებითი ხარჯები რეფერენცის გამთვლელზე.

  #include <memory>
  
  // `unique_ptr` შექმნა
  std::unique_ptr<int> up1(new int(10));
  
  // მფლობელობის გადატანა
  std::unique_ptr<int> up2 = std::move(up1);
  
  // up1 ახლა nullptr
  // up2 ფლობს ობიექტს
  

• std::shared_ptr:

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

  #include <memory>
  
  // `shared_ptr` შექმნა
  std::shared_ptr<int> sp1 = std::make_shared<int>(20);
  
  // მფლობელობის კოპირება
  std::shared_ptr<int> sp2 = sp1; // გამთვლელი მატულობს
  
  // sp1 და sp2 ფლობენ ობიექტს
  

• std::weak_ptr:

  • ობიექტის მფლობელი არ არის.
  • წარმოადგენს "სუსტი" მითითებას ობიექტზე, რომელსაც მართავს ერთ ან რამდენიმე shared_ptr.
  • გამოიყენება ციკლური მითითებების თავიდან ასაცილებლად.
  • არ ზრდის მითითების გამთვლელს.
  • უსაფრთხო წვდომისთვის საჭიროა გარდაქმნა shared_ptr-ში lock() მეთოდით. თუ ობიექტი უკვე წაშლილია, lock() დაბრუნებს ცარიელ shared_ptr-ს.

  #include <memory>
  
  // `shared_ptr` შექმნა
  std::shared_ptr<int> sp = std::make_shared<int>(30);
  
  // `weak_ptr` შექმნა `shared_ptr`-დან
  std::weak_ptr<int> wp = sp;
  
  // შემოწმება და გამოყენება
  if (auto shared_from_weak = wp.lock()) {
      // წვდომა ობიექტზე
  } else {
      // ობიექტი უკვე წაშლილია
  }