Stack Sık sık kod daha güvenilir hale ve kod daha fazla ölçülebilir hale getirmek için yığın onları ayırmak (ve bad_alloc önlemek için) RAII tarzı nesneleri kullanmak C++ DI ilkesine

Question

vs RAII nesneleri tahsis etti.

Ancak yığın üzerinde bir beton sınıfı nesnesi oluşturmak, bağımlılık ters çevirme (DI) ilkesini ihlal eder ve bu nesnenin alay edilmesini önler.

Aşağıdaki kodu düşünün: Ben IBar::process test edebilirsiniz

struct IInputStream 
{ 
    virtual vector<BYTE> read(size_t n) = 0; 
}; 

class Connection : public IInputStream 
{ 
public: 
    Connection(string address); 
    virtual vector<BYTE> read(size_t n) override; 
}; 

struct IBar 
{ 
    virtual void process(IInputStream& stream) = 0; 
}; 

void Some::foo(string address, IBar& bar) 
{ 
    onBeforeConnectionCreated(); 
    { 
     Connection conn(address); 
     onConnectionCreated(); 
     bar.process(conn); 
    } 
    onConnectionClosed(); 
} 

, ama aynı zamanda gerçek Bağlantı nesnesi oluşturmadan, Some::foo test etmek istiyorum.

Elbette bir fabrika kullanabilirim, ancak kodu önemli ölçüde karmaşıklaştıracak ve yığın ayırmayı başlatacaktır.
Ayrıca, Connection::open yöntemini eklemek istemiyorum, tamamen başlatılmış ve tamamen işlevsel nesneler oluşturmayı tercih ediyorum.

Ben Some için Connection türü bir şablon parametresi yapmak (ya foo için eğer bir serbest fonksiyonu olarak bunu ayıklamak), ama doğru yolu (şablonlar birçok kişiye bir kara büyü gibi görünür, bu yüzden olduğundan emin değilim ediyorum) dinamik polimorfizm kullanmayı tercih

Answer 1

Şimdi ne doğru yapıyorsun "kuvvet-kavrama" RAII sınıfı ve test edilebilir bir istiyorum, gerçekten yerine bir arayüz olmalıdır servis sağlayıcı sınıfı() 'dir.

Örneğin o

üstünde de ray sağlayan ayrı bir ScopedConnection sınıf var IConnection içine Connection abstracting

1. : Bu Adres By

   void Some::foo(string address, IBar& bar) 
   { 
       onBeforeConnectionCreated(); 
       { 
        ScopedConnection conn(this->pFactory->getConnection()); 
        onConnectionCreated(); 
        bar.process(conn); 
       } 
       onConnectionClosed(); 
   } 
   

Answer 2

"Ben kullanabilirsiniz bir fabrika, ancak kodları karmaşık bir şekilde karmaşıklaştıracak ve yığın ayırma işlemini başlatacaktır "Aşağıdaki adımları kastediyorum:

unique_ptr<AConnection> conn(createConnection(address)); 

Answer 3

gerçek arasında seçim için akıllı pointer yığın-tahsis connectonu değiştirin soyut sınıf oluşturun ve

struct AConnection : IInputStream 
{ 
    virtual ~AConnection() {} 
}; 

Add fabrika yöntemi ile Some

class Some 
{ 
..... 
protected: 
    VIRTUAL_UNDER_TEST AConnection* createConnection(string address); 
}; 

den Connection türetmek uygulama ve alay edilen, gerçek ty enjekte Bir şekilde inşa etmek istediğin pe. Tavsiye ettiğim yol, türü isteğe bağlı bir şablon parametresi olarak enjekte etmektir. Alışılagelmiş bir şekilde Some::foo'u alışkın olarak kullanmanıza izin verir, ancak bir test durumunda oluşturulan bağlantıyı değiştirmenizi sağlar. Derleme zamanında asıl türünü biliyorsanız

template<typename ConnectionT=Connection> // models InputStream 
void Some::foo(string address, IBar& bar) 
{ 
    onBeforeConnectionCreated(); 
    { 
     ConnectionT conn(address); 
     onConnectionCreated(); 
     bar.process(conn); 
    } 
    onConnectionClosed(); 
} 

Bir fabrika ve çalışma zamanı polimorfizm masraflı olmaz.