2. 程式人生 > >C++狀態模式詳解--設計模式（15）

C++狀態模式詳解--設計模式（15）

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

State模式來源： 

 每個人、事物在不同的狀態下會有不同表現（動作），而一個狀態又會在不同的表現下轉移到下一個不同的狀態（State）。最簡單的一個生活中的例子就是：地鐵入口處，如果你放入正確的地鐵票，門就會開啟讓你通過。在出口處也是驗票，如果正確你就可以ok，否則就不讓你通過（如果你動作野蠻，或許會有報警（Alarm））。
      有限狀態自動機（FSM）也是一個典型的狀態不同，對輸入有不同的響應（狀態轉移）。通常我們在實現這類系統會使用到很多的Switch/Case語句，Case某種狀態，發生什麼動作，Case另外一種狀態，則發生另外一種狀態。但是這種實現方式至少有以下兩個問題：
      (1).當狀態數目不是很多的時候，Switch/Case可能可以搞定。但是當狀態數目很多的時候（實際系統中也正是如此），維護一大組的Switch/Case語句將是一件異常困難並且容易出錯的事情。

      (2).狀態邏輯和動作實現沒有分離。在很多的系統實現中，動作的實現程式碼直接寫在狀態的邏輯當中。這帶來的後果就是系統的擴充套件性和維護得不到保證。

State模式作用：

 State模式就是被用來解決上面列出的兩個問題的，在State模式中我們將狀態邏輯和動作實現進行分離。當一個操作中要維護大量的case分支語句，並且這些分支依賴於物件的狀態。State模式將每一個分支都封裝到獨立的類中。

State模式UML結構圖如圖1所示：

                     

State模式的構成：

State類：抽象狀態類，定義一個介面以封裝與Context的一個特定狀態相關的行為。

ConcreteState類：具體狀態，每一個子類實現一個與Context的一個狀態相關的行為。

Context類：維護一個ConcreteState子類的例項，這個例項定義當前的狀態。

State模式的程式碼示例：

State.h

#ifndef _STATE_H_
#define _STATE_H_

class Context;
class State
{
public:
    virtual void Handle(Context* pContext)=0;
    ~State();
protected:
    State();
private:
};

class ConcreteStateA : public State
{
public:
    ConcreteStateA();
    ~ConcreteStateA();
    virtual void Handle(Context* pContext);
protected:
private:
};

class ConcreteStateB : public State
{
public:
    ConcreteStateB();
    ~ConcreteStateB();
    virtual void Handle(Context* pContext);
protected:
private:
};

class ConcreteStateC : public State
{
public:
    ConcreteStateC();
    ~ConcreteStateC();
    virtual void Handle(Context* pContext);
protected:
private:
};

class Context
{
public:
    Context(State* pState);
    ~Context();
    void Request();
    void ChangeState(State* pState);
protected:
private:
    State* _state;
};

#endif

State.cpp

#include "State.h"
#include <iostream>
using namespace std;
State::State()
{}
State::~State()
{}
ConcreteStateA::ConcreteStateA()
{}
ConcreteStateA::~ConcreteStateA()
{}
//執行該狀態的行為並改變狀態
void ConcreteStateA::Handle(Context* pContext)
{
    cout << "ConcreteStateA" << endl;
    pContext->ChangeState(new ConcreteStateB());
}
ConcreteStateB::ConcreteStateB()
{}
ConcreteStateB::~ConcreteStateB()
{}
//執行該狀態的行為並改變狀態
void ConcreteStateB::Handle(Context* pContext)
{
    cout << "ConcreteStateB" << endl;
    pContext->ChangeState(new ConcreteStateC());
}
ConcreteStateC::ConcreteStateC()
{}
ConcreteStateC::~ConcreteStateC()
{}
//執行該狀態的行為並改變狀態
void ConcreteStateC::Handle(Context* pContext)
{
    cout << "ConcreteStateC" << endl;
    pContext->ChangeState(new ConcreteStateA());
}

//定義_state的初始狀態
Context::Context(State* pState)
{
    this->_state = pState;
}
Context::~Context()
{}
//對請求做處理，並設定下一狀態
void Context::Request()
{
    if(NULL != this->_state)
    {
        this->_state->Handle(this);
    }
}
//改變狀態
void Context::ChangeState(State* pState)
{
    this->_state = pState;
}
Main.cpp
#include "State.h"

int main()
{
    State* pState = new ConcreteStateA();
    Context* pContext = new Context(pState);
    pContext->Request();
    pContext->Request();
    pContext->Request();
    pContext->Request();
    pContext->Request();
    return 0;
}

State模式使用場景：

State模式的應用也非常廣泛，從最高層邏輯使用者介面GUI到最底層的通訊協議（例如利用State模式模擬實現一個TCP連線的類。）都有其用武之地。

        State模式和Strategy模式又很大程度上的相似：它們都有一個Context類，都是通過委託（組合）給一個具有多個派生類的多型基類實現Context的演算法邏輯。兩者最大的差別就是State模式中派生類持有指向Context物件的引用，並通過這個引用呼叫Context中的方法，但在Strategy模式中就沒有這種情況。因此可以說一個State例項同樣是Strategy模式的一個例項，反之卻不成立。實際上State模式和Strategy模式的區別還在於它們所關注的點不盡相同：State模式主要是要適應物件對於狀態改變時的不同處理策略的實現，而Strategy則主要是具體演算法和實現介面的解耦（coupling），Strategy模式中並沒有狀態的概念（雖然很多時候有可以被看作是狀態的概念），並且更加不關心狀態的改變了。
       State模式很好地實現了物件的狀態邏輯和動作實現的分離，狀態邏輯分佈在State的派生類中實現，而動作實現則可以放在Context類中實現（這也是為什麼State派生類需要擁有一個指向Context的指標）。這使得兩者的變化相互獨立，改變State的狀態邏輯可以很容易複用Context的動作，也可以在不影響State派生類的前提下建立Context的子類來更改或替換動作實現。

State模式經典示例：

       允許一個物件在其內部狀態改變時改變它的行為。物件看起來似乎修改了它的類。

1->main()，客戶

2->CLiftState，電梯狀態抽象類

3->CCloseingState，電梯門關閉

4->COpenningState，電梯門開啟

5->CRunningState，電梯執行

6->CStoppingState，電梯停止

7->CContext，電梯的控制面板

       說明：CContext保持電梯的狀態，並提供操作的介面函式。當函式被呼叫時，CContext直接呼叫當前狀態的相應函式。由狀態的介面函式來確定是否可以執行這個動作，以及修改狀態為執行這個動作後的狀態。

       看程式碼：第一塊是不使用模式的做法，第二塊是使用模式的做法，在main()函式裡會有呼叫的方式。

<span style="font-size:14px;"><span style="font-size:14px;">//ILift.h
#pragma once
class ILift
{
public:

    ILift(void)
    {
    }

    virtual ~ILift(void)
    {
    }
    static const int OPENING_STATE = 1;
    static const int CLOSING_STATE = 2;
    static const int RUNNING_STATE = 3;
    static const int STOPPING_STATE = 4;
    virtual void SetState(int state) = 0;
    virtual void Open() = 0;
    virtual void Close() = 0;
    virtual void Run() = 0;
    virtual void Stop() = 0;
};

//Lift.h
#pragma once
#include "ilift.h"
class CLift :
    public ILift
{
public:
    CLift(void);
    ~CLift(void);
    void SetState(int state);
    void Open();
    void Close();
    void Run();
    void Stop();
private:
    int m_state;
    void OpenWithoutLogic();
    void CloseWithoutLogic();
    void RunWithoutLogic();
    void StopWithoutLogic();
};

//Lift.cpp
#include "StdAfx.h"
#include "Lift.h"
#include <iostream>
using std::cout;
using std::endl;

CLift::CLift(void)
{
    this->m_state = 0;
}

CLift::~CLift(void)
{
}

void CLift::SetState(int state)
{
    this->m_state = state;
}

void CLift::Open()
{
    switch(this->m_state)
    {
    case OPENING_STATE:
        break;
    case CLOSING_STATE:
        this->OpenWithoutLogic();
        this->SetState(OPENING_STATE);
        break;
    case RUNNING_STATE:
        break;
    case STOPPING_STATE:
        this->OpenWithoutLogic();
        this->SetState(OPENING_STATE);
        break;
    }
}

void CLift::Close()
{
    switch(this->m_state)
    {
    case OPENING_STATE:
        this->CloseWithoutLogic();
        this->SetState(CLOSING_STATE);
        break;
    case CLOSING_STATE:
        break;
    case RUNNING_STATE:
        break;
    case STOPPING_STATE:
        break;
    }
}

void CLift::Run()
{
    switch(this->m_state)
    {
    case OPENING_STATE:
        break;
    case CLOSING_STATE:
        this->RunWithoutLogic();
        this->SetState(RUNNING_STATE);
        break;
    case RUNNING_STATE:
        break;
    case STOPPING_STATE:
        this->RunWithoutLogic();
        this->SetState(RUNNING_STATE);
        break;
    }
}

void CLift::Stop()
{
    switch(this->m_state)
    {
    case OPENING_STATE:
        break;
    case CLOSING_STATE:
        this->StopWithoutLogic();
        this->SetState(CLOSING_STATE);
        break;
    case RUNNING_STATE:
        this->StopWithoutLogic();
        this->SetState(CLOSING_STATE);
        break;
    case STOPPING_STATE:
        break;
    }
}

void CLift::OpenWithoutLogic()
{
    cout << "電梯門開啟..." << endl;
}

void CLift::CloseWithoutLogic()
{
    cout << "電梯門關閉..." << endl;
}

void CLift::RunWithoutLogic()
{
    cout << "電梯上下跑起來..." << endl;
}

void CLift::StopWithoutLogic()
{
    cout << "電梯停止了..." << endl;
}</span></span>
<span style="font-size:14px;"><span style="font-size:14px;">//LiftState.h
#pragma once
class CContext;
class CLiftState
{
public:
    CLiftState(void);
    virtual ~CLiftState(void);
    void SetContext(CContext *pContext);
    virtual void Open() = 0;
    virtual void Close() = 0;
    virtual void Run() = 0;
    virtual void Stop() = 0;
protected:
    CContext *m_pContext;
};

//LiftState.cpp
#include "StdAfx.h"
#include "LiftState.h"

CLiftState::CLiftState(void)
{
}

CLiftState::~CLiftState(void)
{
}

void CLiftState::SetContext( CContext *pContext )
{
    m_pContext = pContext;
}

//CloseingState.h
#pragma once
#include "liftstate.h"
class CCloseingState :
    public CLiftState
{
public:
    CCloseingState(void);
    ~CCloseingState(void);
    void Open();
    void Close();
    void Run();
    void Stop();
};

//CloseingState.cpp
#include "StdAfx.h"
#include "CloseingState.h"
#include "Context.h"
#include <iostream>
using std::cout;
using std::endl;

CCloseingState::CCloseingState(void)
{
}

CCloseingState::~CCloseingState(void)
{
}

void CCloseingState::Open()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pOpenningState);
    this->CLiftState::m_pContext->GetLiftState()->Open();
}

void CCloseingState::Close()
{
    cout << "電梯門關閉..." << endl;
}

void CCloseingState::Run()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pRunningState);
    this->CLiftState::m_pContext->GetLiftState()->Run();
}

void CCloseingState::Stop()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pStoppingState);
    this->CLiftState::m_pContext->GetLiftState()->Stop();
}

//OpenningState.h
#pragma once
#include "liftstate.h"
class COpenningState :
    public CLiftState
{
public:
    COpenningState(void);
    ~COpenningState(void);
    void Open();
    void Close();
    void Run();
    void Stop();
};

//OpenningState.cpp
#include "StdAfx.h"
#include "OpenningState.h"
#include "Context.h"
#include <iostream>
using std::cout;
using std::endl;

COpenningState::COpenningState(void)
{
}

COpenningState::~COpenningState(void)
{
}

void COpenningState::Open()
{
    cout << "電梯門開啟..." << endl;
}

void COpenningState::Close()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pCloseingState);
    this->CLiftState::m_pContext->GetLiftState()->Close();
}

void COpenningState::Run()
{
    //do nothing
}

void COpenningState::Stop()
{
    //do nothing
}

//RunningState.h
#pragma once
#include "liftstate.h"
class CRunningState :
    public CLiftState
{
public:
    CRunningState(void);
    ~CRunningState(void);
    void Open();
    void Close();
    void Run();
    void Stop();
};

//RunningState.cpp
#include "StdAfx.h"
#include "RunningState.h"
#include "Context.h"
#include <iostream>
using std::cout;
using std::endl;

CRunningState::CRunningState(void)
{
}

CRunningState::~CRunningState(void)
{
}

void CRunningState::Open()
{
    //do nothing
}

void CRunningState::Close()
{
    //do nothing
}

void CRunningState::Run()
{
    cout << "電梯上下跑..." << endl;
}

void CRunningState::Stop()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pStoppingState);
    this->CLiftState::m_pContext->GetLiftState()->Stop();
}

//StoppingState.h
#pragma once
#include "liftstate.h"
class CStoppingState :
    public CLiftState
{
public:
    CStoppingState(void);
    ~CStoppingState(void);
    void Open();
    void Close();
    void Run();
    void Stop();
};

//StoppingState.cpp
#include "StdAfx.h"
#include "StoppingState.h"
#include "Context.h"
#include <iostream>
using std::cout;
using std::endl;

CStoppingState::CStoppingState(void)
{
}

CStoppingState::~CStoppingState(void)
{
}

void CStoppingState::Open()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pOpenningState);
    this->CLiftState::m_pContext->GetLiftState()->Open();
}

void CStoppingState::Close()
{
    //do nothing
}

void CStoppingState::Run()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pRunningState);
    this->CLiftState::m_pContext->GetLiftState()->Run();
}

void CStoppingState::Stop()
{
    cout << "電梯停止了..." << endl;
}</span></span>
<span style="font-size:14px;"><span style="font-size:14px;">//Contex.h
#pragma once
#include "LiftState.h"
#include "OpenningState.h"
#include "CloseingState.h"
#include "RunningState.h"
#include "StoppingState.h"
class CContext
{
public:
    CContext(void);
    ~CContext(void);
    static COpenningState *pOpenningState;
    static CCloseingState *pCloseingState;
    static CRunningState *pRunningState;
    static CStoppingState *pStoppingState;
    CLiftState * GetLiftState();
    void SetLiftState(CLiftState *pLiftState);
    void Open();
    void Close();
    void Run();
    void Stop();
private:
    CLiftState *m_pLiftState;
};

//Context.cpp
#include "StdAfx.h"
#include "Context.h"
COpenningState* CContext::pOpenningState = NULL;
CCloseingState* CContext::pCloseingState = NULL;
CRunningState* CContext::pRunningState = NULL;
CStoppingState* CContext::pStoppingState = NULL;

CContext::CContext(void)
{
    m_pLiftState = NULL;
    pOpenningState = new COpenningState();
    pCloseingState = new CCloseingState();
    pRunningState = new CRunningState();
    pStoppingState = new CStoppingState();
}

CContext::~CContext(void)
{
    delete pOpenningState;
    pOpenningState = NULL;
    delete pCloseingState;
    pCloseingState = NULL;
    delete pRunningState;
    pRunningState = NULL;
    delete pStoppingState;
    pStoppingState = NULL;
}

CLiftState * CContext::GetLiftState()
{
    return m_pLiftState;
}

void CContext::SetLiftState(CLiftState *pLiftState)
{
    this->m_pLiftState = pLiftState;
    this->m_pLiftState->SetContext(this);
}

void CContext::Open()
{
    this->m_pLiftState->Open();
}

void CContext::Close()
{
    this->m_pLiftState->Close();
}

void CContext::Run()
{
    this->m_pLiftState->Run();
}

void CContext::Stop()
{
    this->m_pLiftState->Stop();
}

// State.cpp : 定義控制檯應用程式的入口點。
#include "stdafx.h"
#include "ILift.h"
#include "Lift.h"
#include "Context.h"
#include "OpenningState.h"
#include "CloseingState.h"
#include "RunningState.h"
#include "StoppingState.h"
#include <iostream>
using std::cout;
using std::endl;

void DoIt()
{
    //ILift.h, Lift.h, Lift.cpp
    ILift *pLift = new CLift();
    pLift->SetState(ILift::STOPPING_STATE);//電梯的初始條件是停止狀態。
    pLift->Open();//首先是電梯門開啟，人進去
    pLift->Close();//然後電梯門關閉
    pLift->Run();//再然後，電梯跑起來，向上或者向下
    pLift->Stop();//最後到達目的地，電梯停下來
    delete pLift;
}


void DoNew()
{
    //LiftState.h, LiftState.cpp, OpenningState.h, CloseingState.h, RunningState.h, StoppingState.h
    //Context.h, Context.cpp
    CContext context;
    CCloseingState closeingState;
    context.SetLiftState(&closeingState);
    context.Close();
    context.Open();
    context.Run();
    context.Stop();
}

int _tmain(int argc, _TCHAR* argv[])
{
    cout << "----------使用模式之前----------" << endl;
    DoIt();
    cout << "----------使用模式之後----------" << endl;
    DoNew();

    _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
    _CrtDumpMemoryLeaks();
    return 0;
}</span></span>
State狀態模式的優點:

（1）.狀態模式將與特定狀態相關的行為區域性化，並且將不同狀態的行為分割開來。

（2）.所有狀態相關的程式碼都存在於某個ConcereteState中，所以通過定義新的子類很容易地增加新的狀態和轉換。

（3）.狀態模式通過把各種狀態轉移邏輯分不到State的子類之間，來減少相互間的依賴。

State狀態模式的缺點:

（1）.在於使用狀態模式會增加系統類和物件的個數，且狀態模式的結構與實現都較為複雜，如果使用不當將導致程式結構和程式碼的混亂，對於可以切換狀態的狀態模式不滿足“開閉原則”的要求。導致較多的ConcreteState子類

State狀態模式使用總結：

      策略模式關注行為的變化,但歸根結底只有一個行為,變化的只是行為的實現.客戶不關注這些.當新增變化時對客戶可以沒有任何影響.狀態模式同樣關注行為的變化,但這個變化是由狀態來驅動,一般來說每個狀態和行為都不同.新增的狀態或行為一般與已有的不同,客戶需要關注這些變化.狀態模式中State及其子類中的操作都將Context傳入作為引數，以便State可以通過這個指標呼叫Context中的方法，修改狀態。而策略模式沒有。


相關推薦

C++狀態模式詳解--設計模式（15）

State模式來源：   每個人、事物在不同的狀態下會有不同表現（動作），而一個狀態又會在不同的表現下轉移到下一個不同的狀態（State）。最簡單的一個生活中的例子就是：地鐵入口處，如果你放入正確的地鐵票，門就會開啟讓你通過。在出口處也是驗票，如果正確你就可以ok，否則就不讓

Visitor模式詳解--設計模式（20）

Visitor模式來源：  在面向物件系統的開發和設計過程，經常會遇到一種情況就是需求變更（RequirementChanging），經常我們做好的一個設計、實現了一個系統原型，咱們的客戶又會有了新的需求。我們又因此不得不去修改已有的設計，最常見就是解決方案就是給已經設

建立型模式-工廠相關模式 詳解設計模式之工廠模式(簡單工廠+工廠方法+抽象工廠)

　　這裡我們來說一下簡單工廠，工廠方法，抽象工廠 　　可以看這篇文章：詳解設計模式之工廠模式(簡單工廠+工廠方法+抽象工廠) 　　簡單工廠 　　先說說簡單工廠，簡單工廠模式是屬於建立型模式，又叫做靜態工廠方法（Static Factory Method）模式，但不屬於23種GOF設計模式之一 　　看程

Android NDK——必知必會之JNI的C++操作函式詳解和小結（三）

引言 上一篇講解了一些關於JNI和NDK的必知必會的理論知識和機制，由於篇幅問題把關於JNI的重要的函式放到這篇，具體使用留到下一篇，此係列文章基連結： 一、JNI中的函式概述 在JNI層我們基本上都是通過env指標來呼叫jni.h標頭檔案裡定義的函式，JNI

詳解設計模式 - 工廠模式（3種）

這篇文章作為個人學習備忘筆記，通過生活中的牛奶工廠例項，比對3種工廠模式的不同。 工廠模式一句話總結： 只對生產結果負責，不要三無產品。 生活中的工廠例子 小作坊：五花八門什麼都能生產，但生產質量和產品種類不一定滿足消費者的需求。 專業工廠：遵循一定標準，

一看就懂【來自英雄聯盟蓋倫的怒吼】與 Python 詳解設計模式（二）觀察者模式

觀察者模式概述 觀察者模式（有時又被稱為模型-檢視（View）模式、源-收聽者(Listener)模式或從屬者模式）是軟體設計模式的一種。在此種模式中，一個目標物件管理所有相依於它的觀察者物件，並且在它本身的狀態改變時主動發出通知。這通常透過呼叫各觀察者所提供的方法來實現。此種模式通常被用來實現事件處理系統

詳解設計模式（四）

原文連結：http://blog.csdn.net/zhangerqing/article/details/8245537 其實每個設計模式都是很重要的一種思想，看上去很熟，其實是因為我們在學到的東西中都有涉及，儘管有時我們並不知道，其實在Java本身的設計之中處處都有體現，像AW

詳解設計模式（三）

原文連結：http://blog.csdn.net/zhangerqing/article/details/8243942         今天會講到第三類設計模式——行為型模式，共11種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任

一看就懂！【英雄聯盟銳雯】與 Python 詳解設計模式之門面模式

【網路配圖】 設計模式（Design Pattern）是一套被反覆使用、多數人知曉的、經過分類的、程式碼設計經驗的總結。使用設計模式的目的：為了程式碼可重用性、讓程式碼更容易被他人理解、保證程式碼可靠性。設計模式使程式碼編寫真正工程化；設計模式是軟體工程的基石脈絡，如同大廈的結構一樣

【詳解設計模式】工廠模式

工廠模式 工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。 在工廠模式中，我們在建立物件時不會對客戶端暴露建立邏輯，並且是通過使用一個共同的介面來指向新建立的物件。 介

程式碼詳解設計模式之簡單工廠模式

簡單工廠模式   例項：建立一個形狀介面和實現該介面的圓形和方形，然後定義形狀工廠。Demo演示類使用工廠來獲取不同的形狀物件。 優點： 遮蔽產品的具體實現，呼叫者只關心產品的介面。 擴充套件性高，如果想增加一個產品，只要擴充套件一個工廠類就可以。

程式碼詳解設計模式--模板模式

模板模式   一個抽象類公開定義了執行方法的模板，它的子類可以按需要重寫方法實現，但呼叫將以抽象類中定義的方式進行。 優點： 封裝不變部分，擴充套件可變部分。 提取公共程式碼，便於維護。 行為由父類控制，子類實現。 缺點：

微信和支付寶支付模式詳解及實現（.Net標準庫）

     支付基本上是很多產品都必須的一個模組，大家最熟悉的應該就是微信和支付寶支付了，不過更多的可能還是停留在直接sdk的呼叫上，甚至和業務系統高度耦合，網上也存在各種解決方案，但大多形式各異，東拼西湊而成。所以這裡我介紹下OSS.PayCenter開源跨平臺支付元件 及

spring原始碼-詳解設計模式

開發十年，就只剩下這套架構體系了！ >>>   

詳解設計模式在Spring中的應用

三種 apache 運用 ebp tty int() 包裝 rand 錄像 設計模式作為工作學習中的枕邊書，卻時常處於勤說不用的尷尬境地，也不是我們時常忘記，只是一直沒有記憶。 今天，在IT學習者網站就設計模式的內在價值做一番探討，並以spring為例進行講解，只有領略了

【經典案例】Python詳解設計模式：策略模式

src 手動 pri 依賴 同學 ice als pass concrete 完成一項任務往往有多種方式，我們將其稱之為策略。 比如，超市做活動，如果你的購物積分滿1000，就可以按兌換現金抵用券10元，如果購買同一商品滿10件，就可以打9折，如果如果購買的金額超過500，

Javascript 嚴格模式詳解 strict 模式

今天使用jquery.validate.js 發現如下錯誤：0x800a13b3 - JavaScript 執行時錯誤: strict 模式下不允許訪問函式或引數物件的“caller”屬性 查詢資料如下： 一、概述 除了正常執行模式，ECMAscript 5添加了第二種執行

《Head.First設計模式》的學習筆記（15）－－代理模式

 意圖： 為另一個物件提供一個替身或佔位符得以訪問這個物件。 結構： 接著我們來看RMI遠端代理： 1.我們先在伺服器註冊好幾個糖果機，由於我們現在使用RMI，我們需要構造糖果機和狀態。 糖果機首先變成一個服務，我們為糖果機建立一個遠端介面，讓開介面提供了一組可以遠端

經典分享 C++記憶體管理詳解　１（共２部分）

C++記憶體管理。程式設計師們經常編寫記憶體管理程式，往往提心吊膽。如果不想觸雷，唯一的解決辦法就是發現所有潛伏的地雷並且排除它們，躲是躲不了的。本文的內容比一般教科書的要深入得多，讀者需細心閱讀，做到真正地通曉記憶體管理。 1、記憶體分配方式 記憶體分配

設計者模式詳解--組合模式

param .cn ride 角色 [] 總結 code 方式 bstr 1. 概述 　　將對象組合成樹形結構以表示“部分-整體”的層次結構。組合模式使得用戶對單個對象和組合對象的使用具有一致性。 2. 解決的問題 　　當希望忽略單個對象和組合