文章不错，谢谢

任何问题都可以通过增加间接层次的方法解决。

我想在一个类层次(class hierarchy)中增加一个新的虚函数，但是这个类层次是由另外一帮人维护的，其他人碰都不能碰： class Personnel { public: virtual void Pay ( /*...*/ ) = 0; virtual void Promote( /*...*/ ) = 0; virtual void Accept ( PersonnelV& ) = 0; // ... other functions ... }; class Officer : public Personnel { /* override virtuals */ }; class Captain : public Officer { /* override virtuals */ }; class First : public Officer { /* override virtuals */ }; 我想要一个函数，如果对象是船长(Captain)就这么做，如果是大副(First Officer)就那么做。Virtual function正是解决之道，在Personnel或者Officer中声明它，而在Captain和First覆盖(override)它。 糟糕的是，我不能增加这么一个虚函数。我知道可以用RTTI给出一个解决方案： void f( Officer &o ) { if( dynamic_cast<Captain*>(&o) ) /* do one thing */ else if( dynamic_cast<First*>(&o) ) /* do another thing */ } int main() { Captain k; First s; f( k ); f( s ); } /* A not-atypical C program */ void f(struct someStruct *s) { switch(s->type) { case APPLE: /* do one thing */ break; case ORANGE: /* do another thing */ break; /* ... etc. ... */ } } “很好，小菜鸟。C语言门徒通常老习惯改不掉。但是，你应该知道，通过使用virtual function，你增加了一个间接层次。”她放下笔，“你所需要的不就是一个新的虚函数吗？” “是的。可是我没有权力这么干。” “因为你无权修改类层次，对吧！” “您终于了解了情况，我们没法动它。也不知道这个该死的类层次是哪个家伙设计的...” 我嘀嘀咕咕着。 “是我设计的。” “啊...，真的？！这个，嘿嘿...”，我极为尴尬。 “这个类层次必须非常稳定，因为有跨平台的问题。但是它的设计允许你增加新的virtual function，而不必烦劳RTTI。你可以通过增加一个间接层次的办法解决这个问题。请问，Personnel::Accept是什么?” ”嗯，这个...” “这个类实现了一个模式，可惜这个模式的名字起得不太好，是个PNP，叫Visitor模式。” [译者注：PNP，Poor-Named Pattern, 没起好名字的模式] “啊，我刚刚读过Visitor模式。但是那只不过是允许若干对象之间相互迭代访问的模式，不是吗？” 她叹了一口气，“这是流行的错误理解。那个V，我觉得毋宁说是Visitor，还不如说是Virtual更好。这个PNP最重要的用途是允许在不改变类层次的前提下，向已经存在的类层次中增加新的虚函数。首先来看看Personnel及其派生类的Accept实现细节。”她拿起笔写下： void Personnel::Accept( PersonnelV& v ) { v.Visit( *this ); } void Officer::Accept ( PersonnelV& v ) { v.Visit( *this ); } void Captain::Accept ( PersonnelV& v ) { v.Visit( *this ); } void First::Accept ( PersonnelV& v ) { v.Visit( *this ); } “Visitor的基类如下：” class PersonnelV/*isitor*/ { public: virtual void Visit( Personnel& ) = 0; virtual void Visit( Officer& ) = 0; virtual void Visit( Captain& ) = 0; virtual void Visit( First& ) = 0; }; “啊，我记起来了。当我要利用Personnel类层次的多态性时，我只要调用Personnel::Accept(myVisitorObject)。由于Accept是虚函数，我的myVisitorObject.Visit()会针对正确的对象类型调用，根据重载法则，编译器会挑选最贴切的那个 Visit来调用。这不相当于增加了一个新的虚拟函数了吗？” “没错，小菜鸟。只要类层次支持Accept，我们就可以在不改动类层次的情况下增加新的虚函数了。” “好了，我现在知道该怎么办了”，我写道： class DoSomething : public PersonnelV { public: virtual void Visit( Personnel& ); virtual void Visit( Officer& ); virtual void Visit( Captain& ); virtual void Visit( First& ); }; void DoSomething::Visit( Captain& c ) { if( femaleGuestStarIsPresent ) c.TurnOnCharm(); else c.StartFight(); } void DoSomething::Visit( First& f ) { f.RaiseEyebrowAtCaptainsBehavior(); } void f( Personnel& p ) { p.Accept( DoSomething() ); // 相当于 p.DoSomething() } int main() { Captain k; First s; f( k ); f( s ); } from:http://topic.csdn.net/t/20051231/14/4492965.html

今天开始学习设计模式中的第三个类型——行为型模式。 行为模式： 行为型模式涉及到算法和对象间职责的分配。将注意力从控制流转移到对象间的联系方式上来。 行为模式分为：行为类模式和行为对象模式。行为类模式使用继承机制在类间分派行为；行为对象模式使用对象复合而不是继承。 Template Method模板方法模式 Template Method模板方法模式介绍： Template Method模板方法模式是一种行为型模式，具体点说是行为类型模式。主要解决在软件构建过程中，对于某一项任务，常常有稳定的整体操作结构，但各个子步骤却有很多改变的需求，或者由于固有的原因而无法和任务的整体结构同时实现。 GoF《设计模式》中说道：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤 Template Method模式的结构 定义场景 单看结构不好理解，我们来结合程序进行分析。现在定义一个场景：我想大家都玩过极品飞车（我相当喜欢）。游戏中有很多的汽车，但是从操作角度看大同小异。无非是起步（StartUp）、行驶（Run）、停车（Stop）等等行为。汽车行驶的动作之间可能存在着差异，例如：手动档和自动档，但是接口是一样的，换句话说，基本都是这几个动作。结合Template Method模式讲就是在这个程序中，结构（对汽车的操作）是稳定的，但是变化在于各个子步骤（操作行为的具体实现）。 程序实现与结构分析 首先我们需要一个汽车的抽象类（结构图中的AbstractClass） public abstract class AbstractCar { protected abstract string StartUp(); protected abstract string Run(); protected abstract string Stop(); public void DriveOnTheRoad() { Console.WriteLine(StartUp()); Console.WriteLine(Run()); Console.WriteLine(Stop()); } } 在这段代码中，抽象方法StartUp、Run、Stop叫做primitive operation（原语操作），它们是在子类中的扩展点，例如我们要编写一辆BORA的实现，在他继承AbstractCar后，可以在这几个primitive operation上进行自己个步骤的实现。 AbstractCar中的DriveOnTheRoad方法叫做template method（模板方法），template method用primitive operation定义一个算法，是相对稳定的部分。（子类中重新定义primitive operation）。 然后我们要实现一辆BORA汽车（结构图中的ConcreteClass） public class BORA : AbstractCar { protected override string StartUp() { return "BORA is StartUp"; } protected override string Run() { return "BORA is Running"; } protected override string Stop() { return "BORA is Stoped"; } } 接下来我们进行客户程序的实现 class Program { static void Main(string[] args) { ClientApp.Drive(new BORA()); Console.Read(); } } public class ClientApp { public static void Drive(AbstractCar car) { car.DriveOnTheRoad(); } } 运行结果如下： BORA is StartUp BORA is Running BORA is Stoped Template Method要点 1、 Template Method模式是一种非常基础性的设计模式，在面向对象系统中有着大量的应用。它用最简洁的机制（虚函数的多态性）为了很多应用程序框架提供了灵活的扩展点，是代码复用方面的基本实现结构。 2、 除了可以灵活应对子步骤的变化外，“Don't call me.Let me Call you”的反向控制结构是Template Method的典型应用。“Don’t call me.Let me Call you”是指一个父类调用一个子类的操作，而不是相反。 3、 在具体实现方面，被Template Method调用的虚方法可以具有实现，也可以没有任何实现（抽象方法、纯虚方法），但一般推荐将它们设置为protected方法。可以没有具体实现的方法应该称为hook operation（钩子操作），提供了缺省的行为，子类可以在必要时进行扩展。 4、 尽量减少primitive operation，因为需要重新定义的操作越多，客户程序就越长

重构的原则 在对一个继承的等级结构做重构时，一个应当遵从的原则便是将行为尽量移动到结构的高端，而将状态尽量移动到结构的低端。 1995年，Auer曾在文献【AUER95】中指出： 1. 应当根据行为而不是状态定义一个类。也就是说，一个类的实现首先建立在行为的基础之上，而不是建立在状态的基础之上。 2. 在实现行为时，是用抽象状态而不是用具体状态。如果一个行为涉及到对象的状态时，使用间接的引用而不是直接的引用。换言之，应当使用取值方法而不是直接引用属性。 3. 给操作划分层次。一个类的行为应当放到一个小组核心方法（Kernel Methods）里面，这些方法可以很方便地在子类中加以置换。 4. 将状态属性的确认推迟到子类中。不要在抽象类中过早地声明属性变量，应将它们尽量地推迟到子类中去声明。在抽象超类中，如果需要状态属性的话，可以调用抽象的取值方法，而将抽象的取值方法的实现放到具体子类中。 如果能够遵从这样的原则，那么就可以在等级结构中将接口与实现分隔开来，将抽象与具体分割开来，从而保证代码可以最大限度地被复用。这个过程实际上是将设计师引导到模版方法模式上去。

ShellSort #include "StdAfx.h" #include "ShellSortClass.h" ShellSortClass::ShellSortClass(void) { } ShellSortClass::~ShellSortClass(void) { } void ShellSortClass::Shell_Sort_Ini(std::vector<int> _IntVector, int _Size) { for(int i=0;i<_Size;i++) { IntVector.push_back(_IntVector[i]); } VectorSize=_Size; } void ShellSortClass::Shell_Sort_RunSort() { int SwapValue,j; int Gap=VectorSize/2; while(Gap) { for(int i=Gap;i<VectorSize;i++) { j=i; SwapValue=IntVector[i]; while(j>=Gap&&SwapValue<IntVector[j-Gap]) { IntVector[j]=IntVector[j-Gap]; j=j-Gap; } IntVector[j]=SwapValue; } Gap=Gap/2; } } void ShellSortClass::Shell_Sort_Output() { for(int i=0;i< IntVector.size();i++) { cout<<IntVector[i]<<" "; if(i>5&&i%10==0) cout<<endl; } cout<<endl; }

http://hi.baidu.com/tjulxh/blog/item/cb89e8d556166806a08bb76b.html

from:http://www.vckbase.com/document/viewdoc/?id=1036

引用（reference）是c++的初学者比较容易迷惑的概念。下面我们比较详细地讨论引用。 一、引用的概念 引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似，只是用&代替了*。 例如： Point pt1(10,10); Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义，pt1和pt2表示同一对象。 需要特别强调的是引用并不产生对象的副本，仅仅是对象的同义词。因此，当下面的语句执行后： pt1.offset（2，2）； pt1和pt2都具有（12，12）的值。 引用必须在定义时马上被初始化，因为它必须是某个东西的同义词。你不能先定义一个引用后才 初始化它。例如下面语句是非法的： Point &pt3； pt3=pt1； 那么既然引用只是某个东西的同义词，它有什么用途呢？ 下面讨论引用的两个主要用途：作为函数参数以及从函数中返回左值。 二、引用参数 1、传递可变参数 传统的c中，函数在调用时参数是通过值来传递的，这就是说函数的参数不具备返回值的能力。 所以在传统的c中，如果需要函数的参数具有返回值的能力，往往是通过指针来实现的。比如，实现 两整数变量值交换的c程序如下： void swapint(int *a,int *b) { int temp; temp=*a; a=*b; *b=temp; } 使用引用机制后，以上程序的c++版本为： void swapint(int &a,int &b) { int temp; temp=a; a=b; b=temp; } 调用该函数的c++方法为：swapint（x,y); c++自动把x,y的地址作为参数传递给swapint函数。 2、给函数传递大型对象 当大型对象被传递给函数时，使用引用参数可使参数传递效率得到提高，因为引用并不产生对象的 副本，也就是参数传递时，对象无须复制。下面的例子定义了一个有限整数集合的类： const maxCard=100; Class Set { int elems[maxCard]; // 集和中的元素，maxCard 表示集合中元素个数的最大值。 int card; // 集合中元素的个数。 public: Set () {card=0;} //构造函数 friend Set operator * (Set ,Set ) ; //重载运算符号*，用于计算集合的交集 用对象作为传值参数 // friend Set operator * (Set & ,Set & ) 重载运算符号*，用于计算集合的交集 用对象的引用作为传值参数 ... } 先考虑集合交集的实现 Set operator *( Set Set1,Set Set2) { Set res; for(int i=0;i<Set1.card;++i) for(int j=0;j>Set2.card;++j) if(Set1.elems[i]==Set2.elems[j]) { res.elems[res.card++]=Set1.elems[i]; break; } return res; } 由于重载运算符不能对指针单独操作，我们必须把运算数声明为 Set 类型而不是 Set * 。 每次使用*做交集运算时，整个集合都被复制，这样效率很低。我们可以用引用来避免这种情况。 Set operator *( Set &Set1,Set &Set2) { Set res; for(int i=0;i<Set1.card;++i) for(int j=0;j>Set2.card;++j) if(Set1.elems[i]==Set2.elems[j]) { res.elems[res.card++]=Set1.elems[i]; break; } return res; } 三、引用返回值 如果一个函数返回了引用，那么该函数的调用也可以被赋值。这里有一函数，它拥有两个引用参数并返回一个双精度数的引用： double &max(double &d1,double &d2) { return d1>d2?d1:d2; } 由于max()函数返回一个对双精度数的引用，那么我们就可以用max() 来对其中较大的双精度数加1： max(x,y)+=1.0; C++引用与指针的比较 引用是C++中的概念，初学者容易把引用和指针混淆一起。 一下程序中，n是m的一个引用（reference），m是被引用物（referent）。 int m; int &n = m; n相当于m的别名（绰号），对n的任何操作就是对m的操作。 所以n既不是m的拷贝，也不是指向m的指针，其实n就是m它自己。 引用的规则： （1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。 （2）不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）。 （3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。 以下示例程序中，k被初始化为i的引用。 语句k = j并不能将k修改成为j的引用，只是把k的值改变成为6。 由于k是i的引用，所以i的值也变成了6。 int i = 5; int j = 6; int &k = i; k = j; // k和i的值都变成了6; 引用的主要功能是传递函数的参数和返回值。 C++语言中，函数的参数和返回值的传递方式有三种：值传递、指针传递和引用传递。 以下是"值传递"的示例程序。 由于Func1函数体内的x是外部变量n的一份拷贝，改变x的值不会影响n, 所以n的值仍然是0。 void Func1(int x) { x = x + 10; } ... int n = 0; Func1(n); cout << "n = " << n << endl; // n = 0 以下是"指针传递"的示例程序。 由于Func2函数体内的x是指向外部变量n的指针，改变该指针的内容将导致n的值改变，所以n的值成为10。 void Func2(int *x) { (* x) = (* x) + 10; } ... int n = 0; Func2(&n); cout << "n = " << n << endl; // n = 10 以下是"引用传递"的示例程序。 由于Func3函数体内的x是外部变量n的引用，x和n是同一个东西，改变x等于改变n，所以n的值成为10。 void Func3(int &x) { x = x + 10; } ... int n = 0; Func3(n); cout << "n = " << n << endl; // n = 10 对比上述三个示例程序，会发现"引用传递"的性质象"指针传递"，而书写方式象"值传递"。 实际上"引用"可以做的任何事情"指针"也都能够做，为什么还要"引用"这东西？ 答案是"用适当的工具做恰如其分的工作"。 指针能够毫无约束地操作内存中的任何东西，尽管指针功能强大，但是非常危险。 如果的确只需要借用一下某个对象的"别名"，那么就用"引用"，而不要用"指针"，以免发生意外。

#include "file.h"
#include <iostream>
#include <fstream>

using namespace std;

file::file(void)
{
file::OutFilePath="C:\\file.txt";
file::StopInput="exit";
}
void file::CreatTextFile()
{
ofstream OutFile(file::OutFilePath.c_str());

cout<<"Please input information to save:"<<endl;
cin>>file::UserInputWord;
int CompResult;
CompResult=UserInputWord.compare(StopInput);
while(CompResult!=0)
{
cin>>file::UserInputWord;
OutFile<<file::UserInputWord<<endl;
CompResult=UserInputWord.compare(StopInput);
}
//close the fileStream hand
OutFile.close();
cout <<"finish input and save the information."<<endl<<endl;
}
void file::ReadTextFile()
{
cout<<"Began invoke the readTextFile fuction."<<endl;
ifstream ReadFile(file::OutFilePath.c_str());
while(!ReadFile.eof())
{
getline(ReadFile,file::UserReadWord);
cout<<file::UserReadWord<<endl;
}
ReadFile.close();
cout<<"End invoke the readTextFile fuction."<<endl;
}

file::~file(void)
{
}

谢谢！我纠结了半天，终于找到解决方法了。我参考了你的文章。

copy from baidu?

Comment Your Code All code should be commented, and stored procedures are no different. Adding comments will not affect performance at all, so there is no downside here (other than the time it takes to write them). The benefits are numerous and include making it easier for others (and yourself) to understand the code and safer to make changes at a later date.

One of the most common uses of views is to hide complex SQL, and this often involves joins.

To remove a view, the DROP statement is used. The syntax is simply DROP VIEW viewname;.

To overwrite (or update) a view you must first DROP it and then recreate it.

Like tables, views must be uniquely named. (They cannot be named with the name of any other table or view).

There is no limit to the number of views that can be created.

To create views, you must have security access. This is usually granted by the database administrator.

Views can be nested; that is, a view may be built using a query that retrieves data from another view. The exact number of nested levels allowed varies from DBMS to DBMS. (Nesting views might seriously degrade query performance, so test this thoroughly before using it in production environments.)

Many DBMSs prohibit the use of the ORDER BY clause in view queries.

The more tables you join the more performance will degrade.

As just explained, breaking data into multiple tables enables more efficient storage, easier manipulation, and greater scalability. But these benefits come with a price.

成大事的九种手段：

1、敢于决断——克服犹豫不定的习性

很多人之所以一事无成，最大的毛病就是缺乏敢于决断的手段，总是左顾右盼、思前想后，从而错失成功的最佳时机。成大事者在看到事情的成功可能性到来时，敢于做出重大决断，因此取得先机。

2、挑战弱点——彻底改变自己的缺陷

人人都有弱点，不能成大事者总是固守自己的弱点，一生都不会发生重大转变；能成大事者总是善于从自己的弱点上开刀，去把自己变成一个能力超强的人。一个连自己的缺陷都不能纠正的人，只能是失败者！

3、突破困境——从失败中撮成功的资本

人生总要面临各种困境的挑战，甚至可以说困境就是“鬼门关”。一般人会在困境面前浑身发抖，而成大事者则能把困境变为成功的有力跳板。

4、抓住机遇——善于选择、善于创造

机遇就是人生最大的财富。有些人浪费机遇轻而易举，所以一个个有巨大潜力的机遇都悄然溜跑，成大事都是绝对不允许溜走，并且能纵身扑向机遇。

5、发挥强项——做自己最擅长的事情

一个能力极弱的人肯定难以打开人生局面，他必定是人生舞台上重量级选手的牺牲品；成大事者关于在自己要做的事情上，充分施展才智，一步一步地拓宽成功之路。

6、调整心态——切忌让情绪伤害自己

心态消极的人，无论如何都挑不起生活和重担，因为他们无法直面一个个人生挫折，成大事者则关于高速心态，即使在毫无希望时，也能看到一线成功的亮光。

7、立即行动——只说不做，徒劳无益

一次行动胜过百遍心想。有些人是“语言的巨人，行动的矮子”，所以看不到更为实际现实的事情在他身上发生；成大事者是每天都靠行动来落实自己的人生计划的。

8、善于交往——巧妙利用人力资源

一个人不懂得交往，必然会推动人际关系的力量。成大事者的特点之一是：善于靠借力、借热去营造成功的局势，从而能把一件件难以办成的事办成，实现自己人生的规划。

9、重新规划——站到更高的起点上

人生是一个过程，成功也是一个过程。你如果满足于小成功，就会推动大成功。成大事者懂得从小到大的艰辛过程，所以在实现了一个个小成功之后，能继续拆开下一个人生的“密封袋”。

可以讲任何一种手段，都可以导致一种结果，但这个结果是不是最佳的结果，恐怕就很难说了。成大事者总是选择最佳的手段，达到最完善的结果，这就是非一般人所能做到的。因此在成功之路上，你要想成大事，首先要解决的问题就是：你的手段对你推动成功的计划是否立竿见影！

成大事必备九种能力

挑战生存的能力：善于在现实中寻找答案

1、 摆正心态，敢于面对现实

对于那些不停地抱怨现实恶劣的人来说，不能称心如意的现实，就如同生活的牢笼，既束缚手脚，又束缚身心，因此常屈从于现实的压力，成为懦弱者；而那些真正成大事的人，则敢于挑战现实，在现实中磨炼自己的生存能力，这就叫强者！

在此，我们可以得出一条成大事的经验：适应现实的变化而迅速改变自己的观念，最重要的是需要我们有一副聪慧的头脑和灵活的眼睛，做生活的有心人。

在现实的压力之下，如果你能改变观念，适时而进，可收到事半功倍的效果。

我们的自下而上须臾离不开现实，随着现实的变化，我们必须随之调整自己的观念、思想、行动及目标。这是生存的必须。

如果我们有办法来改变现实，使之适合我们能力和欲望的发展需要，则是最难能可贵的。

2、 让你拥有过硬的自制能力

自制，就是要克服欲望，不要因为有点压力就心里浮躁，遇到一点不称心的事就大发脾气。

一个人除非先控制了自己，否则将无法控制别人。

一个人只要有成大事的目标，知道自己想要的，然后采取行动，告诉自己绝对不要放弃，成功只是时间早晚而已。

假使你在途中遇上了麻烦或阻碍，你就去面对它、解决它、然后再继续前进，这样问题才不会愈积愈多。

你在一步步向上爬时，千万别对自己说“不”，因为“不”也许导致你决心的动摇，放弃你的目标，从而前功尽弃。

人最难战胜的是自己，这话的含义是说，一个人成功的最大障碍不是来自于外界是，而是自身。只有控制住自己，才能控制住压力，让压力在你面前屈服。

3、 把情感装入理性之盒

一种抵触情绪的产生往往是潜移默化的，但它对人一生的影响却是巨大的，这种影响从诸多小事上体现出来。我们应尽量消除自己的不良情绪、因为它不仅会给我们造成身心上的伤害，而且在我们通往成功的路途上，不良情绪有时会成为绊脚石。

为了你的成功，你必须把情感装入理性之盒，你必须去适应别人，适应形势，不然的话，你注定成不了大事，注定会被淘汰。

4、 独处可以激发思考的力量

如果你知道怎么独处的话，成大事者都是善于独处的人——在独处的过程中激发思考的力量。

自卑可以像一座大山把人压倒并让你永远沉默，也可以像推进器产生强大的动力。

比别人先走一步，能创造一种成功的心境。

在独处时，你应当有所思考，不要总人浮于事。

5、 压力是最好的推动力

欲成大事者，因目标高远，压力可能会更大。但若欲成大事，就必须能承受这种压力，把压力当成推进人生的动力。

人们最出色的工作往往是在外于逆境的情况下做出的。人要有所为就要有所不为。应做的一定要做好，不该做的坚决不做。

得到的并不一定就值得庆幸，失去的也并不完全是坏事情。

6、以变应变，才有出路

顺应时势，善于变化，及时调整自己的行动方案，这是成大事者适应现实的一种方法。

一个人如果没有和人打交道的高超技巧，没有把各种情况都考虑周全的头脑，灵活应变的手段，就根本无法驾驭大的局面，将很难成大事。

一个人能看清自己的现状，心态就会平衡许多，就能以一种客观的眼光去看待，认识这个世界，并且相应地调整自己的行为。

7、 自信心是人生的坚强支柱

自信心充足者的适应能力就高，反之则适应能力较低。

一般信心不足较严重的人常有一些身心症状，比如孤僻，害怕与人交往，说话过于偏激，悲观失望。

如果做事成功的经验越多，那么自信心就越强。

自我成功锻炼的机会越少，自信心就越弱，以致产生严重的自卑情绪。

十九世纪的思想家爱默生说：“相信自己‘能’，便会攻无不克。”拿破仑说：“在我的字典里没有不可能。”

8、 把精力投入到自己的强项上

大多数人的生活层次只停留在：为吃饭而吃、为搭公车而搭、为工作而工作、为了回家而回家。

成大事者与不成大事者只差别在一些小小的动作：每天花5分钟阅读、多打一个电话、多努力一点、在适当时机的一个表示、表演上多费一点心思、多做一些研究，或在实验室中多试验一次。

在行动之前你自己就知道你是否足以胜任这一个任务。

没有任何借口可以解释你为会么长时间仍然无法胜任一项工作。

不论你想追求的是什么，你必须强迫自己增强能力以实现目标。

勤加练习、勤加练习、最后还是勤加练习！决不放弃学习，而且一定要将学到的知识运用于日常生活中。

9、 要专心地做好一件事

如果大多数人集中精力专注于一项工作，他们都能把这项工作做得很好。

最成大事者的商人是能够迅速而果断作出决定的人，他们总是首先确定一个明确的目标，并集中精力，专心致志地朝这个目标努力。

一次只专心地做一件事，全身心地投入并积极地希望它成功，这样你的心里就不会感到筋疲力尽。

把你需要做的事想象成是一大排抽屉中的一个小抽屉。不要总想着所有的抽屉，而要将精力集中于你已经打开的那个抽屉。每个人做人办事的手段都是不一样的，可以讲，一个人就有一种手段，一个人就有一种靠自己手段获得成功的途径。无数事实表明，有些人就是太过于自信，想念自己确认的手段能够解决任何问题，但不知道这种往往是起

成大事必备的9种心态

心态之一：积极向上

1.时刻想着出人头地

2.做“小人物”时要向“大人物”看齐

3.惟有进取心，才能成大事

4.摒弃逆境的干扰，寻找向上的根源

5.放弃也是一种成功的开始

6.在平凡中做不平凡的事

7.保持年轻的心态很重要

8.永远积极、主动、热忱

心态之二：勤勉谦恭

1.壮志凌云地想，脚踏实地地干

2.勤敬产业，谦恭做人

3.勤勉高于天赋

4.勤奋造就成功，懒惰摧毁天才

5.养成勤奋的习惯会终生受益

6.有一份耕耘，就有一份收获

7.恒心与支持能“点石成金”

8.莫道君行早，更有早行人

心态之三：诚实守信

1.诚实是一种源自自身的本质

2.诚实守信才是大赢家

3.以诚信奠定成功基业

4.真诚的友谊会使你的事业更发达

5.做人要有正直的品行

6.诚实守信是成大事的“信用卡”

7.要成大事，择友不可草率

8.以真诚待人，用热忱做事

心态之四：敢于挑战

1.敢于挑战自我，克服贬低心理

2.挑战无极限

3.坚持到底造靠勇气，半途而废是懦夫

4.用于挑战激起成大事的信心

5.勇气是战胜困难的良方

6.胜人者力，自胜者强

7.毅力与恒心是成大事的基本功

8.坚持不懈成大事，浅尝辄止无出路

心态之五：善于合作

心态之六：知足平衡

心态之七：乐观豁达

心态之八：宽厚容人

心态之九：永远自信

As you can see, SQL's wildcards are extremely powerful. But that power comes with a price: Wildcard searches typically take far longer to process than any other search types discussed previously. Here are some tips to keep in mind when using wildcards:

Don't overuse wildcards. If another search operator will do, use it instead.

When you do use wildcards, try to not use them at the beginning of the search pattern unless absolutely necessary. Search patterns that begin with wildcards are the slowest to process.

Pay careful attention to the placement of the wildcard symbols. If they are misplaced, you might not return the data you intended.

Having said that, wildcards are an important and useful search tool, and one that you will use frequently.

The brackets ([]) wildcard is used to specify a set of characters, any one of which must match a character in the specified position (the location of the wildcard).

Sets Are Not Always Supported Unlike the wildcards described thus far, the use of [] to create sets is not supported by all DBMSs. Sets are supported by Microsoft Access, Microsoft SQL Server, and Sybase Adaptive Server. Consult your DBMS documentation to determine whether sets are supported.





For example, to find all contacts whose names begin with the letter J or the letter M, you can do the following:



SELECT cust_contact

FROM Customers

WHERE cust_contact LIKE '[JM]%'

ORDER BY cust_contact;






cust_contact

-----------------

Jim Jones

John Smith

Michelle Green


The WHERE clause in this statement is '[JM]%'. This search pattern uses two different wildcards. The [JM] matches any contact name that begins with either of the letters within the brackets, and it also matches only a single character. Therefore, any names longer than one character do not match. The % wildcard after the [JM] matches any number of characters after the first character, returning the desired results.



This wildcard can be negated by prefixing the characters with ^ (the carat character). For example, the following matches any contact name that does not begin with the letter J or the letter M (the opposite of the previous example):

The Underscore (_) Wildcard
Another useful wildcard is the underscore (_). The underscore is used just like %, but instead of matching multiple characters, the underscore matches just a single character.

Microsoft Access Wildcards If you are using Microsoft Access, you might need to use ? instead of _.





Take a look at this example:



SELECT prod_id, prod_name

FROM Products

WHERE prod_name LIKE '__ inch teddy bear';


Watch for Trailing Spaces As in the previous example, you might have to append a wildcard to the pattern for this example to work.

Why use the IN operator? The advantages are

When you are working with long lists of valid options, the IN operator syntax is far cleaner and easier to read.

The order of evaluation is easier to manage when IN is used (as there will be fewer operators used).

IN operators almost always execute more quickly than lists of OR operators.

The biggest advantage of IN is that the IN operator can contain another SELECT statement, enabling you to build highly dynamic WHERE clauses. You'll look at this in detail in Lesson 11, "Working with Subqueries."

IN A keyword used in a WHERE clause to specify a list of values to be matched using an OR comparison.

The IN operator is used to specify a range of conditions, any of which can be matched. IN takes a comma-delimited list of valid values, all enclosed within parentheses. The following example demonstrates this:



SELECT prod_name, prod_price

FROM Products

WHERE vend_id IN ('DLL01','BRS01')

ORDER BY prod_name;

The difference is that count(*) counts the number of rows and is thus unaffected by any null values contained in a row, while count(val) counts the number of values contained in the val column and ignores any null values encountered.

count(val) counts the number of values contained in the val column and ignores any null values encountered.

When performing aggregations, or, indeed, any type of numeric calculation, you should always consider how null values might affect the outcome of your calculation.

Aggregate functions perform a specific operation over all rows in a group

mysql> SELECT open_emp_id, COUNT(*) how_many
-> FROM account
-> GROUP BY open_emp_id;
+-------------+----------+
| open_emp_id | how_many |
+-------------+----------+
| 1 | 8 |
| 10 | 7 |
| 13 | 3 |
| 16 | 6 |
+-------------+----------+
4 rows in set (0.00 sec)


The aggregate function count( ) counts the number of rows in each group, and the asterisk tells the server to count everything in the group. Using the combination of a group by clause and the count( ) aggregate function, you are able to generate exactly the data needed to answer the business question without having to look at the raw data.

2.4 自身连接
自身连接是指同一个表自己与自己进行连接。这种一元连接通常用于从自反关系（也称作递归关系）中抽取数据。例如人力资源数据库中雇员与老板的关系。
下面例子是在机构表中查找本机构和上级机构的信息。
select s.inst_no superior_inst, s.inst_name sup_inst_name, i.inst_no, i.inst_name
from t_institution i
join t_institution s
on i.superior_inst = s.inst_no

结果是：
superior_inst sup_inst_name inst_no inst_name
800 广州市 5801 天河区
800 广州市 5802 越秀区
800 广州市 5803 白云区

自身连接是指同一个表自己与自己进行连接。这种一元连接通常用于从自反关系（也称作递归关系）中抽取数据。例如人力资源数据库中雇员与老板的关系。
下面例子是在机构表中查找本机构和上级机构的信息。

http://www.cnblogs.com/zping/

SQL SERVER，ORACLE数据库分析,设计,研究,优化,重构等

在该示例中，程序接收来自用户的字符串并将该字符串显示在消息框中。程序使用从 User32.dll 库导入的 MessageBox 方法。

using System;
using System.Runtime.InteropServices;
class MainClass
{
[DllImport("User32.dll")]
public static extern int MessageBox(int h, string m, string c, int type);

static int Main()
{
string myString;
Console.Write("Enter your message: ");
myString = Console.ReadLine();
return MessageBox(0, myString, "My Message Box", 0);
}
}

extern 修饰符用于声明在外部实现的方法。

extern 修饰符的常见用法是在使用 Interop 服务调入非托管代码时与 DllImport 属性一起使用。

在这种情况下，还必须将方法声明为 static。

// ======================================================
// 实现一个静态方法将指定文件夹下面的所有内容Detele
// 测试的时候要小心操作，删除之后无法恢复。
// April 18April2005 In STU
// ======================================================





Code
public static void DeleteDir(string aimPath)
{
try
{
// 检查目标目录是否以目录分割字符结束如果不是则添加之
if(aimPath[aimPath.Length-1] != Path.DirectorySeparatorChar)
aimPath += Path.DirectorySeparatorChar;
// 得到源目录的文件列表，该里面是包含文件以及目录路径的一个数组
// 如果你指向Delete目标文件下面的文件而不包含目录请使用下面的方法
// string[] fileList = Directory.GetFiles(aimPath);
string[] fileList = Directory.GetFileSystemEntries(aimPath);
// 遍历所有的文件和目录
foreach(string file in fileList)
{
// 先当作目录处理如果存在这个目录就递归Delete该目录下面的文件
if(Directory.Exists(file))
{
DeleteDir(aimPath+Path.GetFileName(file));
}
// 否则直接Delete文件
else
{
File.Delete (aimPath+Path.GetFileName(file));
}
}
//删除文件夹
System.IO .Directory .Delete (aimPath,true);
}
catch (Exception e)
{
MessageBox.Show (e.ToString());
}
}

面向对象设计原则中类的单一职责原则，一个类应当仅有一个引起它变化的原因

根据上面的分析，在以下的情况下应当使用桥梁模式：

* 如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系。
* 设计要求实现化角色的任何改变不应当影响客户端，或者说实现化角色的改变对客户端是完全透明的。
* 一个构件有多于一个的抽象化角色和实现化角色，系统需要它们之间进行动态耦合。
* 虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者。

1）Design to interfaces. 2)Favor composition over inheritance. 3)Find what varies and encapsulate it"的三个观点。）

实现共同点与变化点的分离（主要是外部的变化），将变化点封装成类处理。

依次类推直到递归结束，也就是完成System.Object内存分配为止。


因此，对象的创建过程是按照顺序完成了对整个父类及其本身字段的内存创建，并且字段的存储顺序是由

上到下排 列，object类的字段排在最前面

楼主 这两句好像矛盾了 应该先是Sysrem.Object内存分配--》父类体系--》》直到最下层的子类内存分配完为止

吧

你应该带着这一行：
作者:Anytao  来源:博客园  时间:2008-09-12  阅读:93 次  原文链接 

又学到了知识了，感谢！

@kunkun
啊~ 是这样啊 我这就添加上~ 谢谢2位啦~~

楼主，应该有个原文链接得提示哦。：）

@丁学
下面有转载的出处~~

轉載未保留出處，也未標明作者信息~~~~

收藏了，很全面。。

--引用--------------------------------------------------
SuperWulei: 故事很好，我感悟到许多人生哲理。
ps：第6个故事呢？
--------------------------------------------------------

我也是转贴的，其实只有５个故事，第６个是让人回贴的一个故事，哈哈　

第6个你已经具备啦　看了文章之后回帖～　

故事很好，我感悟到许多人生哲理。
ps：第6个故事呢？