Fighting~~~~

For my future

Facade外观模式

Facade外 观模式，是一种结构型模式，它主要解决的问题是：组件的客户和组件中各种复杂的子系统有了过多的耦合，随着外部客户程序和各子系统的演化，这种过多的耦合 面临很多变化的挑战。在这里我想举一个例子：比如，现在有一辆汽车，我们（客户程序）要启动它，那我们就要发动引擎（子系统1），使四个车轮（子系统2）转动。但是实际中我们并不需要用手推动车轮使其转动，我们踩下油门，此时汽车再根据一些其他的操作使车轮转动。油门就好比系统给我们留下的接口，不论汽车是以何种方式转动车轮，车轮变化成什么牌子的，我们要开走汽车所要做的还是踩下油门。

GoF《设计模式》中说道：为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

Façade外观模式的结构大概是这样的：

这个图是我对Facade模式的理解，如果大家觉得有什么不对的地方欢迎给我指出。

我就上面说的那个情形写一下实现代码，首先我们要实现三个子系统（Wheel、Engine、Body）：

internal class Engine

{

public string EngineWork()

{

return "BMW's Engine is Working";

}

public string EngineStop()

{

return "BMW's Engine is stoped";

}

}

internal class Wheel

{

public string WheelCircumrotate()

{

return "BMW's Wheel is Circumrotating";

}

public string WheelStop()

{

return "BMW's Wheel is stoped";

}

}

internal class Body

{

public Wheel[] wheels = new Wheel[4];

public Engine engine = new Engine();

public Body()

{

for (int i = 0; i <>

{

wheels[i] = new Wheel();

}

}

}

然后，我们再来实现汽车的Facade

class CarFacade

{

Body body = new Body();

public void Run()

{

Console.WriteLine(body.engine.EngineWork());

for(int i = 0; i <>

{

Console.WriteLine(body.wheels[i].WheelCircumrotate());

}

}

public void Stop()

{

Console.WriteLine(body.engine.EngineStop());

for (int i = 0; i <>

{

Console.WriteLine(body.wheels[i].WheelStop());

}

}

}

现在我们来使用客户端程序验证一下，代码如下：

class Program

{

static void Main(string[] args)

{

CarFacade car = new CarFacade();

car.Run();

car.Stop();

Console.Read();

}

}

执行结果如下；

BMW's Engine is Working

BMW's Wheel is Circumrotating

BMW's Wheel is Circumrotating

BMW's Wheel is Circumrotating

BMW's Wheel is Circumrotating

BMW's Engine is stoped

BMW's Wheel is stoped

BMW's Wheel is stoped

BMW's Wheel is stoped

BMW's Wheel is stoped

正如上面所说：客户端代码（Program）不需要关心子系统，它只需要关心CarFacade所留下来的和外部交互的接口，而子系统是在CarFacade中聚合。

Façade模式的几个要点：

1、从客户程序的角度看，Facade模式不仅简化了整个组件系统的接口，同时对于组件内部与外部客户程序来说，从某种程度上也达到了一种“解耦”的效果——内部子系统的任何变化不会影响到Facade接口的变化。

2、Facade设计模式更注重从架构的层次去看整个系统，而不是单个类的层次。Facade很多时候更是一种架构设计模式。

从未体验过的艰难(A tough time for me)

A tough time for me

在几个月之前，我从来没有想过找工作会如此艰难，那时候意气风发、信心满满，从未料想到“扩招”之后的海选竟是如此的惨烈，更未体会到“雷声大、雨点小”以至于现在久旱未逢一滴让我绝处逢生的雨露，就这样每天绝望地奔波着，忍着被鄙视的痛，也许还会苦苦地等待霸王笔的机会然而却被拒绝。坐在公交车上望着窗外的楼宇和川流不息的车辆，这是处在“经济危机”中的中国么？

面试现场编程(on-site progarmming)简单攻略

onsite编程是很多公司招聘程序员的常规手段，和其它招聘题目相比，onsite编程真刀实枪，可以更全面和客观的反应一个候选人的编程功底。另外一 方面来说，对缺乏经验的编程者来说，be ready to 现场编程不是那么容易糊弄的事情，费时而且费力。面试官通常希望通过现场编程来考察应试者
1. 对编程语言的掌握；
2. 对开发环境的掌握；
3. 编程效率；
4. 结构设计能力;
5. 对数据库或者操作系统或者其它相关知识的掌握；
6. 交流、分析问题、解决问题的能力。

现 场编程一般分为两种，一种是在真实的开发环境下编程，你可以调试、调用联机帮助，直到你得到你想要的输出或者超时；另外一种是“纸上谈兵”，给你几张白纸 和一支笔，让你把代码写出来。笔者个人认为，后者更具挑战性，但也因人而异。大部分场合，面试者会让你stay alone，直到你完成编程题目（交卷）。

既然我们已经了解了面试官的企图，为了得到我们需要的offer，我们就要投其所好，尽量编出“完美”的代码。完美的代码应该：
1. 总是产生正确的输出；
2. 变量命名直观，标准统一；有合适的注释；代码结构清晰；
3. 健壮性，能够预防不正确的输入；
4. 没有明显的效率隐患；我的建议是要尽量避免O(n2)的循环；
5. 如果是用纸写的，一定要尽量做到无语法错误。

如 果你是一个初学者，你应该明白没有终南捷径可以迅速提高编程能力。你必须投入很多的时间和精力在编程练习上。考虑到编程将是你的终身职业，这些投入是非常 值得的。作者推荐一本书"progamming inerviews exposed"，在mitbbs上有它的下载信息，建议读者将其中的代码全都自己再做一遍。对于C/C++程序员，还要多做些字符串处理/指针方面的题 目，本人强烈建议将string类重写一遍。这样基本上就可以对付常规现场编程题。另外，还要读一下相关语言的编程规范。比如VC++的编程规范，C++ Builder的编程规范，ASP.net的编程规范。这些资料在互联网很容易找到。参照编程规范，对于量命名、注释风格、缩进格式等形成自己的风格。

下面是针对现场编程的一些建议：

1. 现场编程是一个有效的面试手段，但仍然不能全面显示编程者的编程能力。并且现场编程有很多局限性。首先是，它只对初学者（应届毕业生）有效，对熟练的程序 员无效。其次是，由于面试时间的限制，只能给一些简单的题目，一般来说suppose代码不会超过100行。这样也给我们一个提示，如果你发现代码量要接 近或超过100行的时候，不妨重新考虑一下你要解决的问题。
2. 如果不完全懂你的assignment，一定要向面试官问清楚。当然问之前，应该先考虑一下，最好不要笼统的说“我不懂”，应该针对细节来问。运气好的话，你的问题还会给你的面试加分。比如说截取字符的时候你就可以问是不是要考虑双字节的字符比如汉字。
3. 如果是用纸写，你没有机会调试。这个时候要注意别犯低级错误，比如引用未定义/未初始化变量，大小写不区分，忘了;或者}等等。写完了要检查。
4. 如果牵涉到用户输入，先写一个空函数来检查用户输入，比如说bool CheckInputOK(){return true;}。表示你已经考虑到了这一点。有时间再fullfill这个函数，没有时间就算了。
5. 注意你的代码风格，变量名字要直观，要有注释。
6. 有时候，面试官会看着你编程。这个时候沉默不是金，一定要talk，keep talking。把你的思路说出来，自言自语但是声音大到面试官可以听见。
7. 写不完就算了，这是很常见的。即使不能拿到offer，也不是end of the world。如果虽然没有完成代码，但有清晰的思路，不妨把思路写下来。或者用空函数的方式把结构展现出来。如果面试官在你身边，和他讨论一下。BTW， 有心的人会在onsite以前就准备好得体的说辞。
8. 紧接着面试官可能会和你讨论你的代码，你要尽快从当时的情绪中摆脱出来。积极的相应面试官的吹毛求疵、提示等等。After onsite可以上网查一查资料，如果有更好的算法可以发信和他讨论。

C++深拷贝与浅拷贝

浅拷贝就是成员数据之间的一一赋值：把值赋给一一赋给要拷贝的值。但是可能会有这样的情况：对象还包含资源，这里的资源可以值堆资源，或者一个文件。。当 值拷贝的时候，两个对象就有用共同的资源，同时对资源可以访问，这样就会出问题。深拷贝就是用来解决这样的问题的，它把资源也赋值一次，使对象拥有不同的 资源，但资源的内容是一样的。对于堆资源来说，就是在开辟一片堆内存，把原来的内容拷贝。

如果你拷贝的对象中引用了某个外部的内容（比如分配在堆上的数据），那么在拷贝这个对象的时候，让新旧两个对象指向同一个外部的内容，就是浅拷贝；如果在拷贝这个对象的时候为新对象制作了外部对象的独立拷贝，就是深拷贝

引用和指针的语义是相似的，引用是不可改变的指针，指针是可以改变的引用。其实都是实现了引用语义。
深拷贝和浅拷贝的区别是在对象状态中包含其它对象的引用的时候，当拷贝一个对象时，如果需要拷贝这个对象引用的对象，则是深拷贝，否则是浅拷贝。

COW语义是“深拷贝”与“推迟计算”的组合，仍然是深拷贝，而非浅拷贝，因为拷贝之后的两个对象的数据在逻辑上是不相关的，只是内容相同。

无论深浅，都是需要的。当深拷贝发生时，通常表明存在着一个“聚合关系”，而浅拷贝发生时，通常表明存在着一个“相识关系”。
举个简单的例子：
当你实现一个Composite Pattern，你通常都会实现一个深拷贝(如果需要拷贝的话)，很少有要求同的Composite共享Leaf的；
而当你实现一个Observer Pattern时，如果你需要拷贝Observer,你大概不会去拷贝Subject，这时就要实现个浅拷贝。
是深拷贝还是浅拷贝，并不是取决于时间效率、空间效率或是语言等等，而是取决于哪一个是逻辑上正确的

//--------------------------------------------------------------------------------

在学习这一章内容前我们已经学习过了类的构造函数和析构函数的相关知识，对于普通类型的对象来说，他们之间的复制是很简单的，例如：

int a = 10; int b =a;

自己定义的类的对象同样是对象，谁也不能阻止我们用以下的方式进行复制,例如：

#include usingnamespacestd; classTest { public: Test(inttemp) { p1=temp; } protected: intp1; }; voidmain() { Test a(99); Test b=a; }

普通对象和类对象同为对象，他们之间的特性有相似之处也有不同之处，类对象内部存在 成员变量，而普通对象是没有的，当同样的复制方法发生在不同的对象上的时候，那么系统对他们进行的操作也是不一样的，就类对象而言，相同类型的类对象是通 过拷贝构造函数来完成整个复制过程的，在上面的代码中,我们并没有看到拷贝构造函数，同样完成了复制工作，这又是为什么呢？因为当一个类没有自定义的拷贝 构造函数的时候系统会自动提供一个默认的拷贝构造函数，来完成复制工作。

下面，我们为了说明情况，就普通情况而言(以上面的代码为例)，我们来自己定义一个与系统默认拷贝构造函数一样的拷贝构造函数，看看它的内部是如何工作的！

代码如下：

#include usingnamespacestd; classTest { public: Test(inttemp) { p1=temp; } Test(Test &c_t)//这里就是自定义的拷贝构造函数 { cout<<"进入copy构造函数"

上面代码中的Test(Test &c_t)就是我们自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。

当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝 构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候系统将会提供给一个默认的拷贝构造函数来完成这个过程，上面代码的复制核心语句就是通过 Test(Test &c_t)拷贝构造函数内的p1=c_t.p1;语句完成的。如果取掉这句代码，那么b对象的p1属性将得到一个未知的随机值；

下面我们来讨论一下关于浅拷贝和深拷贝的问题。

就上面的代码情况而言，很多人会问到，既然系统会自动提供一个默认的拷贝构造函数来 处理复制，那么我们没有意义要去自定义拷贝构造函数呀，对，就普通情况而言这的确是没有必要的，但在某写状况下，类体内的成员是需要开辟动态开辟堆内存 的,如果我们不自定义拷贝构造函数而让系统自己处理，那么就会导致堆内存的所属权产生混乱，试想一下，已经开辟的一端堆地址原来是属于对象a的，由于复制 过程发生，b对象取得是a已经开辟的堆地址，一旦程序产生析构，释放堆的时候，计算机是不可能清楚这段地址是真正属于谁的，当连续发生两次析构的时候就出 现了运行错误。

为了更详细的说明问题，请看如下的代码。

#include usingnamespacestd; classInternet { public: Internet(char*name,char*address) { cout<<"载入构造函数"<<"载入COPY构造函数"<<"载入析构函数!"; delete[] cname; cin.get(); } voidshow(); protected: charname[20]; charaddress[30]; char*cname; }; voidInternet::show() { cout<} voidtest(Internet ts) { cout<<"载入test函数"<} voidmain() { Internet a("中国软件开发实验室","www.cndev-lab.com"); Internet b =a; b.show(); test(b); }

上面代码就演示了深拷贝的问题,对对象b的cname属性采取了新开辟内存的方式避免了内存归属不清所导致析构释放空间时候的错误,最后我必须提一下，对于上面的程序我的解释并不多，就是希望读者本身运行程序观察变化，进而深刻理解。

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源但复制过程并未复制资源的情况视为浅拷贝。

浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错,这点尤其需要注意!

以前我们的教程中讨论过函数返回对象产生临时变量的问题，接下来我们来看一下在函数中返回自定义类型对象是否也遵循此规则产生临时对象！

先运行下列代码:

#include usingnamespacestd; classInternet { public: Internet() { }; Internet(char*name,char*address) { cout<<"载入构造函数"<<"载入COPY构造函数"<<"载入析构函数!"; cin.get(); } protected: charname[20]; charaddress[20]; }; Internet tp() { Internet b("中国软件开发实验室","www.cndev-lab.com"); returnb; } voidmain() { Internet a; a=tp(); }

从上面的代码运行结果可以看出，程序一共载入过析构函数三次，证明了由函数返回自定义类型对象同样会产生临时变量，事实上对象a得到的就是这个临时Internet类类型对象temp的值。

这一下节的内容我们来说一下无名对象。

利用无名对象初始化对象系统不会不调用拷贝构造函数。

那么什么又是无名对象呢？

很简单，如果在上面程序的main函数中有：

Internet　("中国软件开发实验室","www.cndev-lab.com");

这样的一句语句就会产生一个无名对象，无名对象会调用构造函数但利用无名对象初始化对象系统不会不调用拷贝构造函数！

下面三段代码是很见到的三种利用无名对象初始化对象的例子。

#include usingnamespacestd; classInternet { public: Internet(char*name,char*address) { cout<<"载入构造函数"<<"载入COPY构造函数"<<"载入析构函数!"; cin.get(); } public: charname[20]; charaddress[20]; }; voidmain() { Internet a=Internet("中国软件开发实验室","www.cndev-lab.com"); cout

上面代码的运行结果有点“出人意料”，从思维逻辑上说，当无名对象创建了后，是应该调用自定义拷贝构造函数，或者是默认拷贝构造函数来完成复制过程的，但事实上系统并没有这么做，因为无名对象使用过后在整个程序中就失去了作用，对于这种情况c++会把代码看成是：

Internet a("中国软件开发实验室","www.cndev-lab.com");

省略了创建无名对象这一过程，所以说不会调用拷贝构造函数。

最后让我们来看看引用无名对象的情况。

#include usingnamespacestd; classInternet { public: Internet(char*name,char*address) { cout<<"载入构造函数"<<"载入COPY构造函数"<<"载入析构函数!"; } public: charname[20]; charaddress[20]; }; voidmain() { Internet &a=Internet("中国软件开发实验室","www.cndev-lab.com"); cout

引用本身是对象的别名，和复制并没有关系，所以不会调用拷贝构造函数,但要注意的是，在c++看来:

Internet &a=Internet("中国软件开发实验室","www.cndev-lab.com");

是等价与:

Internet a("中国软件开发实验室","www.cndev-lab.com");

的,注意观察调用析构函数的位置（这种情况是在main()外调用，而无名对象本身是在main()内析构的）。

Delaunay三角剖分算法

1. 三角剖分与Delaunay剖分的定义
如何把一个散点集合剖分成不均匀的三角形网格，这就是散点集的三角剖分问题，散点集的三角剖分，对数值分析以及图形学来说，都是极为重要的一项预处理技术。该问题图示如下：

1.1.三角剖分定义
【定义】三角剖分：假设V是二维实数域上的有限点集，边e是由点集中的点作为端点构成的封闭线段, E为e的集合。那么该点集V的一个三角剖分T=(V,E)是一个平面图G，该平面图满足条件：
1.除了端点，平面图中的边不包含点集中的任何点。
2.没有相交边。
3.平面图中所有的面都是三角面，且所有三角面的合集是散点集V的凸包。
1.2. Delaunay三角剖分的定义
在实际中运用的最多的三角剖分是Delaunay三角剖分，它是一种特殊的三角剖分。先从Delaunay边说起：
【定义】Delaunay边：假设E中的一条边e（两个端点为a,b），e若满足下列条件，则称之为Delaunay边：存在一个圆经过a,b两点，圆内(注意是圆内，圆上最多三点共圆)不含点集V中任何其他的点，这一特性又称空圆特性。
【定义】Delaunay三角剖分：如果点集V的一个三角剖分T只包含Delaunay边，那么该三角剖分称为Delaunay三角剖分。
1.3.Delaunay三角剖分的准则
要满足Delaunay三角剖分的定义，必须符合两个重要的准则：
1、空圆特性：Delaunay三角网是唯一的（任意四点不能共圆），在Delaunay三角形网中任一三角形的外接圆范围内不会有其它点存在。如下图所示：

2、最大化最小角特性：在散点集可能形成的三角剖分中，Delaunay三角剖分所形成的三角形的最小角最大。从这个意义上讲，Delaunay 三角网是“最接近于规则化的“的三角网。具体的说是指在两个相邻的三角形构成凸四边形的对角线，在相互交换后，六个内角的最小角不再增大。如下图所示：

1.4.Delaunay三角剖分的特性
以下是Delaunay剖分所具备的优异特性：
1.最接近：以最近临的三点形成三角形，且各线段(三角形的边)皆不相交。
2.唯一性：不论从区域何处开始构建，最终都将得到一致的结果。
3.最优性：任意两个相邻三角形形成的凸四边形的对角线如果可以互换的话，那么两个三角形六个内角中最小的角度不会变大。
4.最规则：如果将三角网中的每个三角形的最小角进行升序排列，则Delaunay三角网的排列得到的数值最大。
5.区域性：新增、删除、移动某一个顶点时只会影响临近的三角形。
6.具有凸多边形的外壳：三角网最外层的边界形成一个凸多边形的外壳。
1.5.局部最优化处理
理论上为了构造Delaunay三角网，Lawson提出的局部优化过程LOP(Local Optimization Procedure)，一般三角网经过LOP处理，即可确保成为Delaunay三角网，其基本做法如下所示：
1.将两个具有共同边的三角形合成一个多边形。
2.以最大空圆准则作检查，看其第四个顶点是否在三角形的外接圆之内。
3.如果在，修正对角线即将对角线对调，即完成局部优化过程的处理。
LOP处理过程如下图所示：

2.Delaunay剖分的算法
Delaunay剖分是一种三角剖分的标准，实现它有多种算法。
2.1.Lawson算法
逐点插入的Lawson算法是Lawson在1977年提出的，该算法思路简单，易于编程实现。基本原理为：首先建立一个大的三角形或多边形，把 所有数据点包围起来，向其中插入一点，该点与包含它的三角形三个顶点相连，形成三个新的三角形，然后逐个对它们进行空外接圆检测，同时用Lawson设计 的局部优化过程LOP进行优化，即通过交换对角线的方法来保证所形成的三角网为Delaunay三角网。
上述基于散点的构网算法理论严密、唯一性好，网格满足空圆特性，较为理想。由其逐点插 入的构网过程可知，遇到非Delaunay边时，通过删除调整，可以构造形成新的Delaunay边。在完成构网后，增加新点时，无需对所有的点进行重新 构网，只需对新点的影响三角形范围进行局部联网，且局部联网的方法简单易行。同样，点的删除、移动也可快速动态地进行。但在实际应用当中，这种构网算法当 点集较大时构网速度也较慢，如果点集范围是非凸区域或者存在内环，则会产生非法三角形。
2.2.Bowyer-Watson算法
Lawson算法的基本步骤是：
1、构造一个超级三角形，包含所有散点，放入三角形链表。
2、将点集中的散点依次插入，在三角形链表中找出其外接圆包含插入点的三角形（称为该点的影响三角形），删除影响三角形的公共边，将插入点同影响三角形的全部顶点连接起来，从而完成一个点在Delaunay三角形链表中的插入。
3、根据优化准则对局部新形成的三角形进行优化。将形成的三角形放入Delaunay三角形链表。
4、循环执行上述第2步，直到所有散点插入完毕。
这一算法的关键的第2步图示如下：