欧美婷婷久久,亚洲欧美日韩视频二区,欧美日韩影院

More Effective C++ (1)

rikisand — Mon, 18 Jan 2010 06:16:00 GMT

�W�四�?nbsp; 效率

······条款16 ��C��80-20准则

大约20%的代码��用了80%的资源，�E�序的整体性能是由该程序的一��部分代码所军_��的~

可行的办法是使用�E�序分析器（profiler�Q�来扑ֈ��D��性能瓉��的拿20%的程序~

而且要针寚w��成瓉��的资源来使用相应的分析器~

······条款17 考虑使用延迟计算

延迟计算�Q?也就是说知道�E�序要求�l�出�l�果的时候才�q�行�q�算~ 很好理解�Q�和操作�pȝ��中的cow copy on write 一个原理~

四个使用场景�Q?/font>

~1~ 引用计数 �Q?/font>

　　class String{…};

String s1 = “hello”;

String s2 = s1 ; //call string Copy ctor

通常情况下，s2赋值后会有一个hello的拷贝，者通常需要��用new操作�W�分配内存，之后strcpys1

的数据给他，但如果下面的操作如下的话�Q?/font>

cout << s1 ;

cout << s1 + s2;

�q�种情况下如果只增加s1的引用计敎ͼ�而s2只是�׃�ns1的值就可以了。只有在需要对s2�q�行修改或者s1�q�行修改�Ӟ��才需要真正拷贝给s2一个副本，引用计数的实现在29条款

~2~区分��d��操作

如： String s = “homer’s all”;

cout<< s[3];

s[3] = ‘x’;

在进行读操作�Ӟ��使用引用计数是开销很小的，然而写操作必须生成新的拯��。通过条款30的代理类我们可以把判断读写操作推�q�到我们能够军_��哪个是正��操作的时�?/font>

~3~延迟��d��

假设�E�序使用了包含许多数据成员的大对象，�q�些对象必须在每�ơ程序运行的时候保留下来，因此存进了数据库。某些时候从database中取出所有数据是没有必要的，比如他只讉K��该对象中的一个数据成员。此�Ӟ��应该对对象进行处理，只有对象内部某一个特定的数据成员被访问的时候才把他取出来。类��g��os中的按需换页~

class LargeObject{

    LargeObject(ObjectID id);

const string& field1() const;

int field2() const;

double field3() const;

const string& field4() const;

private:

ObjectID id;

mutable string* field1value;

mutable int   * fieldValue;

};

LargeObject::LargeObject(ObjectID id):oid(id),fieldValue(0),…{}

const string& LargeObject::field1()const{

   if(fieldValue == 0){

       //read the data for field 1 from database and make field1 point to it

   }

   return *field1Value;

}

实施lazy fetching ��M��成员函数都需要初始化�I�指针以指向有效数据。但是const成员函数中，试图修改数据�~�译器会报错。所以声明字�D�|��针�ؓ mutable �Q�表�C�Z�Q何函数都可以修改,即便在const成员函数中也可以~ 条款28中的��指针可以让这一�Ҏ��更灵�z?/font>

~3~延迟表达式求�?/font>

数��D��领域，也在使用延迟计算。例�?/font>

matrix m1(1000,1000);

matrix m2(1000,1000);

matrix m3 = m1 + m2;

如果此时计算出m3的话�q�算量非�怹�大~

但是如果此时�E�序为：

m3 = m4*m1;

那么刚才的计��就没必要了

如果cout<< m3[4];

我们只需要计��m3[4]��可以了�Q�其他的值等到确实需要他们的时候才予以计算~如果�q�气够好的话永远不需要计��~

�ȝ��Q��g�q�计��只有当软�g在某�U�程度下可以被避免时候才有意义~只有延迟计算得到的好处大于设计它与实现它��p��的精力时才有意义~

·······条款18�Q?分期摊还预期的计��开销

提前计算~ over-eager evaluation 在系�l�要求你做某些事情之前就做了他~

例如�Q�大量数据的集合

template

class DataCollection}{

public:

NumericalType min() const;

NumericalType max() const;

NumericalType avg() const;

};

使用提前计算�Q�我们随时跟�t�目前集合的最大最��^均��|��q�样 min max avg被调用时候，我们可以不用计算立刻�q�回正确的数值~~

提前计算的思想便是�Q�如果预计某个计��会被频�J�调用，你可以通过设计你的数据�l�构以更高效的办法处理请求，�q�样可以降低每次��h��的��^均开销~

最��单的做法�?�~�存已经计算�q��ƈ且很可能不需要重新计��的那些值~

例如在数据库中存有很多办公室的电话号码，�E�序在每�ơ查询电话时先查询本地的�~�存如果没找到再去访问数据库�Q��ƈ且更新缓存，�q�样使用�~�存�q�_��讉K��旉��要大大减��?/font>

预处理也是一�U�策略�?/font>

例如设计动态数�l�的时候，当烦引下标大于已有最大范围时候，需要new出新的空��_��如果甌��两倍于索引的大��的话就可以避免频繁的申��h��作~~~

········条款 19 �Q?了解临时对象的来�?/font>

如果一个对象被创徏�Q�不是在堆上�Q�没有名字，那么�q�个对象��是临时对象�?/font>

通常产生于： ��Z��使函数调用能够成功而进行的隐式转换�Q�或者函数返回对象是�q�行的隐式�{换。由于构造和析构他们带来的开销可以�l�你的程序带来显著的影响�Q�因此有必要了解他们~

~1首先考虑��Z��函数调用能通过产生的��时对象的情况

传给某个函数的对象的�c�d��和这个函数所�l�定的参数类型不一致的情况下会出现�q�种情况�?/font>

例如�Q?/font>

size_t count(const string& str,char ch);

函数定义��str中ch的数�?/font>

char buffer[100];

cout<

传入的是一个char数组�Q�此时编译器会调用str的构造函敎ͼ�利用buffer来创��Z��个��时对象�?/font>

在调用完countChar语句后这个��时对象就被自动销毁了~

仅当传值或者const引用的时候才会发生这��L��c�d��转换~当传递一个非帔R��引用的时候，不会发生�?/font>

void uppercasify(string& str); //change all chars in str to upper case;

在这个例子中使用char数组��׃��会成功~

因�ؓ�E�序作者声明非帔R��引用也就是想让对引用的修改反映在他引用的对象�w�上�Q�但是如果此时生成了临时对象�Q�那么这些修改只是作用在临时对象�w�上�Q�也��׃��是作者的本意了。所以c++��止非常量引用��生��时对象�?/font>

~2 函数�q�回对象时候会产生临时对象

例如�Q?const Number operator + ( const Number& lhs,const Number& rhs);

�q�个函数�q�回一个��时对象，因�ؓ他没有名字，只是函数的返回倹{�?/font>

条款20�?�Q�会介绍让编译器对已�l�超出生存周期的临时对象�q�行优化

········条款20�Q?协助�~�译器实现返回��g��?/font>

�q�回��g��化：�q�回带有参数的构造函数�?/font>

cosnt Rational operator * (cosnt Rational& lhs,const Rational& rhs){

return Rational(lhs.numerator()*rhs.numerator(),lhs.denomiator()*rhs.denominator()};

c++允许�~�译器针对超出生命周期的临时对象�q�行优化。因此如果调用Rational c=a*b�Q?/font>

c++允许�~�译器消除operator*内部的��时变量以及operator*�q�回的��时变量，�~�译器可以把return表达式所定义的返回对象构造在分配�l�c的内存上。如果这样做的话那么调用operator*所产生的��时对象所带来的开销��是0~ 我们可以把operator 声明为内联函数而去除调用构造函数带来的开销~

#include
#include
#include "time.h"
using namespace std;
char buffer[100];
class number{
public:
    const friend number operator * (const number& rhs,const number lhs);
    number(){}
    number(int b):a(b){}
    number(const number& rhs){
        a = rhs.a;
    }
      int a;
};
const number operator*(const number& rhs,const number lhs){
    number res;
    res.a = rhs.a * lhs.a;
        return res;
    /*return number(rhs.a*lhs.a);*/
}
//CLOCKS_PER_SEC
int main()
{
    clock_t start = clock();
    number A(5);number B(6);
    for(int i=0;i<100000000;i++)
        number C = A*B;

clock_t end = clock();
cout<}

通过上面的程序运�?如果没有�q�回��g��?�q�行旉�� 15.9s 优化后是 10.1s

�q�是很显著的�?快了33% �Q�如果这�U�情况出现在�E�序的热点处~效果��很好了

·········条款21 �Q?通过函数重蝲避免隐式�c�d��转换

例子�Q?/font>

class upint{

public:

upint();

upint(int value);

};

cosnt upint operator+(const upint&lhs,const upint&rhs);

upint up1,up2;

upint up3 = up1+up2;

upi3 = up1 +10;

upi4 = 10+ upi2;

�q�些语句也可以通过�Q�因为创��Z��临时对象�Q�通过带有int的构造函��C�生了临时的upint对象�Q�如果我们不愿意��些��时对象的产生与析构付��Z��P��我们需要做什么：

我们声明 cosnt upint operator+(cosnt upint&lhs,int rhs);

cosnt upint operator+(int lhs,const upint& rhs);

��可以去除��时对象��生了~

但是如果我们写了 const upint operator+(int lhs,int rhs); // 错了~

c++规定�Q�每一个被重蝲的运��符必须臛_��有一个参数属于用戯��定义�c�d��Q�int�q�不是自定义�c�d��所以上面的不对�?/font>

同样的如果希望string char* 作�ؓ参数的函敎ͼ�都有理由�q�行重蝲而避免隐形类型�{换（仅仅在有必要的时候，也就是说他们可以对程序效率�v到很大帮助的时候~�Q?/font>

··········条款�Q?考虑使用 op = 来取�?单独�?op�q�算�W?/font>

class Rational{

public:

Rational& operator+=(const Rational& rhs);

Rational& operator-=(const Rational& rhs);

}

const Rational operator+(cosnt Rational& lhs,const Rational & rhs){

return Rational(lhs)+=rhs;

}

利用+= -=来实�? -可以保证�q�算�W�的赋值�Ş式与单独使用�q�算�W�之间存在正常的关系�?/font>

Rational a,b,c,d,result;

result = a+ b+c+d; // 可能要用�?个��时对�?/font>

result +=a;result+=b;result+=c; //没有临时对象

前者书写维护都更容易，而且一般来说效率不存在问题�Q�但是特�D�情况下后者效率更高更可取

注意�Q?/font>

如果+的实现是�q�样的：

const T operator+ (constT& lhs,const T&rhs){

T result(lhs);

return result += rhs;

}

�q�个模版中包含有名字对象result�Q�这个对象有名字意味着�q�回��g��化不可用~~~~~~~~·

·······条款23 �Q?考虑使用其他�{��h的程序库

��L��Q?/font>

提供�c�M��功能的程序库通常在性能问题上采取不同的权衡措施�Q�比如iostream和stdio�Q�所以通过分析�E�序扑ֈ�软�g瓉��之后�Q�可以考虑是否通过替换�E�序库来消除瓉��~~~~

······条款24 : 理解虚函敎ͼ�多重�l�承�Q�虚基类以及 RTTI 带来的开销

虚函数表�Q�vtabs 指向虚函数表的指�?vptrs

�E�序中每个声明了或者��承了的虚函数的类都具有自��q��虚函数表。表中的各个��就是指向虚函数具体实现的指针�?/font>

class c1{

c1();

virtual ~c1();

virtual void f1();

virtual int f2(char c)const;

virtual void f3(const string& s);

};

c1 的虚函数表包括： c1::~c1 c1::f1 c1::f2 c1::f3

class c2:public c1{

c2();

virtual ~c2();

virtual void f1();

virtual void f5(char *str);

};

它的虚函数表入口指向的是那些由c1声明但是c2没有重定义的虚函数指针：

c2::~c2 c2::f1 c1::f2 c1::f3 c2::f5

所以开销上：必须为包含虚函数的类腑և�额外的空间来存放虚函数表。一个类的虚函数表的大小取决于它的虚函数的个敎ͼ�虽然每一个类只要有一个虚函数表，但是如果有很多类或者每个类��h��很多个虚函数�Q�虚函数表也会占据很大的�I�间�Q�这也是mfc没有采用虚函数实现消息机制的一个原因�?/font>

�׃��每一个类只需要一个vtbl的拷贝，把它攑֜�哪里是一个问题：

一�U�：为每一个需要vtbl的目标文件生成拷贝，然后�q�接时取出重复拷�?/font>

或者：更常见的是采用试探性算法决定哪一个目标文件应该包含类的vtbl。试探：一个类的vtbl通常产生在包含该�cȝ��一个非内联�Q�非�U�虚函数定义的目标文仉��。所以上面c1�cȝ��vtbl��放在c1::~c1 定义的目标文仉��。如果所有虚函数都声明�ؓ内联�Q�试探性算法就会失败，在每一个目标文件就会有vtbl。所以一般忽略虚函数的inline指��o�?/font>

如果一个类��h��虚函敎ͼ�那么�q�个�cȝ��每一个对象都会具有指向这个虚函数表的指针�Q�这是一个隐藏数据成员vptr~被编译器加在某一个位�|��?/font>

此处�W�二个开销�Q�你必须在每一个对象中存放一个额外的指针~

如果对象很小�q�个开销��十分显著~~因�ؓ比例大~

此时 void makeCall(c1* pc1){

pc1->f1();

}

��译�?(*pc1->vptr[i])(pc1);

�Ҏ��vptr扑ֈ�vtbl �q�很��单，

在vtbl扑ֈ�调用函数对应的函数指针，�q�个步骤也很��单，因�ؓ�~�译器�ؓ虚函数表里的每一个函数设�|�了唯一的烦�?/font>

然后调用指针所指向的函数~

�q�样看来�Q�调用虚函数与普通函数调用的效率相差无几�Q�只多出几个指��o�?/font>

虚函数真正的开销与内联函数有关~�Q�在实际应用中，虚函��C��应该被内联，因�ؓ内联意味着在编译时�ȝ��被调用函数的函数体来代替被调用函数。但是虚函数意味着�q�行时刻军_��调用哪个一函数�Q�so~~~虚函��C��出的�W�三个代价啊�Q�~不能内联�Q�通过对象调用虚函数的时候，�q�些虚函数可以内联，但是大多数虚函数通过指针或者以用来调用的）�?/font>

~多重�l�承的情�?/font>

多重�l�承一般要求虚基类。没有虚基类�Q�如果一个派生类��h��多个通向基类的��承�\径，基类的数据成员会被复制到每一个��承类对象里，�l�承�c�M��基类间的每一条�\径都有一个拷贝�?/font>

有了虚基�c�，通常使用指向虚基�cȝ��指针作�ؓ避免重复的手�D�，�q�样需要在对象内部嵌入一个或者多个指针~也带来了一定的开销~

例如菱�Ş�l�承 �Q?

class A{};

class B:virtual public A{};

class C:virtual public A{};

class D:public B,public C{};

�q�里A是一个虚基类�Q�因为B和C虚拟�l�承了他�?/font>

对象 D 的布局�Q?/font>

B data

vptr

pointer to virtual base class

C data

vptr

pointer to virtual base class

D data members

A data members

vptr

上面四个�c�，只有三个vptr�Q�因为B和D可以�׃�n一个vptr �Q��ؓ啥？�Q?/font>

现在我们已经看到虚函数如何��对象变得更大�Q�以及�ؓ何不能把它内联了~

下面我们看看RTTI的开销 runtime type identifycation 所需要的开销

通过rtti我们可以知道对象和类的有关信息，所以肯定在某个地方存储了这些供我们查询的信息，�q�些信息被存储在type_info �c�d��的对象里�Q�你可以通过typeid�q�算�W�访问一个类的type_info对象�?/font>

每个�c�M��仅需要一个RTTI的拷贝，规范上只保证提供哪些臛_��有一个虚函数的对象的准确的动态类型信息~

why�Q�和虚函数有啥关�p�~ 因�ؓrtti设计在vtbl�?/font>

vtbl的下�?包含指向type_info对象的指针。所以��用这�U�实现方法，消费的空间是vtbl中占用一个额外的单元再加上存储type_info对象所需要的�I�间�?/font>

------------------------�|�恶的结束线 OVER~------------------------------------------

rikisand 2010-01-18 14:16 发表评论

rikisand — Sun, 17 Jan 2010 11:36:00 GMT

解决��目的问题，意识到断�a�的重要性。如果一个程序在某处遇到了非法的��|��那么最好的情况便是在此��d��下报错，最坏的情况便是�E�序不吭不响的执行着~~直到你发��C��执行的方式极��异，此时�Q�你要花九牛二虎之力才能扑ֈ�错误所在之处~~~~

学习一下断�a�吧：

·······什么是断言

在某处判断某一个表辑ּ�的��gؓ真或者假�Q�如果假则输出错误消息�ƈ停止�E�序的执行~

assert是宏�Q�而不是函敎ͼ�只在debug版本中有效，因此无需在release版本删除�?/font>

·······哪几�U�断�a�

MFC

ASSERT

void foo(char* p,int size)
{
ASSERT(p != 0); // 验证�~�冲区指�?br>ASSERT((size >= 100); // ��认�~�冲区大��至��ؓ100字节
// foo 函数的其它计��过�E?br>}
如果没有定义_DEBUG预处理符�Q�则该语句不会真正生成代码。Visual C++会在调试模式�~�译时自动定义_DEBUG�Q�而在发行模式下，该预处理�W�是不存在的。如果定义了_DEBUG�Q�则上述两个断言生成的代码类如：
//ASSERT(p != 0);
do
{
if(!(p != 0) && AfxAssertFailedLine(__FILE__, __LINE__))
AfxDebugBreak();
} while(0);
//ASSERT((size >= 100);
do
{
if(!(size >= 100) && AfxAssertFailedLine(__FILE__,__LINE__))
AfxDebugBreak();
}while(0);

ASSERT_KINDOF(classname,pObject); ASSERT_KINDOF(CDocument,pDocument);

��验pObject指向的对象是classname�cȝ��一个对象或者其�z��cȝ��对象

ASSERT_VALID(pObject); pObject 必须是一个派生于CObject�cȝ��c�d��象，会调用其重写的AssertValid函数 �Q�例�?/font>

如果使用应用向导或类向导生成��Z��MFC的类�Q�通常会得到AssertValid()的骨�Ӟ��最好改写这些骨架代码以增加最基本的完整性检查。下面是一个典型的例子�Q�类Sample从CObject�l�承�Q�假定它含有职员名字及其薪水�Q?
class Sample : public CObject
{
    protected:
    CString m_Name; // 职员名字
    double m_Salary; // 薪水
public:
    Sample(LPCTSTR name,double salary) : m_Name(name), m_Salary(salary) {}
   #ifdef _DEBUG
        virtual void AssertValid() const;
    #endif
};
#ifdef _DEBUG
void Sample::AssertValid() const
{
    CObject::AssertValid(); // 验证基类
    ASSERT(!m_Name.IsEmpty()); // 验证职员名字
    ASSERT(m_Salary > 0); // 验证薪水
}
#endif

CRT assertion

_ASSERT �?nbsp; _ASSERTE 后一个会在出错时同时打印出条件判断句

ANSI

assert()

注意�Q�assert用于��非法的输入�Q�但是合法的输入�q�不一定是正确的，例如�Q?/font>

int pB = (int*)malloc(sizeof(int)*1000);

assert(pB!=NULL) //错误的��用assert 他会在release版本失效~也就是说assert不应该对�E�序产生副作�?/font>

正确的做法：

int pB = (int*) malloc(sizeof(int)*1000);

if(pB == NULL)

{
//错误处理

}

else{

}

另一个例子：

void draw(){

CFigure* pF = getCF();

assert(pf!=NULL);

if(pf == NULL){}

else{

}

此处�Q�对于getCF来说�q�回��gؓNULL是非法的�Q�如果他的返回值可能�ؓnull��没必要加上assert语句�?/font>

而下面的if语句则是��Z��防止release版本出现null指针的情��c�?

VERIFY()

�׃��ASSERT仅在�E�序的调试版起作用，��试表达式��L��被动的。也��是��_��它们不能包含赋倹{��增量、减量等真正改变数据的操作。但有时候我们需要验证一个主动表辑ּ��Q�比如赋��D��句。这时可以��用VERIFY代替ASSERT。下面是一个例子：
void foo(char* p,int size)
{
char* q; // 指针的副�?br>VERIFY(q = p); // 拯��指针�q�执行验�?br>ASSERT((size >= 100); // ��保�~�冲区大��至��ؓ100字节
// 执行 foo 的其它操�?br>}
在调试模式下ASSERT和VERIFY是相同的。但在release模式下，VERIFY能够�l�箋对表辑ּ�求��|��但不再进行断�a��验）�Q�而ASSERT语句在效果上��如同已�l�删除了一栗��?
��管在MFC源代码中可以扑ֈ�一些应用VERIFY的例子，但ASSERT用得更�ؓ普遍。一些程序员��L��完全避免使用VERIFY�Q�因��Z��们已�l�习惯于使用被动断言。请��C��Q�如果在ASSERT语句中��用了��d��表达式，�~�译器不会发��Z�Q何警告。在发行模式下编译时该表辑ּ�会被直接删除�Q�从而导致程序运行的错误。由于发行版�E�序不含调试信息�Q�这�U�类型的错误是很难找到原因的�?

rikisand 2010-01-17 19:36 发表评论

c++ RTTI (1)

rikisand — Sun, 03 Jan 2010 09:59:00 GMT

��目中遇��C�� RTTI 先学一部分 c++ primer内容

�q�行时类型识别：

�E�序可以使用基类的指�?/font>或者引用来��索这些指针或引用所指对象的实际�z��c�d��

标准库提供了两个操作�W�：

1. typeid 他可以返回指针或者引用所指向对象的实际类�?/font>

2. dynamic_cast ��基�cȝ��型的指针或引用安全的转�ؓ�z��cȝ��指针或者引�?nbsp;

对于不带虚函数的�c�d��~�译时期执行�Q�否则在�q�行期间执行

使用时机�Q?/font>

基类指针调用�z��c�L��员函数的话，一般应使用虚函敎ͼ��q�样�~�译器会�Ҏ��对象的实际类型来选择正确的函数。但是某些情况下无法使用虚函敎ͼ�那么�?/font>

时如果需要��用基�c�L��针调用派生类成员函数侉K��要��用RTTI强制转换�Q�而且必须��查�{换是否成�?/font>�?/font>

(一) Dynamic_cast

dynamic_cast 如果转换到指针失败则�q�回 0 如果转换到引用类型失败则抛出 bad_cast 异常

�Ҏ��针操作：

if(Derived *derivedPtr = dynamic_cast (basePtr)){

//basePtr point to a derived object;

}else{

//basePtr point to a base object;

}

�?if 语句中进行检�?1.条�g代码内部知道 derivedPtr 的类�?2.不可能在��试代码和��用代码中加入代码�Q�也��是说不会在没有��试前就使用derivedPtr 3.如果��p�|外部不会使用未绑定的指针derivedPtr

对引用操作：

因�ؓ不存在空引用所以�{换失败抛出异�?/font>

void f(const Base& b){

try{

const Derived &d = dynamic_cast (b);

}catch(bad_cast){

}

(�? typeid

typeid(e) e是�Q意的表达式或者类型名

Base *bp;

Derived *dp;

//compare type at run time of two objects

if(typeid(*bp)==typeid(*dp)){

//bp dp point to objects of the same type

}

if(typeid(*bp)==typeid(Derived)){

//bp actually point to a Derived

}

注意typeid ��试的是 *bp 对象

//test always fails: The type of bp if pointer to Base

if(typeid(bp)==typeid(Derived)){

}

Base* ��永�q�和Derived�c�d��不同

只有typeid 的操作数是带虚函数的�cȝ��对象的时候，才返回动态类型信息，��试指针�q�回指针的静态的�Q�编译时�c�d��

�Q�三 �Q�type_info �c?/p>

作�ؓtypeid的返回�?提供

t1==t2 t1!=t2 t.name() 的操�?/p>

作�ؓ应用例子�Q�可以实��C��个类型敏感的相等操作�W?/p>

friend bool operator == (const base& lhs, const base& rhs){

return typeid(lhs)==typeid(rhs) && lhs.equal(rhs);

}

�q�样可以处理基类子类混合的相�{�判断了

rikisand 2010-01-03 17:59 发表评论

State 模式

rikisand — Tue, 29 Dec 2009 13:25:00 GMT

STATE 模式�Q?/font>

一个对象的行�ؓ取决于他的状态，而且它必��d��q�行时根据状态改变他的行为。常规实��C��Q�一个操作含有庞大的多分支的条�g语句�Q�且�q�些分支依赖于该对象的状态。这个状态通常使用一个或者多个枚丑ָ�量表�C�。STate模式把这些状态时候的对象看做一个独立的对象�Q�也��是��不同状态时的行为分散到相应的状态类中。要辑ֈ��q�样的效果，需要context�Q�也��是状态的持有者，卛_��先的�c�；抽象状态类�Q�他��装了与context交互的接口；具体状态类�Q�也��是一个个的具体状态。context中保存一个抽象状态类对象为成员，�q�delegate对象行�ؓ�l�他�Q�从而��相应状态下的行��Z��码生效。如果状态改变的准则不是固定的则state状态类同时应该重写changestate�c�M��控制状态的改变�Q�否则可以在context中实现�?/font>

具体到我们的��目�Q?/font>

每一个device即�ؓcontext�Q�他拥有一个state对象�Q�device中的函数processMsg(){state->processMSg();} �׃��状态改变的规则依赖于收到的消息�Q�也��是说一个状态可能�{换到多个状态device的每个状态需要重写statechange�Ҏ��Q�stateChange(){state->stateChange(this�Q�msg);} �q�样�Q�不同的状态下的行为实现在具体状态的�c�M��Q�比原先的版本清晰明了，可读性更强�?/font>

rikisand 2009-12-29 21:25 发表评论

ALGORITHM IN C (1)

rikisand — Wed, 11 Nov 2009 12:18:00 GMT

Steps to developing a usable algorithm.
• Define the problem.
• Find an algorithm to solve it.
• Fast enough?
• If not, figure out why.
• Find a way to address the problem.
• Iterate until satisfied.

主要内容 FIND-UNION ALGORITHM

��是利用�q�查集来考察�q�通性的��法。条件N个节点，M对节点，输入每一对节�Ҏ��候，如果已经�q�通，则忽略，否则输出接点�q�更�?

主要介绍三种��法�Q�第一�U�，QUCK-FIND 利用数组记录每一个联通子图，同一个联通子囄��节点数组变量是相同的。因此每��d��一对就需要遍历N个数�l�变量考察是否需要更斎ͼ�最坏时间MN�Q�实际上每个子图为高度�ؓ2的树;�W�二�U�，QUICK-UNION 联通子��N��要union�?仅仅需要将两个root union 因此每个联通子��N��度变高，所有find root 会消耗一定时��_��当然无需遍历N�?�Q�最坏时��_��也就是每�ơ均需要从叶子节点��d��溯求根（�q�里书中丑־�例子好像有问题）也是MN�Q�第三种也就�?QUICK WEIGHT UNION �q�种�Ҏ��在两个子树合�q�的时候，不是��单的指定合�ƈ�{�略�Q�而是�l�过判断的，把size��（相应高度也小�Q�的合�ƈ到size大的里面�Q�实际上很容易理解就是尽量减��树的高度来�q�求quick-find的效率；

�q�而作者写道�\径压�~�，也是�q�种思想。或者实��Cؓ全部压羃�Q�也��是说在�q�行union操作的时候，所有check的节炚w��直接链接到union后的新root下面�Q�或者half union �Q�容易实��C��性能好）每次check时候，如果没有停止loop��单的�?id[i]=id[id[i]];卛_��辑ֈ�减少到根距离的效果�?

half union 的主要代码：

int i,j;
for(i=p;id[i]!=i;i=id[i]) id[i]=id[id[i]];
for(j=p;id[j]!=j;j=id[j]) id[j]=id[id[j]];
if(i==j)continue;
if(size[i]>size[j]) id[j]=i,size[i]+=size[j];
else        id[i]=j,size[j]+=size[i];

�W�一�ơ用windows live writer 试试效果哦~~

rikisand 2009-11-11 20:18 发表评论

11.7

rikisand — Sat, 07 Nov 2009 13:18:00 GMT

what's this

and ...

�?�Q�做完了��p��写下�?省的之后忘了

昨天看的misof的教�E?关于数~ 今天做了其中的提到的例题�Q?/div>

BorelSe:

simple的题~�W�一�ơ没搞对�Q�搞完后发现�q�是写麻烦了。题目中明确说明�Q�也显而易见的是空集和全集一定是B集里�?�Q�我�q�费心去处理�I�集。。�?/div>

其次�Q�重复的数字不用处理�Q�因为用的是或操作�?/div>

剩下的就是用一个数�l�和一个set不断循环了，其实用队列效果很好的�Q�恩···

1         int howMany(int size, vector <string> sub)
2         {
3                  set<int> q;q.clear();string str;
4                  int mask=(1<<size)-1;
5                  VI C;
6                  REPV(sub,i){
7                      if(sub[i]=="")C.push_back(0),q.insert(0);
8                      else{
9                       set<int> vec;
10                       stringstream ss(sub[i]);str="";
11                       while(ss>>str) {
12                                     if(str=="")vec.insert(0);
13                                     else vec.insert(atoi(str.c_str())-1);
14                                     }
15
16                     int now=0;
17                     for(set<int>::iterator it=vec.begin();it!=vec.end();it++){
18                         now|=(1<<(*it));
19                     }
20                     if(q.count(now)==0) C.push_back(now),q.insert(now);
21                     }
22                 }
23                 int last=q.size();
24                 while(true){
25                     REPV(C,i)
26                     {
27                         int s=C[i]^mask;if(q.count(s)==0)C.push_back(s),q.insert(s);
28                         REP(j,i)
29                         {
30                         int k= C[i]|C[j];
31                         if(q.count(k)==0)C.push_back(k),q.insert(k);
32                         }
33                     }
34                     if(last==q.size())return last;
35                     else last=q.size();
36                 }
37         }

关于数字�Q?/div>

2的n�ơ方换算�?10的次�?大概�?n/3 数量�U�的也就是说 �?n/3+1 大小��可以了

�q�个是double 的数�?/div>

	sign	exponent	mantissa
single precision	1	8	23
double precision	1	11	52

rikisand 2009-11-07 21:18 发表评论

Hello Blog World~~

rikisand — Sat, 07 Nov 2009 11:27:00 GMT

呵呵~~ just test

#include<iostream>
using namespace std;
int main()
{
cout<<"hello world~"<<endl;
return 0;
}

rikisand 2009-11-07 19:27 发表评论