2. 程式人生 > >C++11之如何實現控制反轉

C++11之如何實現控制反轉

阿新 • • 發佈：2019-02-09

一個小例子
我們先寫一個不使用控制反轉的小例子：

#include <iostream>

using namespace std;

struct A{
    virtual void func(){}
    virtual ~A(){}
};

struct B: public A{
    func(){cout << "B" << endl;}
};

struct C:public A{
    func(){cout << "C" << endl;}
}

class D{
public:
    D(A* a):m_a(a){}

    void
 
 func(){m_a->func();}

    ~D(){
        if (m_a != nullptr)
        {
               delete m_a;
               m_a = nullptr;
        }
    }

private:
    A* m_a;
};

int _tmain(int argc, _TCHAR* argv[])
{
    D* active = nullptr;
    if (condtionB)
    {
        active = new D(new B());
    } 
    else
 

    {
        active = new D(new C());
    }
    delete active;
    return 0;
}

從上面的例子中可以看到D物件和A物件之間的耦合性就產生了。當A物件派生多個子類時，建立D物件時就不得不多加一個條件的判斷，這嚴重影響了程式碼的擴充套件性。也違背了“開放-封閉”的原則。耦合性產生的原因在於D物件的建立直接依賴於new外部物件，也叫做“硬編碼”，是的二者關係緊耦合，失去了靈活性。一種解決辦法是通過工廠模式來建立物件。

struct Factory{
    static A * Create(const string & condition)
    {

        if
 
 (conditionB)
        {
            return new B();
        } 
        else
        {
            return new C();
        }
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    string condition = "B"
    D* active = new A(Factory::Create(condition))
    active->func();
    delete active;
    return 0;
}

這樣改進是不是感覺，以後A增加派生類只需要修改Factory的程式碼就可以了，而不是每次new 的時候都要寫好多判斷語句。但是這個方法還是沒有徹底將兩個物件之間的關係解耦。
要想徹底將兩個物件解耦就要引入一種機制，讓A物件不再直接依賴於外部物件的建立，而是以來某種機制，這種機制可以讓物件之間的關係在外面組裝，外界可以根據需求靈活的配置這種機制對的物件建立策略，而這種機制就是控制反轉（Ioc）。

控制反轉

控制反轉就是應用本身不負責依賴物件的建立和維護，而是交給外部容器來負責。這樣控制權就應由應用賺到了外部的Ioc.從而實現控制反轉。Ioc用來降低物件之間直接依賴產生的耦合性。
從上面的例子中，我們可以看到直接依賴會產生耦合性。

```
void IocSample{
    IocContainer ioc;
    ioc.RegisterType<D,A>("B");
    ioc.RegisterType<D,A>("C");
    //由Ioc容器去初始化D物件
    D* active = ioc.Resolve<D>("B");
    active->func();
    delete active;
};

從上面的例子中，我們通過Ioc配置了D和A物件的關係，然後由Ioc容器去建立A物件，這裡A物件的建立不再依賴於工廠或者A物件，徹底解耦了而知之間的關係。

Ioc讓我們在建立物件上獲得了最大的靈活性，大大降低了依賴物件建立時的耦合性，及時需求變化了，也只需要修改配置檔案就可以建立想要的物件，而不是需要修改程式碼了。通過依賴注入（DI）將建立物件的依賴關係注入到目標型別的建構函式中。就像上面的例子將A依賴於B的依賴關係注入到A型別的建構函式中。

Ioc有兩種能力，一種是物件工廠的能力，不僅可以建立所有的物件，還能根據配置去建立物件；另一種能力是可以去建立依賴物件，應用部需要直接建立以來物件，由Ioc容器去建立實現控制反轉。

簡單Ioc的實現

void IocSample{
    IocContainer ioc;
    ioc.RegisterType<D,A>("B");
    ioc.RegisterType<D,A>("C");
    //由Ioc容器去初始化D物件
    D* active = ioc.Resolve<D>("B");
    active->func();
    delete active;
};

#include <string>
#include <map>
#include <memory>
#include <functional>
using namespace std;

template <class T>
class IocContainer{
public:
    IocContainer(){}
    ~IocContainer(){}

    //註冊需要建立物件的建構函式，需要傳入一個唯一的標識
    template<class Drived>
    void RegisterType(string key){
        std::function<T* ()> function = []{return new Drived();};//lambda表示式
        RegisterType(key, function);
    }

    //根據唯一的標識去查詢對應的構造器，並建立指標物件
    T* Resolve(string key){
        if (m_creator.find(key) == m_creatoe.end())
        {
            return nullptr;
        }
        std::function<T*()> function = m_creator[key];
        return function;
    }
    std::shared_ptr<T> ResolveShared(string key){
        T* ptr = Resolve(key);
        return std::shared_ptr<T>(ptr);
    }

private:
    void RegisterType(string key, std::function<T*()> creator){
        if(m_creator.find(key) != m_creator.end){
            throw std::invalid_argument("this key has already exist!");
        }
        m_creator.emplace(key,creator);
    }
    map<string,std::function<T*()>> m_creator;
};

測試一下

int _tmain(int argc, _TCHAR* argv[])
{
    IocContainer<A> ioc;
    ioc.RegisterType<A>("B");
    ioc.RegisterType<A>("C");

    std::function<A*()> deriveB = ioc.ResolveShared("B");
    deriveB->func();

    std::function<A*()> deriveC = ioc.ResolveShared("C");
    deriveC->func();
    return 0;
}

Result：
B
C

相信大家也注意到一個問題，上面的例子只能建立無參物件，還有一個問題就是隻能建立一種介面型別的物件，不能建立所有型別的物件。下面我們來看看怎麼解決這倆個問題。

Note:型別擦除常用的方法
1）通過多臺來擦除型別
2）通過模板來擦除型別
3）通過某種型別容器來擦除型別
4)通過通用型別來擦除型別
5）通過閉包來擦除型別

感興趣的同學可以看

#include <string>
#include <unorderd_map>
#include <memory>
#include <functional>
using namespace std;
#include <Any.cpp>

struct Car{
    void test ()const{cout << "car" << endl;}

};

struct Bus{
    void test ()const{cout << "bus" << endl;}

};

class IocContainer{
public:
    IocContainer(){}
    ~IocContainer(){}

    //註冊需要建立物件的建構函式，需要傳入一個唯一的標識
    template<class T, typename Depend>
    void RegisterType(const string & key){
        //通過閉包擦除型別
        std::function<T* ()> function = []{return new T(new Depend());};//lambda表示式
        RegisterType(key, function);
    }

    template<class T>
    //根據唯一的標識去查詢對應的構造器，並建立指標物件
    T* Resolve(const string& key){
        if (m_creator.find(key) == m_creatoe.end())
        {
            return nullptr;
        }
        Any resolver = m_creator[key];
        //將找到的any轉化為function
        std::function<T*()> function = resolver.AnyCast<std::function<T*()>>;
        return function;
    }
    template<class T>
    std::shared_ptr<T> ResolveShared(string key){
        T* ptr = Resolve<T>(key);
        return std::shared_ptr<T>(ptr);
    }

private:
    void RegisterType(const string& key, Any creator){
        if(m_creator.find(key) != m_creator.end){
            throw std::invalid_argument("this key has already exist!");
        }
        m_creator.emplace(key,creator);
    }
    unorded_map<string,Any> m_creator;
};

struct A{
    virtual void func(){}
    virtual ~A(){}
};

struct B: public A{
    func(){cout << "B" << endl;}
};

struct C:public A{
    func(){cout << "C" << endl;}
}

class D{
public:
    D(A* a):m_a(a){}

    void func(){m_a->func();}

    ~D(){
        if (m_a != nullptr)
        {
            delete m_a;
            m_a = nullptr;
        }
    }

private:
    A* m_a;
};

int _tmain(int argc, _TCHAR* argv[])
{
    IocContainer ioc;
    //配置依賴關係
    ioc.RegisterType<D,B>("B");
    ioc.RegisterType<D,C >("C");

    auto deriveB = ioc.ResolveShared<D>("B");
    deriveB->func();

    auto deriveC = ioc.ResolveShared<D>("C");
    deriveC->func();

    ioc.RegisterType<Car>("car");
    ioc.RegisterType<Bus>("bus");

    auto bus = ioc.ResolveShared<Bus>("bus");
    bus->test();

    auto car = ioc.ResolveShared<Car>("car");
    car->test();

    return 0;
}：

Result:
B
C
bus
car

我們在最開始的第一個例子上添加了兩個類。然後測試。

建立依賴的物件

配置依賴關係來建立物件

ioc.RegisterType<D,B>("B");
ioc.RegisterType<D,C >("C");

但是這種方法不太靈活，一旦建立無法修改。所以還有另外一種方法。

配置引數來建立物件

auto B= ioc.ResolveShared<A>("B");
B->func();

以上說的都是Ioc很基礎也較好理解的一些例子，還有一個更好的例子。能適應多種情況的Ioc的容器的實現。大家可以參考《C++深入應用》P275。

相關推薦

C++11之如何實現控制反轉

一個小例子 我們先寫一個不使用控制反轉的小例子： #include <iostream> using namespace std; struct A{ virtual void func(){} virtual ~A(){

C#依賴註入控制反轉IOC實現詳解

section 直接 pub xmlns 軟件 image 方法 問題： some 原文:C#依賴註入控制反轉IOC實現詳解IOC的基本概念是：不創建對象，但是描述創建它們的方式。在代碼中不直接與對象和服務連接，但在配置文件中描述哪一個組件需要哪一項服務。容器負責將這些聯系

C++11之AOP實現

AOP 相信大家對面向物件程式設計一定都熟悉透了。面向物件程式設計的繼承是一種從上而下的關係，不適合從左到右的橫向關係，試想一下如果很多無關聯的物件有公共的行為，這些公共的行為可能分散在不同元件和不同物件中，通過繼承實現一定是很不好的。那應該怎麼實現呢？對滴，

C++11之decltype

family 有變 con mod decltype space word div c++11 使用場景 在C++中常常要用到非常長的變量名。假設已經有變量和你將使用的變量是一個類型。就可以使用decltypekeyword 來申明

.NET之IOC控制反轉運用

string 標準 需要 對象 ati ext [] 根據 mar 當前場景： 如果有不同的用戶。使用同一個系統。而不同的客戶有某些不同的需求。在不改變系統主體的情況下，可以直接使用IOC控制反轉依賴搭建項目 1.添加接口層 目前裏面只有一個會員的類。裏面有一個登錄接口

C#基礎之流程控制語句詳解

集合 必須 清晰 循環 remove 很難 使用 fault code C#程序的執行都是一行接一行、自上而下地進行，不遺漏任何代碼。為了讓程序能按照開發者所設計的流程進行執行，必然需要進行條件判斷、循環和跳轉等過程，這就需要實現流程控制。C#中的流程控制包含了條件語句、循

C++11之右值引用與移動構造

添加 oooo 返回對象 oat 值引用 apc 定義 tco pri ----------------------------右值引用--------------------------------- 右值定義： 　　通俗來講，賦值號左邊的就是左值，賦值號右邊的就

C++11之智能指針

周期 智能指針 文件的 指向 delet 多個 構造 循環引用 出現 1、關於智能指針的理解 　　1）智能指針是使用RAII技術（資源的獲取即初始化）對普通指針進行封裝得到的，其實質是一個指針，使用起來像指針。 　　2）智能指針可以用來解決程序員忘記使用delete釋放內存

Spring詳解篇之IoC控制反轉

###一.Spring概況 spring是一個開源框架 是一個輕量的控制反轉和麵向切面的容器框架 大小和開銷都是輕量的。 通過控制反轉技術可以達到鬆耦合的目的 切面程式設計，允許通過分離應用的業務邏輯。 包含並管理應用物件的配置和生命週期，是一個容器，並且能夠組

2.Spring學習筆記之 ————IoC(控制反轉)

控制反轉（IoC），是Spring裡一個專有的名詞，其意思就是說，物件的例項由Spring容器來進行建立而不是我們自己手動建立，當我們在Spring容器中設定好Bean屬性後，Spring容器就會自動建立其例項，我們只要去呼叫Spring的Bean就行。 接下來是例子：

C++11之for迴圈

簡單使用： 輸出每個元素： string s = "biu biu biu"; for(auto i : s) { cout<<i<<endl; } 順帶

基於C++11 thread 實現執行緒池

轉自：https://blog.csdn.net/u013507368/article/details/48130151 這裡基於C++11 thread實現執行緒池，執行緒池不可拷貝。   1 nocopyable類     不可拷貝基類繼承

C++11之initialization_list

 轉自http://blog.csdn.net/hailong0715/article/details/54018002 在我們實際程式設計中，我們經常會碰到變數初始化的問題，對於不同的變數初始化的手段多種多樣，比如說對於一個數組我們可以使用 int arr[] = {1,2,

C++11之for迴圈的新用法 for（：）語句

轉載自：https://www.cnblogs.com/jiayayao/p/6138974.html   C++使用如下方法遍歷一個容器： #include "stdafx.h" #include<iostream> #include<vector>

c++11之初始化列表

一、前言     C++的學習中，我想每個人都被變數定義和申明折磨過，比如我在大學筆試過的幾家公司，都考察了const和變數，型別的不同排列組合，讓你區別有啥不同。反正在學習C++過程中已經被折磨慣了，今天再來看看重溫下那段“輝煌的歷史”。先來看一段程式碼： Playe

C++ 11之 && 右值引用

最近在看cocos2dx的原始碼，發現了一個模板類有一個奇怪的語法&&： inline RefPtr(RefPtr<T> && other) {

C語言來實現字串反轉(只有單詞反轉，單詞裡的字母不反轉)

用C/C++來實現字串的反轉。比如：字串”I am a good developer!”反轉之後變成了”developer! Good a am I”。（只有單詞反轉，單詞裡的字母不反轉） 用c語言來搞先到字串末尾然後挨個掃描碰到非空格wordLen++否則先處理wordLe

C語言之實現隨機數產生演算法

隨機數，也就是在不同的時刻產生不同的數值。在UNIX作業系統和window的作業系統上，我們知道有一個函式rand，它就是用來產生隨機數的函式API介面，那麼它的原理如何實現？ 如果約定a1=f(se

C++11之std::function和std::bind

std::function是可呼叫物件的包裝器，它最重要的功能是實現延時呼叫： #include "stdafx.h" #include<iostream>// std::cout #include<functional>// std::fu

c++11之move和forward

　　stout中大量使用了c++11的特性，而c++11中move和forward大概是最神奇的特性了. 左值和右值的區別 int a = 0; // a是左值，0是右值 int b = rand(); // b是左值，rand()是右值 　　直觀理解：左值在等