我们经常看到一些页面被划分成几大块.最简单的就是分成左右两在块.像windows系统打开我的电脑时,一般是看到左边是个树形的目录结构,右边就是文件目录或有哪几个盘啊.

这样的页面是怎样实现的呢?

主要是通过类CSplitterWnd来实现的.下面来简单讲下它的用法

先创建一个SDI项目.

再添加类CMyFrm(该类继承自CFormView,实际上只要是继承自CView的类都行的.)

 

MainFrm.h

CSplitterWnd m_wndSplitter;

 

//这是一个CWnd中的虚函数,窗口的分割就在该函数中完成.哎它怎么被调用的就先不去管了,反正MFC里经常莫名其妙的跑出来一个回调函数,你看不到是在哪里被调用的,

//系统背后偷偷的就调用它了

BOOL OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext);

 

///MainFrm.cpp///

 

BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext){

   m_wndSplitter.CreateStatic(this,1,2); //这里表示把窗口分成1行两列,也就是把一个窗口分成两半了.如果要分成竖着的三部分就是CreateStatic(this,1,3);横着的三部分就是

                                                        //CreateStatic(this,3,1);

  m_wndSplitter.CreateView(0,0,RUNTIME_CLASS(CMyFrm),CSize(100,100),pContext); //把窗口的左边部分用某个继承自View的类绑定起来.

  m_wndSplitter.CreateView(0,1,RUNTIME_CLASS(CMyFrm),CSize(100,100),pContext); //把窗口的右边部分用某个继承自View的类绑定起来.

 

return TRUE;

}

 

 

7-1 鼠标消息分哪两类,它们之间有什么区别?
答:根据产生鼠标消息时鼠标光标所处的位置,鼠标消息分为:客户区鼠标消息和非客户区鼠标消息两类。

在应用程序窗口中,用户可以绘图的部分叫做客户区或者用户区,而除此之外的区域叫非客户区。

鼠标在客户区产生的消息叫客户区鼠标消息,在非客户区产生的消息叫非客户区鼠标消息。
7-3 在程序设计中,如何使用非客户区鼠标消息?
答:首先,在主框架窗口类的声明中手工添加非客户消息响应函数的声明,然后在主框架窗口类实现文件的消息映射表中添加消息映射,最后在主框架窗口类的实现文件中,添加鼠标响应函数并实现它。
7-9 编写一个
(1)
//添加数据成员
class CM7_9Doc : public CDocument
{

// Attributes
public:
	CPoint p1,p2;
	int flag;
	};

void CM7_9View::OnDraw(CDC* pDC)
{
	CM7_9Doc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	
	CClientDC dc(this);
	p1.x = 300;
	p1.y = 300;
	
	if(flag == 0){
		pDC->Ellipse(pDoc->p2.x+50,pDoc->p2.y+50,pDoc->p2.x-50,pDoc->p2.y-50);
	}
	else{
		pDC->Ellipse(p1.x+50,p1.y+50,p1.x-50,p1.y-50);
	}
}
//单击鼠标左键 圆放大
void CM7_9View::OnLButtonDown(UINT nFlags, CPoint point) 
{
	CClientDC dc(this);
	p1.x = 350;
	p1.y = 350;
	dc.Ellipse(p1.x+100,p1.y+100,p1.x-100,p1.y-100);
	
	CView::OnLButtonDown(nFlags, point);
}
//单击鼠标右键 圆变小
void CM7_9View::OnRButtonDown(UINT nFlags, CPoint point) 
{
	
	InvalidateRect(NULL,TRUE);
	CClientDC dc(this);
	p1.x = 350;
	p1.y = 350;
	dc.Ellipse(p1.x+50,p1.y+50,p1.x-50,p1.y-50);

	CView::OnRButtonDown(nFlags, point);
}

void CM7_9View::OnMouseMove(UINT nFlags, CPoint point) 
{

	CM7_9Doc* pDoc = GetDocument();
	//按下crtl 同时移动鼠标 圆跟着鼠标移动	
	if(nFlags&MK_CONTROL){
		flag = 0;
		pDoc->p2 = point;
		InvalidateRect(NULL,true);
	}

	CView::OnMouseMove(nFlags, point);
}

7-12
class CM7_12Doc : public CDocument
{
public:
	CRect rect;
	};
CM7_12Doc::CM7_12Doc()
{
	rect.left = 200;
	rect.right = 400;
	rect.top = 200;
	rect.bottom =300;
}

void CM7_12View::OnDraw(CDC* pDC)
{
	CM7_12Doc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	CClientDC dc(this);

	dc.Rectangle(pDoc->rect);
	// TODO: add draw code for native data here
}

void CM7_12View::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	// TODO: Add your message handler code here and/or call default
	CM7_12Doc* pDoc = GetDocument();
	CRect client;
	GetClientRect(&client);
	switch(nChar){
	case VK_LEFT:
		pDoc->rect.left -=10;
		pDoc->rect.right -=10;
		break;
	case VK_RIGHT:
		pDoc->rect.left +=10;
		pDoc->rect.right +=10;
		break;
	case VK_UP:
		pDoc->rect.top -=10;
		pDoc->rect.bottom -=10;
		break;
	case VK_DOWN:
		pDoc->rect.top +=10;
		pDoc->rect.bottom +=10;
		break;
	case VK_HOME:
		pDoc->rect.left -=10;
		pDoc->rect.top -=10;
		break;
	case VK_END:
		pDoc->rect.bottom +=10;
		pDoc->rect.right +=10;
		break;

	}
	InvalidateRect(NULL,true);
	CView::OnKeyDown(nChar, nRepCnt, nFlags);
}

void CM7_12View::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	CM7_12Doc *pDoc = GetDocument();
	pDoc->rect.left = 200;
	pDoc->rect.right = 400;
	pDoc->rect.top = 200;
	pDoc->rect.bottom = 300;
	InvalidateRect(NULL,true);

	CView::OnLButtonDown(nFlags, point);
}

单实例

我们在设计某些类时，根据需求，有时只需要一个实例，不想过多浪费内存，这就可以通过单实例的方式。


如，我们在使用windows的任务管理器时，弹出的始终是一个窗口，
这里如果对象采用多实例模式，那么就会弹出多个窗口，会出现下述两种情况：
第一，如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，
容易使用户误解，不知道哪一个才是真实的状态，这与需求不符；
第二，如果这些窗口显示的内容完全一致，则是重复对象，意味着浪费内存资源。


因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。



单实例的特点及实现

单实例模式，应该有如下特点：
第一，这个类只能创建一个对象；
第二，这个类必须自行创建这个对象；
第三，这个类创建的对象必须在整个系统都可以使用。


单实例上述特点的实现方式：
第一，是这个类只提供私有的构造函数；
第二，是这个类定义中含有一个该类的静态私有对象；
第三，是这个类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。

思考: 
Singleton模式经常和Factory（AbstractFactory）模式在一起使用，
因为系统中工厂对象一般来说只要一个



单实例的具体代码实现

需要考虑：
第一，只有一个对象，则需要禁止copying行为(包括拷贝和赋值)。
第二，如果是动态申请资源，则需要考虑资源的释放。
第三，多线程安全，即同一时刻多个线程调用这个函数会不会出现程序异常。



(1) 懒汉式
懒汉式的方式就是延迟加载，即定义一个指向该类的私有指针，
直到用到实例的时候才进行对象的创建，并把对象地址赋值给这个指针。


第一种方式：申请的资源手动释放


#############    Test.h    #############

class Test
{
public:


    //获取单例指针
    static Test* getInstance();


    //销毁单例资源   注：必须在所有线程结束后，进程结束前调用, 或不调用
    static void destroyInstance();


private:


    //防止外部构造和析构
    Test();
    ~Test();


    //防止拷贝和赋值, 只声明实现
    Test(Test&);
    Test& operator=(Test&);


private:


    //全局唯一对象指针
    static Test*  m_pTest;


    //针对m_pTest的全局锁，实现创建单实例线程安全, 锁的封装，参考本博客线程锁的封装
    static Lock m_sLock;


};




#############    Test.cpp    #############


Test*  Test::m_pTest = NULL;
Lock Test::m_sLock;


/*
    * 构造函数
*/
Test::Test()
{
}


/*
    * 析构函数
*/
Test::~Test()
{
}




//创建单实例对象
Test* Test::getInstance()
{
    Test::m_sLock.mutexLock();
    if(m_pTest == NULL)
    {
        m_pTest = new(std::nothrow) Test;
    }
    Test::m_sLock.mutexUnlock();


    return m_pTest;
}


//销毁Test, 注：必须在所有线程结束后，进程结束前调用
void Test::destroyInstance()
{
    Test::m_sLock.mutexLock();


    delete m_pTest;
    m_pTest = NULL;


    Test::m_sLock.mutexUnlock();
}





说明：
1. 创建实例，getInstance()
2. 销毁实例，destroyInstance()
3. 在懒汉式的单例类中，其实有两个状态，单例未初始化和单例已经初始化。
假设单例还未初始化，有两个线程同时调用getInstance方法，这时执行 m_pTest == NULL 肯定为真，
然后两个线程都初始化一个单例，最后得到的指针并不是指向同一个地方，
不满足单例类的定义了，所以懒汉式的写法会出现线程安全的问题！
在多线程环境下，要对其进行修改，例如，上面进行加锁处理，
以此来保证只有一个实例。
4. 构造函数为私有的好处:
禁止用户对此类型的变量进行定义，即禁止在类外创建此类型的对象。

5. 析构函数为私有的好处:
禁止用户在程序中使用 delete 删除此类型对象。
对象的删除只能在类内实现，也就是说只有类的实现者才有可能实现对对象的 delete，
用户不能随便删除对象。如果用户想删除对象的话，只能按照类的实现者提供的方法进行。   





第二种：申请的资源自动释放（这种方式有点多余，程序结束，系统自动回收内存，只是一种思考）




#############    Test.h    #############
class Test
{
public:


    //获取单例指针
    static Test* getInstance();


private:


    //防止外部构造和析构
    Test();
    ~Test();


    //防止拷贝和赋值, 只声明实现
    Test(Test&);
    Test& operator=(Test&);


    class Garbo   //它的唯一工作就是在析构函数中删除Test的实例  
    {  
    public:  
        ~Garbo()  
        {  
            if(Test::m_pTest)  
           {
                delete Test::m_pTest;  
           }
        }  
    }; 


private:


    //全局唯一对象指针
    static Test*  m_pTest;


    //定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数  
    static Garbo m_sGarbo; 


    //针对m_pTest的全局锁，实现创建单实例线程安全, 锁的封装，参考本博客线程锁的封装的文章
    static Lock m_sLock;


};







#############    Test.cpp    #############

Test*  Test::m_pTest = NULL;
Garbo Test::m_sGarbo;
Lock Test::m_sLock;


/*
    * 构造函数
*/
Test::Test()
{
}


/*
    * 析构函数
*/
Test::~Test()
{
}


//创建单实例对象
Test* Test::getInstance()
{
    Test::m_sLock.mutexLock();
    if(m_pTest == NULL)
    {
        m_pTest = new(std::nothrow) Test;
    }
    Test::m_sLock.mutexUnlock();


    return m_pTest;
}






说明：
1.创建实例，getInstance()
2.不需要手动释放资源，通过静态对象m_sGarbo的析构函数自动释放





第三种：（推荐使用方式）


补充：
已初始化的的全局变量和局部静态变量存放在data段，
未初始化的全局变量和局部静态变量一般存放在bss段里，
前者在生产可执行文件时就分配好内存了，后者在加载时才分配。

注意：
所谓static对象指的是内存在data段和bss段中的对象．这类对象在整个程序的生命周期内都是存在的，除非程序结束否则会一直存在，
利用static关键字声明的对象是static对象中的一种，但是如果是在函数内部定义的static对象，那么这种static对象被称为local static对象，
除此之外的则是non-local static对象，比如:global作用域内的static对象，namespace作用域内的static对象，
类作用域内使用static关键字声明的对象，file作用域内的static对象等．

local static对象的一个特性就是不会在编译的时候自动初始化，然后在调用函数的时候碰到local static对象定义的时候才会对其进行初始化。

从另外一个角度来看，任何一种 non-const static 对象，不论是local 或者non-local ，在多线程环境下“等待某事发生”都会有麻烦。
处理这个麻烦的做法是：(1) 可以在程序的单线程启动阶段手工调用；(2) 也可以通过加锁的方式解决多线程的问题。






#############    Test.h    #############
class Test
{


public:
    //获取单例指针
    static Test* getInstance();



private:
    Test();
    ~Test();


    //防止拷贝和赋值, 只声明实现
    Test(Test&);
    Test& operator=(Test&);


};







#############    Test.cpp    #############

/*
    * 构造函数
*/
Test::Test()
{
}


/*
    * 析构函数
*/
Test::~Test()
{
}




/*
    * 单实例实现
*/
Test* Test:getInstance()
{
    static Test instance;       //局部静态变量
    return &instance;
}






说明：
1.使用单例getInstance()
2.不用资源释放问题



(2) 饿汉式
饿汉式的方式是一开始就加载了，以空间换时间，即定义一个静态的私有对象。不存在多线程问题。

class singleton
{
protected:
    singleton()
    {}
private:
    static singleton* p;
public:
    static singleton* initance();
};
singleton* singleton::p = new singleton;
singleton* singleton::initance()
{
    return p;
}