Yazılım geliştirmede modeller: temsili model

Adanali

Active member
Yazılım geliştirmede modeller: temsili model


  1. Yazılım geliştirmede modeller: temsili model

Kalıplar, modern yazılım geliştirmede önemli bir soyutlamadır. İyi tanımlanmış terminoloji, açık belgeler sunar ve en iyisinden öğrenirler. Proxy modeli, Design Patterns: Elements of Reusable Object-Oriented Software kitabındaki yedi yapısal modelden biridir.







Rainer Grimm, uzun yıllardır yazılım mimarı, ekip lideri ve eğitim yöneticisi olarak çalışmaktadır. C++, Python ve Haskell programlama dilleri üzerine makaleler yazmaktan hoşlanır, aynı zamanda sık sık uzmanlık konferanslarında konuşmaktan da keyif alır. Modernes C++ blogunda yoğun bir şekilde C++ tutkusundan bahsediyor.













Proxy, başka bir nesneye erişimi kontrol eder ve orijinal nesneye erişmeden önce veya sonra ek işlemler gerçekleştirmenize olanak tanır.

Hangi deyim C++’ın karakteristiğidir? RAII (kaynak edinimi başlatmadır)! Ve RAII, proxy modelini uygulamaya yönelik C++ yöntemidir.

proxy modeli


amaç

  • Başka bir nesneye erişmek için yer tutucu sağlar

Ayrıca şöyle bilinir

kullanım durumu


  • Başka bir nesneye erişimi denetleme
    • Uzak Proxy (uzak hizmet için aracı görevi görür)
    • Sanal proxy (istek üzerine nesne oluşturun)
    • Güvenlik proxy’si (bir isteği güvenlik özniteliklerini içerecek şekilde genişletir)
    • Önbelleğe alma proxy’si (önbelleğe alınmış istekleri iletir)
çerçeve









Proxy

  • Erişimi ve dosya süresini kontrol edin RealSubject
  • RealSubject ile aynı arayüzü destekler
Subject

  • arasındaki arayüzü tanımlar. Proxy ve RealSubject
RealSubject

  • Arayüzü uygula
misal


Aşağıdaki örnekler iki jenerik proxy kullanır: std::unique_ptr Ve std::shared_ptr.


// proxy.cpp

#include <iostream>
#include <memory>

class MyInt{
public:
MyInt(int i):i_(i){}
int getValue() const {
return i_;
}
private:
int i_;
};

int main(){

std::cout << 'n';

MyInt* myInt = new MyInt(1998); // (3)
std::cout << "myInt->getValue(): "
<< myInt->getValue() << 'n';

std::unique_ptr<MyInt> uniquePtr{new MyInt(1998)}; // (1)
std::cout << "uniquePtr->getValue(): "
<< uniquePtr->getValue() << 'n';

std::shared_ptr<MyInt> sharedPtr{new MyInt(1998)}; // (2)
std::cout << "sharedPtr->getValue(): "
<< sharedPtr->getValue() << 'n';

std::cout << 'n';

}


Her iki akıllı işaretçi de şeffaf bir şekilde üye işlevlerine işaret edebilir getValue itibaren MyInt erişim. Üye işlevini çağırmanız fark etmez getValue üzerinde std::unique_ptr (1), yaklaşık std::shared_ptr (2) veya doğrudan konu satırından arayın. Tüm çağrılar aynı değeri döndürür.

bilinen kullanımlar

Akıllı işaretçiler proxy modelini C++’da modeller. Ayrıca RAII deyimi, joker karakter modelinin C++ uyarlamasıdır. RAII, C++’da en sık kullanılan deyimdir. Birkaç satırda daha fazlasını yazacağım.

İlgili modeller

  • Adapter modeli mevcut bir arabirimi uyarlarken, Facade modeli yeni, basitleştirilmiş bir arabirim oluşturur.
  • Dekoratör modeli yapısal olarak delege ile benzerdir, ancak dekoratörün amacı farklıdır. Bir dekoratör, bir nesneyi ek etkinliklerle genişletir. Proxy, bir nesneye erişimi kontrol eder.
  • Cephe, bir nesneye erişimi kapsaması açısından bir temsilciye benzer. Cephe, yardımcı ile aynı arayüzü desteklemiyor, ancak basitleştirildi.
Avantajlar ve dezavantajlar


faydalar

  • Altta yatan nesne, istemci için tamamen şeffaftır,
  • temsilci, istemciyi kullanmadan isteklere doğrudan yanıt verebilir.
  • delegasyon şeffaf bir şekilde genişletilebilir veya başka bir delegasyon ile değiştirilebilir.
Dezavantajları

  • Proxy ve nesneyi ayırmak kodlamayı zorlaştırır
  • Proxy ile yönlendirilen aramaların performans üzerinde olumsuz bir etkisi olabilir
RAI dili


RAII, Resource Acquisition Is Initialization’ın kısaltmasıdır. Muhtemelen C++’daki en önemli deyim, yapıcıda bir kaynağın alınması ve nesnenin yıkıcısında serbest bırakılması gerektiğini söyler. Ana fikir, nesne kapsam dışına çıktığında yıkıcının otomatik olarak çağrılmasıdır. Başka bir deyişle, bir kaynağın ömrü, yerel bir değişkenin ömrüne bağlıdır ve C++, yerel değişkenlerin ömrünü otomatik olarak işler.

C++’daki joker karakter deseni ile RAII deyimi arasında büyük bir fark vardır. Klasik proxy modelinde, proxy ve nesne aynı arayüzü uygular. Bu nedenle, proxy’nin bir üye işlevi çağrılır ve bu çağrı nesneye atanır. Tersine, nesne üzerindeki işlemin dolaylı olarak gerçekleştirilmesi RAII için tipiktir.

Aşağıdaki örnek, RAII’nin C++’daki deterministik davranışını gösterir.


// raii.cpp

#include <iostream>
#include <new>
#include <string>

class ResourceGuard{
private:
const std::string resource;
public:
ResourceGuard(const std::string& res):resource(res){
std::cout << "Acquire the " << resource << "." << 'n';
}
~ResourceGuard(){
std::cout << "Release the "<< resource << "." << 'n';
}
};

int main() { // (2)

std::cout << 'n';

ResourceGuard resGuard1{"memoryBlock1"}; // (1)

std::cout << "nBefore local scope" << 'n';
{
ResourceGuard resGuard2{"memoryBlock2"}; // (3)
} // (4)
std::cout << "After local scope" << 'n';

std::cout << 'n';

std::cout << "nBefore try-catch block" << 'n';
try{
ResourceGuard resGuard3{"memoryBlock3"};
throw std::bad_alloc(); // (5)
}
catch (std::bad_alloc& e){ // (6)
std::cout << e.what();
}
std::cout << "nAfter try-catch block" << 'n';

std::cout << 'n';

}


ResourceGuard kaynağını yöneten bir bekçidir. Bu durumda, dize kaynağı temsil eder. ResourceGuard kaynağı yapıcısında oluşturur ve yıkıcısında serbest bırakır. İşini çok güvenilir bir şekilde yapıyor.

Yok edici resGuard1 (1) sonunda olacak main– (2) Arama işlevi. ömrü resGuard2 (3) zaten (4) ile bitiyor. Bu nedenle, yıkıcı otomatik olarak çalışır. Bir istisna atmak bile güvenilirliğini etkilemez. resGuard3 (5). Yıkıcı dosyanın sonunda kullanılır try-Bloklar (6. sıra) denir.

Ekran görüntüsü, öğelerin yaşamlarını gösterir.








RAII deyim yuvası sayesinde oldukça kolay ResourceGuard içinde LockGuard gidip.


class LockGuard{
private:
static inline std::mutex m;
public:
LockGuard() {
m.lock();
}
~LockGuard() {
m.unlock();
}
};


Tüm örnekleri LockGuard aynı mutex’i paylaşmak m. Bir örnek kapsam dışına çıktığında, otomatik olarak muteksinden vazgeçer m Bedava.

RAII deyiminin C++’daki en önemli deyim olduğunu belirtmiştim. Kanıt olarak, öne çıkan birkaç örneği sıralayacağım:

RAII uygulamaları

  • STL kabı dahil std::string: Yapıcılarında otomatik olarak bellek ayırırlar ve ayrıca onu yıkıcılarında otomatik olarak serbest bırakırlar.
  • akıllı işaretçiler: std::unqiue_ptr Ve std::shared_ptr alttaki ham işaretçiyi işleyin; artık gerekmediğinde temeldeki ham işaretçi belleğini otomatik olarak boşaltırlar.
  • kilitler: std::lock_guard, std::unique_lock, std::shared_lock Ve std::scoped_lock temeldeki muteksi yapıcısında kilitle ve yıkıcısında otomatik olarak kilidini aç
  • std::jthread: std::jthread C++20’de geliştirildi std::thread C++11’den; std::jthread aramalar otomatik olarak join gerekirse yıkıcısında
Sıradaki ne?


Bir sonraki yazımda, Design Patterns: Elements of Reusable Object-Oriented Software kitabındaki kalıplar üzerinden yolculuğuma devam edeceğim Observer kalıbı, her profesyonel programcının araç kutusunda olması gereken bir davranış kalıbıdır.


(rm)



Haberin Sonu
 
Üst