http://www.cppblog.com/mzty/archive/2007/03/02/19109.html  C++基础

http://www.cppblog.com/mzty/archive/2007/04/16/22064.html  C#界面，C++核心算法

http://www.cppblog.com/mzty/archive/2007/03/04/19163.html  设计模式

http://www.cppblog.com/mzty/archive/2007/03/29/20893.html  64bit，FW3.0随笔分类

http://www.cppblog.com/mzty/archive/2007/03/29/20892.html  windows脚本技术

http://www.cppblog.com/mzty/archive/2007/03/04/19167.html  C#基础

Creational : Singleton Pattern

First step in any MFC application is the creation of application object (object of class derived from CWinApp). There should be only one application object in an instance of MFC application. CWinApp is designed to make sure that only application object is present in a given instance. CWinApp and its descendants are called Singleton Classes. A class (CWinApp or its descendant) that assures a maximum of ONE object of its type at a given time and provides a global access point (AfxGetApp() method) to this object is a Singleton class.

As this principle is applied over and over again to solve recurring object "creational" problems, this becomes a pattern. Singleton Pattern ensures that a class only has one instance and provides a global access point it. The article Creating Singleton Objects using Visual C++ talks about different approaches for implementing Singletons.

Structural : Bridge Pattern

Bridge Pattern is all about decoupling an abstraction (interface) from its implementation so that the two can vary independently. In MFC, the process of storing/retrieving an object to/from a persistence mechanism (like a file) is called Serialization. MFC uses the Bridge Pattern to implement Serialization. CArchive and CFile classes implement object Serialization. CArchive class provides the interface for writing/reading an object to/from a persistence mechanism whereas the CFile and its sub classes provides implementation for different persistence mechanisms such as memory, disk file, sockets etc.

A CArchive object is configured with an object of class CFile (or a derived class) during its construction, from which it obtains the necessary information for serialization, including the filename and type of the requested operation (a read or write). Client performing the Serialization operation can use CArchive object without regarding the persistence mechanism implemented by CFile classes.

The article Bridge Pattern - Bridging the gap between Interface and Implementation talks about Bridge pattern in detail.

Behavioral : Observer Pattern

The Observer Pattern is intended to "Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically". An object that is subjected to change is called a Subject and an object that depends on the Subject's state is called an Observer.

MFC uses a Document/View variant of the Observer Pattern. MFC's famous Document/View architecture uses this variant. A document contains the data object and acts as a Subject. A view is a window object through which the user updates the document and it acts as an Observer. A document can have multiple views. Whenever the data in the document is changed by one of the views, it updates the document by calling UpdateAllViews method, with optional hint about the modification. To inform about the change to other views, the document object calls OnUpdate method for each view attached to it (except the view that called UpdateAllViews). Derived view classes can override the OnUpdate method and update themselves by querying the data from the document.

The article Applying Observer Pattern in C++ Applications talks about Observer pattern in detail.

Summary

Design Pattern provides a common language for designers and helps them to decompose systems into a set of cooperating classes and objects. They provide proven design solution to recurring problems. In this article, I have introduced the design pattern and how MFC is using some of the patterns in its design. We can easily find more and more patterns when we dig into MFC and its classes.

• 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。
• 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。Vi s i t o r 使得你可以将相关的操作集中起来定义在一个类中。当该对象结构被很多应用共享时，用Vi s i t o r 模式让每个应用仅包含需要用到的操作。
• 定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。

// Visitor pattern -- Structural example

using System; using System.Collections; namespace DoFactory.GangOfFour.Visitor.Structural {      // MainApp test application   class MainApp   {     staticvoid Main()     {       // Setup structure       ObjectStructure o = new ObjectStructure();       o.Attach(new ConcreteElementA());       o.Attach(new ConcreteElementB());       // Create visitor objects       ConcreteVisitor1 v1 = new ConcreteVisitor1();       ConcreteVisitor2 v2 = new ConcreteVisitor2();       // Structure accepting visitors       o.Accept(v1);       o.Accept(v2);       // Wait for user       Console.Read();     }   }   // "Visitor"   abstractclass Visitor   {     publicabstractvoid VisitConcreteElementA(       ConcreteElementA concreteElementA);     publicabstractvoid VisitConcreteElementB(       ConcreteElementB concreteElementB);   }   // "ConcreteVisitor1"   class ConcreteVisitor1 : Visitor   {     publicoverridevoid VisitConcreteElementA(       ConcreteElementA concreteElementA)     {       Console.WriteLine("{0} visited by {1}",         concreteElementA.GetType().Name, this.GetType().Name);     }     publicoverridevoid VisitConcreteElementB(       ConcreteElementB concreteElementB)     {       Console.WriteLine("{0} visited by {1}",         concreteElementB.GetType().Name, this.GetType().Name);     }   }   // "ConcreteVisitor2"   class ConcreteVisitor2 : Visitor   {     publicoverridevoid VisitConcreteElementA(       ConcreteElementA concreteElementA)     {       Console.WriteLine("{0} visited by {1}",         concreteElementA.GetType().Name, this.GetType().Name);     }     publicoverridevoid VisitConcreteElementB(       ConcreteElementB concreteElementB)     {       Console.WriteLine("{0} visited by {1}",         concreteElementB.GetType().Name, this.GetType().Name);     }   }   // "Element"   abstractclass Element   {     publicabstractvoid Accept(Visitor visitor);   }   // "ConcreteElementA"   class ConcreteElementA : Element   {     publicoverridevoid Accept(Visitor visitor)     {       visitor.VisitConcreteElementA(this);     }     publicvoid OperationA()     {     }   }   // "ConcreteElementB"   class ConcreteElementB : Element   {     publicoverridevoid Accept(Visitor visitor)     {       visitor.VisitConcreteElementB(this);     }     publicvoid OperationB()     {     }   }   // "ObjectStructure"   class ObjectStructure   {     private ArrayList elements = new ArrayList();     publicvoid Attach(Element element)     {       elements.Add(element);     }     publicvoid Detach(Element element)     {       elements.Remove(element);     }     publicvoid Accept(Visitor visitor)     {       foreach (Element e in elements)       {         e.Accept(visitor);       }     }   } }

• 访问一个聚合对象的内容而无需暴露它的内部表示。
• 支持对聚合对象的多种遍历。
• 为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。

namespace Iterator_DesignPattern
{
    using System;
    using System.Collections;

    class Node 
    {
        private string name;
        public string Name 
        {
            get 
            {
                return name;    
            }
        }
        public Node(string s)
        {
            name = s;
        }
    }
    
    class NodeCollection 
    {
        private ArrayList list = new ArrayList();
        private int nodeMax = 0;
        
        // left as a student exercise - implement collection
        // functions to remove and edit entries also
        public void AddNode(Node n)
        {
            list.Add(n); 
            nodeMax++;            
        }        
        public Node GetNode(int i)
        {
            return ((Node) list[i]);
        }

        public int NodeMax 
        {            
            get 
            {
                return nodeMax;
            }
        }
    }

    /**//*
     * The iterator needs to understand how to traverse the collection 
     * It can do that as way it pleases - forward, reverse, depth-first, 
     */
    abstract class Iterator 
    {
        abstract public Node Next();        
    }

    class ReverseIterator : Iterator
    {
        private NodeCollection nodeCollection;
        private int currentIndex;

        public ReverseIterator (NodeCollection c)
        {
            nodeCollection = c;            
            currentIndex = c.NodeMax -1; // array index starts at 0!
        }

        // note: as the code stands, if the collection changes,
        // the iterator needs to be restarted 
        override public Node Next()
        {
            if (currentIndex == -1)
                return null;
            else 
                return(nodeCollection.GetNode(currentIndex--));
        }
    }
    
    /**//// <summary>
    ///    Summary description for Client.
    /// </summary>
    public class Client
    {
        public static int Main(string[] args)
        {   
            NodeCollection c =&