中文一区字幕,激情视频亚洲,久久国产精品网站

关于javascript callback

littlegai — Thu, 09 Oct 2008 04:29:00 GMT

如果注册了客��L��回调脚本�Q�则Form中如下字�D�不为空
Page.Request.Form["__CALLBACKID"]
Page.Request.Form["__CALLBACKPARAM"]

littlegai 2008-10-09 12:29 发表评论

关于HttpApplication

littlegai — Fri, 19 Sep 2008 03:00:00 GMT

修改web.config
Session_End
Application_End
��h��面
Application_Start
Application_BeginRequest
Application_AuthenticateRequest
Session_Start
再次��h��
Application_BeginRequest
Application_AuthenticateRequest

littlegai 2008-09-19 11:00 发表评论

如果sharepoint 不能卸蝲

littlegai — Sat, 16 Aug 2008 00:56:00 GMT

执行命��o�?Stsadm -o uninstall 然后在控刉��杉K��面卸载即可�?br>

littlegai 2008-08-16 08:56 发表评论

修复Visual Studio

littlegai — Wed, 23 Jul 2008 16:06:00 GMT

有时候在��d��Web引用的时候，会告诉你没有安装有关�l��g�Q�需要重装Visual Studio�Q�主要是因�ؓ所安装的扩展包��Z��问题�Q�这时候可以用
devenv /resetskippkgs
修复

littlegai 2008-07-24 00:06 发表评论

Nebula Tips (1)

littlegai — Sat, 19 Jul 2008 13:27:00 GMT

可以在E:\Program Files\Nebula2 SDK\build\vstudio8目录扑ֈ��~�译的项目�?br>其中�Q�Nebula2.sln是源代码
tutorials.sln是那些小例子
打开tutorials.sln�Q�我用的是VS2008)�Q�找��C��要运行的那个��目�Q�可以在SDK扑֯�应的例子�Q�，讄��一下包含�\径和�?lib)路径�Q�就可以�~�译了，通常�~�译�q�程会很��利�Q�但是我�q�里�q�行的时候，出现�?�Q?br>

nD3D9Shader:failed to load fx file 'h:/games/Nebula2SDK/data/shaders/fixed/shape.fx' with:
memory(34,9):ID3DXEffectCompiler:Error in type checking
memory(55,9):ID3DXEffectCompiler:Error in type checking
memory(67,9):ID3DXEffectCompiler:Error in type checking
ID3DXEffectCompiler:There was an error initializing the compiler
在http://nebuladevice.cubik.org/forum/index.php?topic=41.msg401#msg401可以扑ֈ�解决办法�Q�其中有效的一条是在nd3d9shader_main.cc
中设�|�编译标识�ؓ
D3DXSHADER_USE_LEGACY_D3DX9_31_DLL
扑ֈ��Ҏ��bool nD3D9Shader::LoadResource()

/**
    Load D3DX effects file.
*/
bool
nD3D9Shader::LoadResource()
{
    n_assert(!this->IsLoaded());
    n_assert(0 == this->effect);

    HRESULT hr;
    IDirect3DDevice9* d3d9Dev = this->refGfxServer->d3d9Device;
    n_assert(d3d9Dev);

    // mangle path name
    nString filename = this->GetFilename();
    nString mangledPath = nFileServer2::Instance()->ManglePath(filename.Get());

    //load fx file
    nFile* file = nFileServer2::Instance()->NewFileObject();

    // open the file
    if (!file->Open(mangledPath.Get(), "r"))
    {
        n_error("nD3D9Shader: could not load shader file '%s'!", mangledPath.Get());
        return false;
    }

    // get size of file
    int fileSize = file->GetSize();

    // allocate data for file and read it
    void* buffer = n_malloc(fileSize);
    n_assert(buffer);
    file->Read(buffer, fileSize);
    file->Close();
    file->Release();

    ID3DXBuffer* errorBuffer = 0;
    #if N_D3D9_DEBUG
        DWORD compileFlags = D3DXSHADER_DEBUG | D3DXSHADER_SKIPOPTIMIZATION;
    #else
        DWORD compileFlags = D3DXSHADER_USE_LEGACY_D3DX9_31_DLL;
    #endif

    // create include file handler
    nString shaderPath(mangledPath.Get());
    nD3D9ShaderInclude includeHandler(shaderPath.ExtractDirName());

    // get global effect pool from gfx server
    ID3DXEffectPool* effectPool = this->refGfxServer->GetEffectPool();
    n_assert(effectPool);

    // create effect
    hr = D3DXCreateEffect(
            d3d9Dev,            // pDevice
            buffer,             // pFileData
            fileSize,           // DataSize
            NULL,               // pDefines
            &includeHandler,    // pInclude
            compileFlags,       // Flags
            effectPool,         // pPool
            &(this->effect),    // ppEffect
            &errorBuffer);      // ppCompilationErrors
    n_free(buffer);

    if (FAILED(hr))
    {
        n_error("nD3D9Shader: failed to load fx file '%s' with:\n\n%s\n",
                mangledPath.Get(),
                errorBuffer ? errorBuffer->GetBufferPointer() : "No D3DX error message.");
        if (errorBuffer)
        {
            errorBuffer->Release();
        }
        return false;
    }
    n_assert(this->effect);

    // success
    this->hasBeenValidated = false;
    this->didNotValidate = false;
    this->SetState(Valid);

    // validate the effect
    this->ValidateEffect();

    return true;
}
注意按照�U�色的地方进行修改即可，然后���回看到�q�行�l�果�Q?br>

littlegai 2008-07-19 21:27 发表评论

javascript学习

littlegai — Wed, 23 Apr 2008 03:17:00 GMT

1�?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> Html标签如果环绕javascript代码�Q�则会作用于它的输出

如：

2�?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> 不是W3C标准

W3C标准是：

但是有些��览器不支持type方式声明javascript脚本�Q�所以你最好两个都用，��如下面�Q?/span>

3�?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> 有些��览器在执行脚本的过�E�中产生输出�Q�但有些不能

Ready start

Running...

Keep running

Stop!

4�?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> 大多数浏览器喜欢把它们不支持的标�{�中的内容直接显�C�出来，如果你碰��C��个浏览器恰好不支�?/span>javascript�Q�你应该�Q?/span>

但是如果你所写的是严格的XHTML�Q�注释标记就不大合适了�Q�你最好：

<script type="text/javascript">

<![CDATA[

   ..script here ..

]]>

</script>

5�?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> 如果��览器不支持javascript或�?/span>javascript被关闭了�Q�最好写一�D?/span>noscript�Q�就像这��P��

一个很有意思的用法��是�Q�如果浏览器不支�?/span>javascript�Q�就让他们蟩转到一个错误页面，如下�Q?/span>

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

noscript Redirect Demo







 
6�?span style="font-family: "Times New Roman"; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> 
事�g响应斚w���Q?/span>html是不区分大小写的�Q?/span>onclick,OnClick,onCliCk效果相同�Q�但是在XHTML中，只接受小写�?/span>
大多数浏览器支持在地址栏中输入�?strong>javascript: alert('hello')的代码来�q�行javascript�?/strong>当然�Q�也可以以超链接的�Ş式：Click to invoke

littlegai 2008-04-23 11:17 发表评论

Direct Show �W�记

littlegai — Fri, 22 Feb 2008 14:10:00 GMT

一�?总览�Q?/b>

Graph、Filter、Pin、Simple

Graph�Q�可以理解�ؓ媒体处理的流�E�图�?

Filter�Q�可以理解�ؓ媒体处理��程图中的一个步骤�?

Pin�Q�可以理解�ؓ媒体处理各个步骤之间的数据流节点�?

Simple�Q�可以理解�ؓ各个形态的数据�?

Filter的分�c�：

· source filter:��数据从源（比如媒体文�g�Q�引入Graph�?

· transform filter�Q�数据流入、改变、流出�?

· Renderer filters�Q�把最�l�结果展现给用户�?

· splitter filter�Q�比如把一个媒体流分解��频和音频�?

· mux filter�Q�和splitter filter相反�?

1. Graph Manager

主要对处于同一个Graph的Filter(s)�q�行�l�一的管理�?

比如�Q?

· 各个Filter的状态切�?/i>

· 建立同步旉��

· 事�g回发

· 创徏

��Z��么要�l�一��理状态切换？

因�ؓ处于同一Graph中的各个Filter的状态切换往往需要遵循严格的先后��序。所以一般通过发送命令给Graph Manager的方式进行各Filter的状态变更�?

��Z��么要建立同步旉��Q?

比如声像需要同步�?

2. Media Types

�l�构�?a href="ms-help://MS.PSDKSVR2003SP1.1033/directshow/htm/am_media_typestructure.htm">AM_MEDIA_TYPE定义了媒体类型�?

主要包含如下�l�构�Q?

· Major type: �׃��个GUID来表�C�。通常包含韌��频、未知流、MIDI�{�等�?

· Subtype: �׃��个GUID来表�C�。Major type��频，则子�c�d��可以包括RGB-24, RGB-32, UYVY

· Format block: 说明囑�Ş��寸、��率等信息。如果Major type��频，sub type为RGB-24�Q�则Format block的信息会被自动��L识�?

3. Sample�?/b>Allocator

需要注意的是，各个filter之间�q�不直接传送它们各自进行处理的数据的指针。它们通过一个暴�?a href="ms-help://MS.PSDKSVR2003SP1.1033/directshow/htm/imemallocatorinterface.htm">IMemAllocator接口的Com�l��g来分配内存。填充了数据的内存被��装到Sample里面。各个Filter真正使用的是Sample。Sample通常包含�Q?

· 内存指针

· 旉��?

· 标识

· 媒体�c�d��Q�可选）

�q�里当一个Filter使用Sample的时候，它同时掌握这个Sample的引用计敎ͼ��q�样��有效杜�l�了资源争用现象的发生�?

4. Filter Graph中的��g

��g被封装到Filter中，��M��与硬件的交互都�{化�ؓ与Filter的交互�?

二�?Graph-Building �l��g

Filter Graph Manager.

Capture Graph Builder�Q�设计的初衷是视频捕�?但是可以衍生很多用途�?

Filter Mapper and System Device Enumerator�Q�枚丑֏�用的filter.

DVD Graph Builder

Video Control

1. ��拼接

1) 如果在Graph里面有一个没有输入的Filter�Q�那么Graph在完成自��q��时候，��׃��考虑�q�个Filter。如果有一个已有的Filter的流出恰好与�q�个没有输入的Filter的流入相匚w��Q�则��这两个Filter�q�接�?

2) Graph在完成自��q��q�程中也会查找所有注册过的Filter与当前非�l�点Filter的流��行匹配。注册的Filter会有一个权��|��作�ؓGraph�q�行�q�接��试的优先��依据�?

步骤�Q?

1) 使用IStreamBuilder�Q�如果pin实现了这个接口，但大多数情况没有�Q�。（否则2�Q?

2) 查找被缓存的Filter。（否则3�Q?

3) 查找Graph现有的Filter。（否则4�Q?

4) 查找所有注册了的Filter�?

2. 关键�Ҏ��

IFilterGraph::ConnectDirect:直接�q�接两个Filter�Q�如不成功，�q�回��p�|�?

IGraphBuilder::Connect�Q�连接两个Filter�Q�如果可能，直接�q�接�Q�否则通过中间Filter(s)�q�行�q�接�?

IGraphBuilder::Render�Q�你自己建立了一�p�d��从源开始的Filter�Q�基于这些Filter(s)完成Graph�?

IGraphBuilder::RenderFile�Q�从一个文件开始完成Graph.

IFilterGraph::AddFilter:向Graph中添加一个Filter

通过�q�些�Ҏ��Q�你可以�Q?

1�?由Graph Manager建立整个Graph。（通过RenderFile�Q?

2�?由Graph Manager建立部分Graph。（比如你想自己写一个AVI文�g�Q�当然也可以通过Render来生成预览）

3�?完全手动建立整个Graph。（需要自己AddFilter�Q�还需要自己Connect�Q��?b>

三�?Direct Show 数据��概�q?/b>

1. 关键接口�Q�方法）

IMediaSample�Q�对Filter之间使用的内存的��装�?

IMemAllocator::GetBuffer�Q�从allocator获取Buffer�Q�即ImediaSimple的实现对象）

摘要�Q?

�׃��Render会按照时间戳来Render数据�Q�所以它会一直占用它的上一�U�Filter��入的Simple�Q�直到时间戳所标识的时间到达。所以当上一�U�Filter用完了allocator的Simple池中的Simple�Ӟ��会阻塞而不处理�Q�进而反向媄响到更上一�U�的Filters�Q�从而��它们变�ؓ�{�待的状态。同时由于时间戳对于Render的时间上的要求，所有上�U�Render都必��d��Simple的时间戳标识的时间到达之前处理完自己对于该Simple的动作�?

2. Transport�Q�传送）

· Push Model�Q�推送模型）�Q�上层filter�Q�pin-out�Q�将处理好的数据推送给下层filter(pin-in)。下层filter在需要数据的时候通过IMemInputPin::Receive来获取数据�?

· Pull Model�Q�抓取模型）�Q�下层filter(pin-in)在需要数据的时候，通过IAsyncReader异步向上层filter��h��数据。（通常用于视频文�g的回放）

3. Samples and Allocators

1) 引用计数

上层Filter(pin-out)通过IMemAllocator::GetBuffer向Allocator甌��Simple�Q�如果此时没有Simple的引用计��Cؓ0�Q�则说明Allocator的Simple池中没有可用的Simple�Q�则GetBuffer的调用会被阻塞。一旦Simple池中出现可用的Simple�Q�则先前��d��的GetBuffer放行�Q��ƈ获取一个引用计数变�?的Simple。此Simple处理后，传递给下层Filter(pin-in)�Q�下层Filter如果在Receive�Ҏ��中处理Simple�Q�则它与上层Filter的处理处于同一�U�程中，Simple的引用计��C��会变化，如果下层Filter需要通过创徏�U�程异步使用上层推入的Simple�q�行处理�Q�则该Simple的引用计��C��?�Q�变�?.之后如果上层Filter的推送线�E�结束，则Simple的引用计数减1�Q�变�?.

2) 提交和撤销Allocator

IMemAllocator::Commit,在被调用之前�Q�所有的GetBuffer无效�Q?

调用IMemAllocator::Decommit之后�Q�所有的GetBuffer调用无效.

4. Filter 状态变�?/b>

Filter状态的变化由Graph Manager�q�行控制�?

所有的状态变化都是自低（Render Filter�Q�向上（Source Filter�Q�进行的。比如暂停的时候，Render Filter会首先暂停，�q�时候Render之上的Filter中都会存有未能推送的Simple�Q�此时相当于在各个Filter之前都堆�U�了一些等待处理的数据。沿着Render向上的Filter逐个暂停�Q�直到Source。当状态从暂停变化为开始的时候，Render会首先变化�ؓ开始状态，处理在它之前堆积的数据，�q��N��些被占用的Simple。然后逐步向上直到Source,Source在能够获取Simple之后�Q�数据��l�流入Graph�Q�整个Graph�q�入开始状态�?/p>

littlegai 2008-02-22 22:10 发表评论

littlegai — Fri, 10 Aug 2007 14:47:00 GMT

1、数据库与面向对象编�E�语�a�的不�?br>关系数据库的��x��Ҏ��数据�l�构的声明。这��L��话一些封装手�D�就不可用了。没有封装，数据讉K��׃��会被明显的约束�?br>表是通过外键兌��的。这同样不能够被��装�?br>存在于数据库中的数据是持久化的，�q�且存活得比�E�序要长。数据库的结构一旦发生变化，数据��p��q�行�q�徙�?/p>
如果�pȝ��被多�ơ安装，那么��׃��有不同的数据库。那么如果数据库�l�构发生变化�Q�这个变化同栯��作用于每一份安装�?/p>
不同的用户可以同时访问数据，但是他们可以每�h拥有一份程序的拯��?br>
�c�d��以��承，但数据不行�?br>源代码可以在本地�q�行�l�护和测试，之后发布到源代码��理服务器中。版本冲�H�可以被识别刎ͼ�然后通过一些强有力的工具可以帮助解册��些问题。在大多数项目中�Q�同一个数据库往往为多个开发�h员服务�?br>�l�护源代码可以��用工兗��数据库的结构和数据则只能够�׃�h花更多的�_�֊��ȝ��护�?br>讉K��数据库所��p��的时间比赯��问访问内存中对象的时间来要多上好几倍�?/p>
关系型数据库中的数据�l�构是浅层结构，然而当它们变成对象处于面向对象的系�l�中�Ӟ��他们的含义变得更加深入，他们的关�p�d��得更加错�l�复杂�?/p>
2�E�序与数据库打交道时产生的一些问�?/p>
当程序与数据库交互时�Q�会产生�q�样一些问题：

�E�序与数据库之间的关联往往不是�c�d��安全的（惌��JDBC�Q�。编译器无法评估�E�序与数据库是否�l�构性兼宏V��某些映��类和持久层把这些问题拿��C��一边，却没有解军_��们。类型安全性将会在影射�c�L��持久层中失去�Q�而不是其他的地方�?/p>
数据库将�?#8220;隐藏”一些对象。这�U�情况发生在对象被写入数据库或者在��d��出来的地斏V��因此对象可以被�E�序的两个部分交换��用，而不需要显式得暴露于接口中�?/p>
大多数情况下往往采用表和对象一一对应的模式。这往往在强调数据的应用�E�序中是错误的做法。特别是当需要从数据库读取对象时�Q�可能会需要多个表的极联，或者�ؓ了满��x��据展�C�的需要，建立一些视图。结果，当数据库发生变化�Ӟ��很难扑ֈ�一个合适的途径来决定那些类也要跟着修改。反�q�来��_��通常无法明确�cȝ��那些变化会媄响到查询和视图�?/p>
�q�有一些琐��的问题。数据库中的数据�c�d��与程序语�a�中的基本数据�c�d��之间的映��会造成一些困难。比如时间戳的尺度，采用��点数尺度或采用string或变长字�W�串集合��׃��有相当大的差别�?/p>
在面向对象的�pȝ��当中�Q�关联关�pȝ��建模是基于概�늚��Q�例如，账目和收支有养I��。在关系数据库中�Q�一对多关系和多对一关系都是适用的。所以也��无法找��C��套确定的�Ҏ��来实施重构�?/p>
因此我们在重构的时候需要着重考虑�q�样三个地方�Q?/p>
1�Q�有��x��据库�l�构、数据库模型的重构；

2�Q�不同版本的数据库之间的数据�q�移�Q?/p>
3�Q�有��x��据库讉K��代码的重构�?/p>
3重构关系数据库的数据库结�?/p>
在实践中�Q�往往有一定数量的数据库模式��^行存在。至��有两个模式�Q�一个�ؓ开发者所使用�Q�开发数据库�Q�一个�ؓ用户所使用�Q��品数据库�Q��?/p>
因此开发者��L��可以��试着修改数据库而不��L��扰用戗��只有当数据库被��d��的测试完成，�q�且适合于构��Z��其上的系�l�，�q�样才会��数据库、程序作��Z��个稳定版本提交给用户�?/p>
此外�Q�每一个开发者应当拥有自��q��数据库实例，�q�样他们才能够独立的��试他们对于数据库的一些变动而不会媄响到开发团队的其他人员。这些不同版本数据库实例的存在��得数据的�q�移变成了一个关键话题。在下面的部分，我们��会讨论�q�个话题�?/p>
“逐步�q�化”�q�样一个核心的原理不论在程序重构中�q�是数据�l�构的重构中都在重演着�Q�老的�l�构�q�不会马上被新的所取代。新旧数据库�l�构往往会�ƈ存一�D�|��间。老的数据库结构会被标��Cؓ“�q�期”以让那些新编写的�E�序不去讉K��它。然后已有的�E�序会被修改�Q�一步又一步的向新数据库过渡。一旦这个过�E�结束，老的数据�l�构��q��完成了它的��命，他会被终�l�然后删除。图5-1�C�出了表“Customer”的变革。一开始的时候，姓和名是作�ؓ一个字�D�存储的�Q�他们合�U�C��“Name”。现在姓和名会被存放在两个字�D�中�Q�最后Name字段��被取代�q�被删除�?/p>

在中间的状态，表Customer包含冗余字段Name。程序或触发器需要保障它们之间的一致性�?/p>
在Java中，你可以把那些�q�时的程序标��C��“已过�?#8221;。但是在大多数数据库和其他程序开发语�a�中没有提供相关的功能�?/p>
在关�p�L��据库中，字段、表、视囄��x��个数据库的结构都有可能需要被标记�?#8220;�q�时”�Q�当�Ӟ��q�视具体的重构过�E�而定。我们往往通过讉K��层面的限制或提示来体现这些独立的“已过�?#8221;标注。比如我们��用O/R mapping工具来生成这些数据的映射�c�，那么对于�q�些�c�L��Ҏ��我们��可以用“已过�?#8221;�q�行标记了。当�Ӟ��前提��是你许��Z��会通过其他的手�D�|��直接讉K��数据库。如果确实这��P��在你的下一个版本中使用�q�种方式标记“�q�时”的数据库�l�构也就��_��了�?/p>
如果你无法保证对于数据库的访问只是通过O/R mapping的映��类�Q�那么就和你的开发团队订立协议吧。列一张表�Q�在�q�个表列丑֛�为重构而过时的那些东西。当然所有的开发者都要同意这个表上列丄��重构�l�果�Q��ƈ且能够去贯彻它�?/p>

Ambler在他的网站上攉��了很多数据库中会被频�J�用到的重构�Ҏ��。这些重构方法�ؓ数据库重构提供了一些依据�?/p>
Ambler的重构方法的目的在于为数据库的结构带来改观。因而只是独立的��d��一列�ƈ不能�l�成一�ơ重构。独立的��d��一列不能够�l�数据库�l�构带来��M��的改观�?/p>
有这样几�U��Ş式的重构�Q�重构而提升数据的质量�Q�重构而优化数据的�l�构�Q�重构而提高数据的性能�Q�重构而整合数据；重构而优化数据库框架�?/p>

littlegai 2007-08-10 22:47 发表评论

重构--改善既有代码的设计读书笔�?�W�四�?1)

littlegai — Mon, 06 Aug 2007 13:50:00 GMT
4.2JUnit框架
单元��试
�~�写单元��试的目的是��Z��提高�w��ؓ一个程序员的生产性能。至于让质保部门开心，那只是附带效果而以。单元测试是高度本地�?/span>的东西，每个test class只对单一package�q�作。它能够��试其他packages的接口，除此之外它将假设其他package一切正常�?br>功能��试
用来保证软�g能够正常�q�作。他们只负责向客��h��供质量保证，�q�不兛_��E�序员的生��力。它们应该由一个喜�Ƣ寻找臭虫的个别团队来开发。这个团队应该��用重量��工具和技术来帮助自己开发良好的功能��试�?br>一般而言�Q�功能测试尽可能把整个系�l�当作一个黑��。面对一个GUI待测�pȝ��Q�它们通过GUI来操作那个系�l�。而对文�g更新�E�序或数据库更新�E�序�Q�功能测试只观察待定输入所��D��的数据变化�?br>一旦功能测试者或最�l�用��h��到��Y件中的一个bug�Q�要除掉它至��需要做两�g事。当然你必须修改代码�Q�才得以排除错误�Q�但你还应该��d��一�?span style="BACKGROUND-COLOR: yellow">单元��试�Q�让�?span style="BACKGROUND-COLOR: yellow">揭发�q�只臭虫�?br>4.3��d��更多的测�?br>观察class该做的所有事情，然后针对��M��一��功能的��M��一�U�可能失败的情况�Q�进行测试。这不同于某些程序员提倡的“��试所有public函数”。记住，��试应该是一�U?span style="BACKGROUND-COLOR: yellow">风险驱动行�ؓ�Q�测试的目的是希望找出现在或未来可能出现的错误。所以我不会��L��试那些仅仅读或写一个值域的访问函敎ͼ�因�ؓ它们太简单了�Q�不大可能出错。这一点很重要�Q�因��Z��如果撰写�q�多��试�Q�结果往往��试量反而不够。测试的要诀是：��试你最担心出错的部分，�q�样你就能从��试工作中得到最大收益�?br>考虑可能出错的边界条�Ӟ��把测试火力集中在那儿�?br>��L��边界条�g�Q�也包括��L��Ҏ��的、可能导致测试失败的情况。对于文件相��x��试，�I�文件是个不错的边界条�g。当事情被大家认为应该会出错�Ӟ��别忘了检查彼时是否有异常如预期般的被抛出�?
不要因�ؓ“��试无法捕捉所有臭�?#8221;�Q�就不撰写测试代码，因�ؓ��试的确可以捕捉大多数臭虫�?br>对象技术有个微妙处�Q��承和多态会让测试变得比较困难，因�ؓ��有许多�l�合需要测试。如果你有三个彼此合作的abstract class有三个subclass�Q�那么你��d��有九个可供选择的classes�Q�和27�U�组合。我�q�不��L��试着��试所有可能组合，但我会尽量测�?span style="BACKGROUND-COLOR: yellow">每一�?/span>classes�Q�这可以大大减少各种�l�合所造成的风险。如果这些classes之间彼此有合理的独立性，我很可能不会��试所有组合。是的，我��L��可能遗漏些什么，但我觉得“花合理时间抓出大多数臭虫”要好�q?#8220;�I�尽一生抓出所有臭�?#8221;�?br>��试代码和��品代码之间有个区别：你可以放心的拯��、编辑测试代码�?

littlegai 2007-08-06 21:50 发表评论

重构--改善既有代码的设计读书笔�?�W�三�?6)

littlegai — Mon, 30 Jul 2007 14:11:00 GMT

3.10Switch Statement
面向对象的一个最明显特征��是�Q�少用switch或case语句。从本质上讲�Q�switch语句的问题在于重复。通常用多态来解决Switch 语句带来的坏味道。switch语句常常�Ҏ��type code�q�行选择�Q�你要的是与该type code相关的函数或class。所以你应该使用Extract Method��switch语句提炼��C��个独立的函数中，再以Move Method��他搬移到需要多态的那个class里头。此时你必须军_��是否使用Replace Type Code with Subclass或Replace Type Code with State/Strategy。一旦这样完成��承结构之后，你就可以Replace Conditional with Polymorphism了�?br>如果你只是在单一函数中有些选择事例�Q�而你�q�不��x��动它们，那么“多�?#8221;��有�Ҏ��鸡用牛刀了。这�U�情况下Replace Parameter with Explicit Method是个不错的选择。如果你的选择条�g之一是null,可以试试Introduce Null Object�?br>3.11Parallel Inheritance Hierarchies(�q��l�承关系)
在这�U�情况下�Q�每当你为某个class增加一个subclass�Q�必��M��为另外一个class相应增加一个subclass。如果你发现某个�l�承体系的class名称前缀和另一个��承体�pȝ��class名称前缀完全相同�Q�便是闻��C��q�种坏味道。消除这�U�重复性的一般策略是�Q�让一个��承体�pȝ��实体(instance)指涉(参考、引用、refer to)另一个��承体�pȝ��实体。如果再接再厉运用Move Method和Move Field�Q�就可以��指涉端的��承实体消弭�?/p>
3.12Lazy Class(冗赘�c?
你所创徏的每一个class�Q�都得有人去理解它、维护它�Q�这些工作都是要花钱的。如果一个class的所得不值其�w��h�Q�它��应该消失。项目中�l�常会出现这��L��情况�Q�某个class原本对得赯��q��w��h�Q�但重构使它�w��Ş�~�水�Q�不再做那么多工作；或开发者事前规划了某些变化�Q��ƈ��d��一个class来对付这些变化，但变化实际上没有发生。如果某些subclass没有做满��_��工作�Q�试试Collapse Hierarchy。对于几乎没用的�l��g�Q�你应该以inline class对付它们�?br>Collapse Hierarchy(折叠�l�承体系)
superclass和subclass之间无太大区别�?br>��它们合��Z��体�?br>动机
如果你曾�l�写�q��承体�p�，你就会知道，�l�承体系很容易变得过分复杂。所谓重构��承体�p�，往往是将函数和值域在体�p�M��上下�U�d��。完成这些动作后�Q�你很可能发现某个subclass�q�未带来该有的�h��|��因此需要把classes合�ƈ(折叠)��h��?br>作法�Q?br>选择你想�U�除的class�Q�是superclass�q�是subclass?
使用pull up Field和pull up method或者push down method和push down field�Q�把惌��U�除的class内的所有行为和数据搬移到另一个class�?br>每次�U�d��后，�~�译�q�测试�?br>调整“卛_��被移除的那个class”的所有引用点�Q��o它们改而引用合�qӞ��折叠�Q�后留下的class。这个动作将会媄响到变量的声明、参数的型别以及构造函数�?br>�U�除我们的目标；此时它应该已�l�成��Z��个空�c�R�?br>�~�译、测试�?/p>
3.13Speculative Generality(夸夸其谈未来�?
如果所有的装置都会被用刎ͼ�那就值得处理�q�些非必要的事情�Q�如果用不到��׃��值得。用不上的装�|�只会挡你的路，所以，把它搬开吧�?br>如果函数或class的唯一用户是test cases(��试用例)�Q�这��飘��Z��坏味道。如果你发现�q�样的函数或class�Q�请把它们连同其test case都删掉。但如果他们的用途是帮助test cases��正当功能，当然必须刀下留人�?br>3.14Temporary Field(令�h�q�h��的暂时值域)
有时你会看到�q�样的对象：其内某个instance变量仅�ؓ某种特定情势而设。这��L��代码让�h不易理解�Q�因��Z��通常认�ؓ对象在所有时候都需要它的所有变量。在变量未被使用的情况下猜测起当初设�|�的目的�Q�会让你发疯�?br>请��用Extract Class�l�这个可怜的孤儿创造一个家�Q�然后把所有和�q�个变量相关的代码都放进�q�个新家�?br>如果class中有一个复杂算法，需要好几个变量�Q�往往��可能导致这�U�坏味道。由于实现者不希望传递一长串参数�Q�所以他把这些参数都放进值域中，但是�q�些值域只在使用该算法的时候才有效�Q�其他情况下只会让�h�q�h��。这个时候可以用Extract Class把这些变量和其相关的函数提炼��C��个独立的class中，提炼后的新对象是一个method object�?br>3.15Message Chains(�q�渡耦合的消息链)
用户索求对象�Q�然后向求得的对象��l�烦求对象�?br>�q�时候应该��用Hide Delegate。应该先观察Message Chain最�l�得到的对象是用来干什么的�Q�看看能否以Extract Method把��用该对象的代码提炼到一个独立函��C��Q�再�q�用Move Method把这个函数推入Message Chain�?br>Hide Delegate(隐藏委托关系)

当类囑֦�上所�C�时�Q�客��L��如果惌��获得对应Person的Manager�Q�需要如下过�E�：

Department department = person.Department;
            Manager manager = department.Manager;

通过重构�Q��ؓ�c�Person��d��属性Manager�Q�如�Q?br>

1 public class Person
2     {
3         private Department _department;
4         public Department Department
5         {
6             get
7             {
8                 return _department;
9             }
10             set
11             {
12                 _department = value;
13             }
14         }
15         public Manager Manger
16         {
17             get
18             {
19                 return _department.Manager;
20             }
21         }
22     }

�q�样客户端可以这样写�Q?br>Manager manager = person.Manger;
当然如果person不属于�Q何一个部门，那么�E�序��׃��出错。这里其实可以引入Null Object来解决问题�?/p>
3.16Middle Man�Q�中间�{手�h�Q?br>��Z��可能会过渡运用delegation。你也许会看到某个class所实现的接口有一半的函数都委托给其他class�Q�这样就使过渡运用。这时你应该使用Remove Middle Man�Q�直接和职责对象打交道。如果这�?#8220;不干实事”的函数只有少数几个，可以�q�用inline Method把它们放�q�调用端。如果这些Middle Man �q�有其他的行为，你可以运用Replace Delegation with Inheritance把它们变成实责对象的subclass�Q�这样你既可以扩展原对象的行为，又不必负担那么多的委托动作�?br>Remove Middle Man
�q�个重构�q�程和Hide Delegate刚好相反�?br>Replace Delegation with Inheritance
�q�个重构�q�程��是把关联关�p��{换�ؓ�l�承关系�?br>�?br>
转变�?br>
3.17Inappropriate Intimacy
当两个类彼此关系紧密地时候，有可能是他们所包含的方法或值域处在错误的类中而导��_��此时应当通过Move Method或Move Field把它们移动到合适的位置。应当看一下两个类之间是否真的需要双向导航关�p�，如果不是�Q�让它们之间的关�p�d��为单向导航关�p�R��或者通过Extract Class把共同的函数或值域抽取出来�Q�让每一个Class直接去调用被抽取出来的类。另外如果是子类和父�c�过分耦合�Q�则可以通过��承�{换�ؓ兌��的手�D�|��降低耦合性�?br>3.18Alternative Classes with Different Interfaces�Q�异曲同工的�c�）
如果两个函数做同一件事�Q�却有着不同的签名式�Q�应当运用Rename Method�Ҏ��它们的用途重新命名。请反复�q�用Move Method��某些行为移入classes�Q�直��C��者的协议一致�ؓ止。或许可以��用Extract Superclass来解决问题�?br>3.19Incomplete Library Class�Q�不完美的程序库�c�）
当你面对的程序类库不够好( 或者不能满��求）而你又不能直接改变它�Ӟ��可以采用Introduce Foreign Method �Ҏ��来修改其中一两个函数�Q�或者��用Introduce Local Extension来添加行为�?br>Introduce Foreign Method (162)
在client class建立一个函敎ͼ��q�以一个server class实体作�ؓ�W�一个参数。书中的例子�Q?br>
Introduce Local Extension(164)
�q�种重构方式实际上就是从已封装的�c�d��中��承你认�ؓ功能不��的那个类�Q�然后添加你惌��实现的功能。当�Ӟ��有时候你��x��展的那个�cȝ��巧加上了关键字final(java) 或sealed(c#)�Q�这样就没办法了�?br>3.20Data Class(�U�稚的数据类)
所谓Data Class是指�Q�它们拥有一些值域�Q�以及用于访问这些值域的函敎ͼ�除此之外一无长物。早期的Data Class可能会包含public值域或容器类值域�Q�应当首先将它们��装��h��Q�用属性或特定�Ҏ��Q�。尽量可能的把外界操�U�这些值域的方法搬�U�d��c�里面来�Q�那些不应该被其他classes修改的值域�Q�请�q�用Remove Setting Method�?br>Remove Setting Method
卛_��调设值函数或属性中的set让它变�ؓ只读�?br>3.21Refused Bequest
当子�c�M��愿意�l�承父类的某些东西时�Q�徏议将�l�承修改为关联。不��随便修改�l�承体系。这是一�U�很淡的坏味道�?br>3.22Comments(�q�多的注�?
注释本��n�q�不是坏味道�Q�它可以帮助我们扑ֈ�代码中的坏味道�?br>如果你需要注释来解释一块代码做了什么，试试Extract Method�Q�如果method已经提炼出来�Q�但�q�是需要注释来解释其行为，试试Rename Mehtod�Q�如果你需要注释说明某�pȝ��l�的需求规��|��试试Introduce Assertion�?br>当你感觉需要撰写注释，请先��试重构�Q�试着让所有注释都变得多余�?br>如果你不知道该做什么，�q�才是注释的良好�q�用时机。除了用来记�q�将来的打算之外�Q�注视还可以用来标注你�ƈ无十��x��握的区域。你可以在注释里写下“��Z��么做某某�?#8221;。这�c�M��息可以帮助将来的修改者，��其是那些健忘的家伙�?br>Introduce Assertion
引入断言�?br>某一�D�代码需要对�E�序状态作出某�U�假设。注意，你可以创��q��断言�Q�而不仅仅是依赖已有断�a��?br>

littlegai 2007-07-30 22:11 发表评论

重构--改善既有代码的设计读书笔�?�W�三�?5)

littlegai — Tue, 17 Jul 2007 13:26:00 GMT

3.5 Divergent Change ( 发散式变�?
针对某一外界变化的所有相应修改，都只应该发生在单一class中，而这个新class内的所有内定w��应该反映外界变化。�ؓ此，你应该找出因为某特定原因而造成的所有变化，然后�q�用Extract Class��他们提炼到另一个class中�?br>3.6Shotgun Surgery(散弹式修�?
如果每遇到某�U�变化，你都必须在许多不同的classes内作��多小修改以响应之�Q�你所面��的坏味道��是散弹式修攏V�?br>�q�种情况下，你应该��用Move Method和Move Field把所有需要修改的代码放进同一个class。如果眼下没有合适的class可以安置�q�些代码�Q�就创造一个。通常你可以运用Inline Class把一�p�d��相关行�ؓ放进同一个class。这可能会造成��量发散式变化，但你可以��L��处理它�?/p>
InLine Class

场景�Q�你的某个class没有做太多事�?没有承担��_��责�Q)�?br>��class的所有特性搬�U�d��另一个class中，然后�U�除原class�?br>作法
在移动的目的class�w�上声明所有被�U�d��的class的公共属性和�Ҏ��?如果“以一个独立接口表�C�source class函数”更合适的话，��应该在inlining之前使用Extract Interface)
修改所有source class引用点，改而引用吸收被�U�d��的class的目标class�?��source class声明为private�Q�以斩断package之外的所有引用可能。同时�ƈ修改source class的名�U�ͼ��q�便可以使编译器帮助你捕获到所有对于source class的dangling reference(虚悬引用�?
�~�译�Q�测�?br>�q�用Move Method和Move Field�Q�将source class的特性全部搬�U�d��目标class�?br>3.7Feature Envy(依恋情结)
有一�U�经典的气味是：函数�Ҏ��个class的兴��高�q�对自己所处之host class的兴��。这�U�倾慕之情最通常的焦点便是数据。无数次�l�验里，我们看到某个函数��Z��计算某��|��从另一个对象那儿调用几乎半打的取值函数。疗法显而易见：把这个函数移臛_��一个地炏V��你应该使用Move Method�Q�把它移到它该去的地斏V��有时候函数只有一部分受这�U�依恋之苦，�q�时候你应该使用Extract Method把这一部分提炼到独立的函数中，再��用Move Method带它��d��的梦中家园�?br>往往一个函��C��用上��C��classes�Ҏ��。那么它�I�竟该被�|�于何处呢？我们的原则是�Q�判断哪个class拥有最�?#8220;被此函数使用”的数据，然后��把�q�个函数和那些数据摆在一赗��如果先以Extract Method��这个函数分解�ؓ��C��较小函数�q�分别放�|�于不同地点�Q�上�q�步骤也��比较容易完成了�?br>3.8Data Clumps(数据泥团)
��?#8220;��L��l�在一起出现的数据”放进属于它们自己的对象中。首先找��些数据的值域形式出现点，�q�用Extract Class��它们提炼到一个独立的对象中。然后运用Introduce Parameter Object �?Preserve Whole Object为参数过长的成员函数减肥�?br>一个好的评判数据惔团的办法�Q�删除掉众多数据中的一�W�。其他数据如果不再有意义�Q�这��是个明��的信号�Q�你应该为它们��生一个新对象�?/p>
3.9Primitive Obsession(基本型别偏执)
对象技术的新手通常不愿意在��Q务上�q�用��对�?-像是�l�合数值和币值的money class、含一个�v始值和一个结束值得range class、电话号码或邮政�~�码(ZIP)�{�等的特�D�strings。你可以�q�用Replace Data Value with Object��原本单独存在的数值替换�ؓ对象。如果欲替换之数值是type code�Q�型别码)�Q�而它不媄响行为，你可以运用Replace Type Code with Class��它换掉。如果你有相依于此type code的条件式�Q�可�q�用Replace Type Code with SubClass或Replace Type Code with State/Strategy 加以处理�?br>如果你有一�l�应该��L��攑֜�一��L��值域�Q�可�q�用Extract Class。如果你在参数列中看到基本型数据�Q�不妨试试Introduce Parameter Object。如果你发现自己正在从array中挑选数据，可运用Replace Array with Object�?br>Replace Type Code with Class
在以C为基��的编�E�语�a�中，type code(型别�?或枚丑ր�很常见。如果带着一个有意义的符号名�Q�type code的可��L��还是不错的。问题在于，�W�号名终�I�只是个别名�Q�编译器看见的、进行型别检验的�Q�还是背后那个数倹{��Q何接受type code作�ؓ引数(argument)的函敎ͼ�所期望的实际上是一个数��|��无法强制使用�W�号名。这会大大降低代码的可读性，从而成��虫之源�?br>如果把那��L��数��D�{换�ؓ一个class�Q�编译器��可以对�q�个class�q�行型别��验。只要�ؓ�q�个class提供factory method�Q�你��可以始�l�保证只有合法的实体才会被创建出来，而且它们都回被传递给正确的宿��d��象�?br>但是如果枚�D被switch所使用�Q�你��׃��能简单地��它替换为class。因为switch往往只会接受整型数据。所以应该首先对switch�q�用Replace Conditional with Polymorphism重构�Q�而在�q�之前，�q�要�q�行Replace Type Code with Subclasses或Replace Type Code with State/Strategy把type code处理掉�?br>作法�Q?br>1、�ؓ type code建立一个class。其中包含相应的用于记录type code的值域�Q��ƈ准备一�l�static变量保存允许被创建的实体�Q��ƈ以一个static函数�Ҏ��原本的type code �q�回合适的实体�?br>2、修改source class代码�Q�让他��用上�q�新建的class�?br>3、编译、测�?br>4、对于source class中每一个��用type code 的函敎ͼ�相应建立一个函敎ͼ�让新函数使用新的class。你需要徏�?#8220;以新class实体��变量”的函敎ͼ�用以替换原先“直接以type code为引�?#8221;的函数。你�q�需要徏立一�?#8220;�q�回新class实体”的函敎ͼ�用以替换原先一直返回type code的函数。徏立新函数前，你可以��用Rename Method修改原函数名�U�ͼ�明确指出那些函数仍然使用旧式的type code�?br>5、逐一修改source class用户�Q�让它们使用新接口�?br>6、每修改一个用��P��~�译�q�测试�?br>7、删除��?#8220;type code”的接口，�q�删除保存旧type code的静态变量�?br>8、编译测试�?br>Replace Type Code with SubClass
我的理解�Q?br>
在这里Room�c�d��含一个属性IsMeetingRoom。如果�ؓtrue�Q�则�q�个戉K��是一个会议室�Q�如果�ؓfalse�Q�则�q�个戉K��是一个普通的戉K��。这里true和false可以理解��Z��个简单的“型别�~�码”。它可以重构��Z��面的形式�Q?br>
更复杂的情况�Q?br>
�q�样��需要根据RoomType的实际数量分��d��多个子类来�?/p>
作法�Q?br>使用Self Encapsulate Field�Ҏ��把type code自我��装��h��。如果type code被传递给构造函敎ͼ�你就需要将构造函数换成factory method.
为type code的每一个数值徏立一个相应的subclass。在每个subclass中覆写type code的取值函�?getter)�Q��其返回相应的type code倹{�?br>每徏立一个新的subclass,�~�译�q�测试�?br>从superclass中删除掉保存type code的值域。将type code讉K��函数声明为抽象函数�?br>�~�译�Q�测试�?br>Replace Type Code with State/Strategy
你有一个type code�Q�它会媄响class的行为，但你无法使用subclassing�?br>以state object(专门用来描述状态的对象)取代type code�?br>之所以无法subclassing是因为Type Code会在对象生命周期�q�程中发生变化�?br>如果你打��再完成本项重构之后再以Replace Conditional with Polymorphism(用多态替换条件判�?��化一个算法，那么选择Strategy模式比较合适；如果你打��搬�U�M��状态有关的数据�Q�而且你把新徏对象视�ؓ一�U�变�q�状态，��应该��用State模式�?br>
Replace Array with Object
你有一个数�l?array)�Q�其中的元素各自代表不同的东�ѝ�?br>以对象替换数�l�，对于数组中的每个元素�Q�以一个值域表示之�?br>String[] row =new String[3];
row[0]="Liverpool";
row[1]="15";
转换�?br>Performance row=new Performance();
row.setName("Liverpool");
row.setWins("15");
3.10Switch Statements

如果你只是在单一函数中有些选择事例�Q�而你�q�不��x��动它们，那么“多�?#8221;��有�Ҏ��鸡用牛刀了。这�U�情况下Replace Paremeter with Explicit Method是个不错的选择。如果你的选择条�g之一是null�Q�可以试试Introduce Null Object
Replace Paremeter with Explicit Method
此方法即是将包含多个switch分支的函数的各个分支独立成不同的函数。比如：
public static Object CreateObject(int typeOfObject)
{
      switch(typeOfObject)
      {
            case 1:return new A();
            case 2:return new B();
            case 3:return new C();
      }
}
转换为：
public static Object Create1()
{
      return new A();
}
public static Object Create2()
{
      return new B();
}
public static Object Create3()
{
      return new C();
}
思考：�q�样会削弱此函数的运行期�Ҏ��?br>Introduce Null Object
使用�q�种重构�Ҏ��的好处就是你不用在向一个对象发送消息的时候去��验这个对象是否存在。因为对象确实存在，只不�q�有可能对你发送的消息做出“我是�I?#8221;的回应�?br>作法
为source class建立一个subclass�Q��其行为像source class的null版本。在source class和null class中都加上IsNull()函数�Q�前者的IsNull()应该�q�回false�Q�后者的应该�q�回true.可以建立一个nullable接口�Q�将isnull函数攑֜�其中�Q�让source class实现�q�个接口�?br>另外可以创徏一个testing接口�Q�专门用来检验对象是否�ؓnull.
�~�译�?br>扑և�所�?#8220;索求source obejct却得��C��个null”的地斏V��修改这些地方，使他们改而获得一个null object�?br>扑և�所�?#8220;讲source object与null做比较的地方”。修改这些地方，使它们调用IsNull()函数�?br>你可以在不该在出现null value的地�Ҏ��上一些断�a��Q�确保null的确不再出现。这可能对你有所帮助�?br>�q�出�q�样的程序点�Q�如果对象不是null�Q�做A动作�Q�否则做B动作�?br>对于每一个上�q�地点，在null class中覆写A动作�Q��其行为和B动作相同�?br>使用上述的被覆写动作(A)�Q�然后删�?#8220;对象是否�{�于null”的条件测试。编译�ƈ��试�?br>其他�Ҏ��情况
使用本项重构�Ӟ��你可以有数种不同的null objects�Q�例如你可以�?#8220;没有��֮�”�?#8220;不知名顾�?#8221;�q�两�U�情冉|��不同的。果真如此，你可以针对不同的情况建立不同的null class。有时候null objects 也可以携带数据，例如不知名顾客的使用记录�{�等�?br>本质上讲�Q�这是一个比Null Object模式更大的模式：Special Case模式。所谓Special case class是某个class的特�D�情况，有着�Ҏ��的行为。因此表�q�C��知名��֮�的UnKnownCustomer 和表�C�没有顾客的NoCustomer都是Customer的特例。你�l�常可以在表�C�数量的class中看到这��L��特例�c�R��例如Java��点数有“正无�I�大”�?#8220;负无�I�大”�?#8220;非数�?#8221;�{�特例。special case class的�h值是�Q�它们可以降低你的错误处理开销。例如��Q点运��决不会抛出异常。如果你对NaN作��Q点运��，�l�果也会是个NaN。这�?#8220;null object”的访问函数通常会返回另一个null object是一��L��道理�?/p>

littlegai 2007-07-17 21:26 发表评论

The C++ Standard Library : A Tutoral and Reference ��M��W�记之auto_ptr

littlegai — Thu, 12 Jul 2007 14:46:00 GMT
        �q�一部分会将要讨��Z��下auto_ptr.c++标准库提供auto_ptr作�ؓ一�U�智能指�?有了�q�种��指针,��可以在异常被抛出的时候避免资源的泄漏.注意,auto_ptr只是��指针的一�U?因�ؓ事实上有多种��指针存在.而auto_ptr只是被用来满��x��U�情形下的需求的.而对于其他一些情�?auto_ptr无能为力.所以在使用的时�?要格外注�?
        auto_ptr的动�?/span>
        通常,一个函��C��按照下面的流�E�进行操�?
        1.获取资源.
        2.�q�行一些操�?
        3.释放之前所获取的资�?
        如果函数所获取的那些资源与本地对象�l�定,它们��׃��在函数结束的时候被自动释放�?因�ؓ本地对象的析构函��C��被调�?但是如果资源被显式获�?�q�且没有与�Q何对象绑�?它们必须也被昑ּ�的释放掉.在��用指针的时�?资源通常是被昑ּ��理�?
        一�U�典型的像上面这样��用资源的方式��是使用new来创建和用delete来释�?
        但是作释攄��的delete操作往往被忽�?特别是函数有�q�回值的时�?.当然,出现异常的时�?也同样会发生�q�种风险.因�ؓ异常有可能马上停止你函数的执�?而不去进行delete释放.�l�果��是内存泄漏,或者说得宽泛一�?�?资源泄漏".��Z��避免资源泄漏,通常需要函数能够捕��h��有的异常.随之而来的就�?代码变得��来��复�?冗长.
        伴随着�q�种情况的发�?一�U�智能指针auto_ptr出现�?在�Q何时�?一旦指针本�w�被销�?它所指向的数据也会被销�?此外,因�ؓ��指针是一个本地变�?不管函数到底是因为正常结�?�q�是因�ؓ非正常结�?auto_ptr所指向的数据都会被销�?
        有了auto_ptr,delete语句和catch语句��变得不那么必要�?auto_ptr和普通指针的使用方式基本相同,即用��L��"*"表示它所指向的对�?同样�?->"来访问所指向对象的成员方�?但是有关指针的运��?比如指针的自�?不被支持(�q�也许是一个优�?因�ؓ指针�q�算也许会造成一些麻�?.
        注意auto_ptr<>不允�怽�使用指派的方式来声明它所指向的对�?比如:
        下面的操作是不允许的:
        std::auto_ptr ptr2 = new ClassA; //ERROR
        而应该采用显式的构造函数来初始�?
        std::auto_ptr ptr1(new ClassA); //OK
        通过auto_ptr来�{换所有权
        auto_ptr在语意上提供了对于所有全的严格约�?�q�意味着因�ؓ如果一个auto_ptr删除了它所指向的对�?那么�q�个对象��不会被其他��M��对象所拥有.两个或以上的auto_ptr�l�不能同时拥有一个对�?不幸的是,�q�种情况是有可能出现�?所以只能有�E�序员来��保�q�种情况不会发生.
        那么在这�U�情况下,auto_ptr的拷贝构造函数如何工作呢?通常它会把一个对象的数据复制�l�另外一个对�?但是在这�?恰恰是这�U�行��Z��D��两个auto_ptr拥有相同对象�q�种情况的出�?解决�Ҏ��很简�?但是却得��Z��一个重要结�?auto_ptr的拷贝构造函数和指派操作促成了auto_ptr对于对象所有权的一�ơ移�?
        看一下下面的代码:
        //initialize an auto_ptr with a new object
        std::auto_ptr ptr1(new ClassA);
        //copy the auto_ptr
        //- transfers ownership from ptr1 to ptr2
        std::auto_ptr ptr2(ptr1);
        �W�一句中,ptr1拥有new所创徏的那个对�?然后�W�二句把对于对象的所有权从ptr1转移�l�了ptr2.所以在�W�二句之�?ptr2拥有new创徏的那个对象的所有权,而ptr1则自动失��M��对于那个对象的所有权.ClassA只会在ptr2被析构的时候被释放�?
        同样,对于一�ơ指�z�操作也是如�?如下所�C?
        //initialize an auto_ptr with a new object
        std::auto_ptr ptr1(new ClassA);
        std::auto_ptr ptr2; //create another auto_ptr
        ptr2 = ptr1;        //assign the auto_ptr
                      //- transfers ownership from ptr1 to ptr2
        注意,随着所有权的移�?之前失去对象所有权的那个auto_ptr��变成了一个空指针.
        当然,�q�可以让�q�个失去所指的�I�指针重新指向一个对�?像下面这�?
        std::auto_ptr ptr;               //create an auto_ptr
        ptr = std::auto_ptr(new ClassA); //OK, delete old object and own new
        对于所指向的对象的所有权的变换�ؓ我们提供了auto_ptr的一�U�潜在用�?函数可以使用向其他的函数传递所有权.�q�包含两�U�情�?
        1.传入函数的对象不再��?卛_��auto_ptr作�ؓ参数传递的时�?在这�U�情况下,被调用的函数得到了传入的auto_ptr所指向的那个对象的所有权.因此,如果函数不再��对象的所有权转移出来,那么对象��׃��在函数的调用�l�束之后销�?
         2.函数要向外传出对�?当auto_ptr被返回的时�?所有权��p��调用的函数�{�Uȝ��调用�?
         �׃��auto_ptr��L��牉|��到对象所有权变换的问�?所以在使用的时候一定要注意你是否真的要转换�q�个所有权.
         你可能打��通过引用传递auto_ptr(s).但是�q�样做有可能最�l�你都不清楚所有权的归属了.��M��,�q�不是一个好的决定或设计.
        从auto_ptr的概念出�?你可能会觉得即��是传递常指针的话,对象的归属也会改�?如果�q�种情况可能发生,那将是非常危险的.因�ؓ��Z��L��不期待一个成�?帔R��"的东西发生改�?�q�运的是,通过一些技术上的处�?�q�样做是不可能的.�?

1 #include<iostream>
2 using namespace std;
3 int getValue(auto_ptr<int>);
4 int main()
5 {
6     const auto_ptr<int> myAutoPtr=auto_ptr<int>(new int);
7     *myAutoPtr=10;
8     cout<<getValue(myAutoPtr)<<endl;
9
10 }
11 int getValue(auto_ptr<int> ptr)
12 {
13     return 10*(*ptr);
14 }
       上面首先定义了常量的auto_ptr,�q�就表明,�q�个auto_ptr不能��自己所指对象的所有权传递给其他对象.因而调用函数getValue的时候如果传递了上面定义的auto_ptr,��׃��被编译器发现,�q�作为编译错误反馈回�?
错误�Q?passing ‘const std::auto_ptr’ as ‘this’ argument of ‘std::auto_ptr<_Tp>::operator std::auto_ptr_ref<_Tp1>() [with _Tp1 = int, _Tp = int]’ discards qualifiers
��auto_ptr(s)作�ؓ成员变量
当然,如果在类中��用auto_ptr的时�?你同样也可以避免资源泄漏�q�种问题的发�?如果你��用auto_ptr取代通常的指针的�?你将不再需要对那些对象�q�行手动的析构处�?同时,auto_ptr也能够有效避免因为初始化异常而导致资源泄漏这�U�情�늚�发生.因�ؓ析构��L��在构造之�?所以如果在构造的时候发生异�?你往往不能够及旉��放资�?�q�而导致资源泄漏情�늚�发生.
        但是,在��n用了auto_ptr带来的诸多好处的同时,你在处理拯��构造函数和重蝲赋值操作的时�?要格外注意auto_ptr所有权变换的问�?当然,避免�q�类问题的最好方法就是��用常量指�?
        有关auto_ptr(s)的滥�?/span>
        auto_ptr能够满��一些需�?特别是容易发生资源泄漏的时�?它总能够发挥好的效�?但是在��用它的时候仍焉��要注�?不要滥用.在��用的时�?要注意以下几�?
        1.auto_ptr(s)不能够共享对于所指向对象的所有权.
        2auto_ptr(s)不提供对于数�l�的支持.因�ؓ在释放资源的时�?auto_ptr使用的是delete而不是delete[].当然,对于数组而言,STL也有相应的处理办�?比如容器.
        3.auto_ptr(s)不是��指针的全�?注意它�ƈ不能解决一切问�?注意它的应用场景.
        4.auto_ptr(s)不能满��容器中对象的操作要求.





littlegai 2007-07-12 22:46 发表评论

重构--改善既有代码的设计读书笔�?�W�三�?4)

littlegai — Tue, 10 Jul 2007 14:16:00 GMT

现在回到重构--改善既有代码的设计这本书�?br>3.4Long Parameter List�Q�过长参数列�Q?br>如果“向既有对象发��Z��条请�?#8221;��可以取得原本位于参数列上的一份数据，那么你应该激�z�重构准则Replace Parameter with Method。上�q�的既有对象可能是函数所属class内的一个值域�Q�也可能是另一个参数。你�q�可以用 Preserve Whole Object��来自同一对象的一堆数据收藏�v来，�q�以该对象替换它们。如果某些数据缺乏合理的对象归属�Q�可使用Introduce Parameter Object为它们制造出一�?#8220;参数对象”�?/p>
Replace Parameter with Methods(以函数取代参�?
对象调用某个函数�Q��ƈ��结果作为参敎ͼ�传递给另外一个函数。而接受该参数的函��C��可以�Q�也有能力）调用前一个函数�?br>动机
如果函数可以通过其它途径�Q�而非参数列）获得参数��|��那么它就不应该通过参数取得该倹{�?br>�~�减参数列的办法之一��是�Q�看�?#8220;参数接受�?#8221;是否可以通过“与调用端相同的计��?#8221;来取得参数携带倹{��如果调用端通过“其所属对象内部的另一个函�?#8221;来计��参敎ͼ��q�在计算�q�程�?#8220;未曾饮用调用端的其它参数”�Q�那么你��应该将�q�个计算�q�程转移到被调用端内�Q�从而除去该��参数。如果你所调用的函数隶属另一对象�Q�而该对象拥有一个reference指向调用端所属对象，前面所说的�q�些也同样适用�?br>作法
1、如果有必要�Q�将参数的计��过�E�提炼到一个独立函��C��?br>2、将函数本体�?#8220;对该参数的引�?#8221;替换为对“新函数的引用”�?br>3、每�ơ替换后�Q�修改�ƈ��试�?br>4、全部替换完成后�Q�适用Remove Parameter��该参数��L��?/p>

思考：
��实从实践角度讲�Q�上面这�U�方法是一�U�很实用的重构方法。确实是�~�减了函数的参数个数�Q��ƈ隐藏了一些中间结果。但是我认�ؓ�Q�在应用�q�个�Ҏ��的时候，�q�应当考虑�q�样两个问题�Q?br>1、当中间函数�Q�方法）被隐藏的时候，以这个中间函数的�q�回��gؓ参数的那个函数名�q�能够表�q�自��q��用途吗�Q?br>2、被修改的那个函数所处的具体语境是什么。因为在面向对象�~�程的时代，单独去考虑一个函数的情况是很��的。确保这个函数是否处在正��的位置上（如是否处在正��的�c�M��Q�是必要的�?br>

此间存在一个重要的例外。有时候你明显不希望造成“被调用之对象”�?#8220;较大对象”间的某种依存关系。这时候将数据从对象拆解出来单独作为参敎ͼ�也很合情合理。但是请注意其所引发的代仗��如果参数列太长或变化太频繁�Q�你��需要重新考虑自己的依存结构了�?
Introduce Parameter Object�Q�引入参数对象）
某些参数��L��很自然的同时出现�Q�以一个对象取代这些参数�?br>你常会看到特定的一�l�参数��L��一赯��传递。可能有好几个函数都使用�q�一�l�参敎ͼ��q�些函数可能隶属同一个class�Q�也可能隶属不同的classes。这样一�l�参数就是所谓的Data Clump(数据泥团)。我们可以运用一个对象包装所有这些数据，再以该对象取代它们�?br>作法�Q?br>1、新��Z��个class�Q�用以表��C��x��换的一�l�参数。将�q�个class设�ؓ不可变的(不可被修改的�Q�immutable)�?br>2、编译�?br>3、针对��用该�l�参数的所有函敎ͼ�实施Add Parameter�Q�以上述新徏class之实体对象作为新��d��敎ͼ��q�将此一参数��D��为null�?br>4、对于Data Clump(数据泥团)中的每一��?在此均�ؓ参数)�Q�从函数�{�֐�式中�U�除之，�q�修改调用端和函数本体，令他们都改而通过“新徏的参数对�?#8221; 取得该倹{�?br>5、每除去一个参敎ͼ��~�译�q�测试�?br>6、将原先的参数全部除��M��后，观察有无适当函数可以�q�用Move Method搬移到参数对象中�?/p>
思考：
现在我有一个函数f�Q�函数定义如下：
public string f(int i,int j,string s)
{
   int newValue=i+j;
   string result=s+":"+newValue.ToString();
   return result;
}
现在我把�q�三个参数�{化�ؓ�c�d��象，�c�d��定义为MyParameter

public class MyParameter
    {
        int _i;

        public int I
        {
            get { return _i; }
            set { _i = value; }
        }
        int _j;

        public int J
        {
            get { return _j; }
            set { _j = value; }
        }
        string _s;

        public string S
        {
            get { return _s; }
            set { _s = value; }
        }
        public MyParameter(int i, int j, stirng s)
        {
            _i = i;
            _j = j;
            _s = s;
        }

    }

然后再我的代码中�q�样写：
f(new MyParameter(3,2,"Result"));

发现什么问题了吗？
1、好像参数�ƈ没有减少�Q�只不过是移动到了构造函��C��Q?br>2、你从f参数中将会看不出f中到底需要什么东西（如果参数名称体现了参数的用途的话）�?br>�q�说明：
1、虽然这是经典的重构�Ҏ��Q�但是不能滥用，在��用的时候要谨慎考虑场景是否合适�?br>2、注意TDA原理�Q�不要刻意��生太多的中间对象�?br>3、参��C��能随便合�q�或隐去�Q�要特别注意领域模型�Q�要切合领域模型所表述的意图�?br>我个��为可以应用的场景�Q?br>��是文中所说的DataRange�Q�即适合于被转换为参数对象的参数列具有通用的含义，�q�且概念层次比较低�?/p>

littlegai 2007-07-10 22:16 发表评论

重构--改善既有代码的设计读书笔�?�W�三�?3)

littlegai — Sun, 08 Jul 2007 12:31:00 GMT

其实在看Martin Fowler的重构这本书的很长一�D�|��间里�Q�我一直把它错当成了另外一本书的中文版�Q�那本书的名字就是：John.Wiley.and.Sons.Refactoring.in.Large.Software.Projects.Performing.Complex.Restructurings.Successfully.Jun.2006
以前曄��看过�q�本书，目前�q�没有找��C��文版。相对于《重�?-改善既有代码的设计》的侧重实践来说�Q�上面这本书理论性更��Z��些。看讲实�늚�书有个缺点，��是你看了不上手做一做的话，�{�于白看�Q�而理论呢�Q�你可以��C��。所以下面穿插一些《Refactoring.in.Large.Software.Projects.Performing.Complex.Restructurings.Successfully》的理论�Q�有很多通过英文字面意思很隄��解，�q�样我会在网上找些资料，然后抄记在下面：
设计原理
        正如代码�?#8220;有味”一��P��l�构也会“有味”�Q�他们通常会由对于设计原理的违反而引赗��因此设计原理会为我们提供一些有价值的东西�q�而帮助我们�ؓ设计��d��狐臭。在我们从设计中扑և��q�反�q�些设计原理的地方的同时,我们也有了自��q��x��来改善我们的设计。。下表列��Z��当前��行的设计原理：

1�?span style="BACKGROUND-COLOR: yellow">DRY(Don't Repeat Yourself)�Q�不要写重复的代码。也可以叫做“一�ơ且仅一��?Once and Only Once)”原理�?br>2�?span style="BACKGROUND-COLOR: yellow">SCP(Speaking Code Principle)�Q�代码应该清楚地表明它自��q��意图。代码中出现注释�Q�说明代码不能清楚地表现自己的意图�?br>3�?span style="BACKGROUND-COLOR: yellow">OCP(Open Closed Principle)�Q�一个设计单元应该向修改开放。这�U�修改不应该��D��调用�Ҏ��效。��承是一�U�能够让你达到此目的的方法。子�c�d��以进行一些调��_��而超�c�M��持不变�?br>4�?span style="BACKGROUND-COLOR: yellow">LSP(Liskov Substitution Principle)�Q�个软�g实体如果使用的是一个基�cȝ��话，那么一定适用于其子类�Q�而且它根本不能察觉出基类对象和子�c�d��象的区别。反�q�来代换是不成立�?br>5�?span style="BACKGROUND-COLOR: yellow">DIP(Dependency Inversion Principle)�Q�等�U�高的概念不应该依赖于等�U�低的概念（或实玎ͼ�。对于从属关�p�L��说刚好相反。因为等�U�高的概忉|��L��U�低的概忉|��说变动的可能性要��?br>6�?span style="BACKGROUND-COLOR: yellow">ISP(Interface Segregation Principle)�Q�接口隔��d��理。接口应该尽量的��。他们应该仅包含很少的方法，但是�q�些被放�|�在同一个接口中的方法应该是紧密相关的�?br>7�?span style="BACKGROUND-COLOR: yellow">REP(Reuse/Release Equivalency Principle)�Q�可重用的元素必然是已经被发布的元素�?/p> 8�?span style="BACKGROUND-COLOR: yellow">CRP(Common Closure Principle)�Q?font style="FONT-SIZE: 12pt" size=2>包中的所有类对于同一�c�L��质的变化应该是共同��闭的�?/font> 一个变化若对一个包产生影响�Q�则��对该报的所有类产生影响。而对其他的包不构成�Q何媄响�?br>9�?span style="BACKGROUND-COLOR: yellow">ADP�Q�Acyclic�Q�无环的�Q�Dependencies Principle�Q�：包之间的依赖关系应当是无环的�?br>10�?span style="BACKGROUND-COLOR: yellow">SDP(Stable Dependencies Principle)�Q�一个包应该依赖于至��像它自己那��L��定的包�?br>11�?span style="BACKGROUND-COLOR: yellow">SAP�Q�Stable Abstractions Principle�Q�：��稳定的包，其抽象程度越高。不�E�_��的包通常是具体化的包�?br>12�?span style="BACKGROUND-COLOR: yellow">TDA�Q�Tell,Don't Ask�Q�：不要向一个对象去甌��另外一个对象，而应该告诉这个对象应该如何去做�?br>13�?span style="BACKGROUND-COLOR: yellow">SOC(Separation Of Concerns)�Q�不要在一个类中包含多个关注点。这通常也被叫做“责�Q单一原理”�?br>�c�d��p�d��中的“狐臭”
两个或多个类之间的关�p�通常包含“使用”�?#8220;�l�承”两种。如果我们想在一个系�l�中扑և�“使用”关系�Q�我们应该看一�?#8220;静�?#8221;关系图。在�pȝ��q�行时呈现出来的“使用”关系构成了对象之间的动态关�p�d��?br>一、无用类

��Refactoring.in.Large.Software.Projects.Performing.Complex.Restructurings.Successfully
那些不再使用的类会因为具有一些显而易见的无用功能而增加系�l�的负担。这些负担包括：�E�序开发者需要花费大量的旉��来分辨出一个正��的�c�，构徏�pȝ��的时间变得更长，�pȝ��变得更加难以理解�?br>相对于完全无用的�c�，更多的情况下你会遇到包含部分无用代码的类。这是因��Z��个类中包含了太多的功能，而在真正使用的时候，那些功能又被抛弃掉了。我们可以在重构的时候依据这些功能把�c�进行拆分，通过拆分我们会首先得到无用类。然后进一步对它进行处理�?br>不仅仅单单一个类会成为无用类�Q�有的时候，处在同一个关�p�d��中的�c�都回成为无用类(s)�?br>无用�c�通常因�ؓ两种原因而出玎ͼ�
�Q�、技术上提供覆盖面尽可能�q�的支持�Q�一个开发者推��一个类可能最�l�会被用刎ͼ�即��没有�q�象表明现实中有与之对应的需求�?br>�Q�、重构：通过对系�l�的修改�Q�以前需要用到的�c�，现在变得陈旧�q�期了�?br>二、树型依赖关�p?br>
��Refactoring.in.Large.Software.Projects.Performing.Complex.Restructurings.Successfully
树型依赖关系图体��C��对于�pȝ��的一�U�分解。树中的每一个类都确定的被另外一个类使用�?br>鉴于在面向对象的应用�E�序中，功能分解本��n通常会被看作是一�U?#8220;狐臭”�Q�一�U�树型依赖结构像重复代码一样也应该被看作是一�U?#8220;狐臭”。在�?-6中，�c�Protocol除了被类Data Storage使用外，不再被别的地方��用。重用没有发生�?br>三、静态环状依赖关�p?br>
��Refactoring.in.Large.Software.Projects.Performing.Complex.Restructurings.Successfully
两个�c�d��此��用对�Ҏ��最��单的环状依赖关系。环状依赖关�p�M��也可以包含多个类�?br>环状依赖关系会��环本�w�变得更加臃�ѝ��环所��h��的消极媄响包括：
a、不可理解性：�q�些�c�M��能够被一个又一个的单独理解�Q�因为它们彼此依靠对�Ҏ��实现功能。又或者是�Q�一个类需要从多个�c�M��选择一个作为理解他们本�w�的前提�?br>b、可�l�护性：环状依赖可能包含严重的�ƈ且不可预��的递推关系�Q�进而导致修改包含它的系�l�变得非常困难�?br>c、可计划性：对环的修改到底会造成什么媄响是很难预期的。估��到底需要多��的工作来完成这个修改会是一件很困难的事�?br>d、设计的清洁性：因�ؓ处在环中的那些类会直接或间接的访问到处在环中的�Q意一个类�Q�因此，从理��Z��Ԍ��c�M��的这�U�关�p�d��随意了。如果在�q�个环中又恰好把一个方法放到错误的�c�M��Q�会��D��理解�q�种设计变得更加困难�?br>e、重用性：�q�些�c�d��d��旉��用。如果在一个给定的语境中，只有其中的一个类所提供的功能被��x��Q�因为处在环中，�q�个�c�M��能被��单的剥离�q��用�?br>f、可��试性：�q�些�c�d��M��赯��试。这增加了测试的要求以及堪错的难度。如果想要独立的��试其中的一个类�Q�就必须使用“伪对�?#8221;�?br>g、异常处理：通常异常会在环中�?#8220;堆积”。如果环中的一个方法抛��Z��异常�Q�他会潜在得影响环中的其他方法�?br>h、依赖引入问题：每一个处于环中的�c�d��时又依赖于另一个处于环中的�c�d��在环外的依赖关系�?br>昄��Q�环中的最大长度越大，代码�?#8220;狐臭”呛_��浓。然而，在有些地方，只包含两个类的环却是一�U�被推崇的设计方案，被应用于很多设计模式中（如�P代器模式�Q��?br>四、显式依�?br>面向对象支持��装原理以及信息隐藏原理�Q�内部的实现被隐藏于接口之中。客��L��的代码无��ȝ��道�Q何有关于API的实现。另外，接口与实现类之间存在一�?#8220;裂痕”。很多开发者相信封装和信息隐藏只会在成员变量被定义�?#8220;�U�有”的时候才会有效。这当然不是事实�Q�在很多�pȝ��中都是支�?#8220;属�?#8221;的，�q�且属性可以被�l�承。然而，有这样一个事实，在一个系�l�中�Q�显式依赖关�p�d��是无法隐藏的。一个具有公�׃��赖关�pȝ��pȝ��在被修改的时候，��M��产生�q�样那样的问题，反之�Q�私有的局部的依赖关系只会有小范围的媄响�?br>TDA(Tell,don't ask)原理指出了一条正��的途径�Q�理��x��况下�Q�客��L��告诉对象自己打算做什么。既不要通过已有对象获取一个新的对象，更不要用那个新的对象�q�行一些操作�?br>下面看一个例子。在�q�个例子中，“订单”有很多的状态。我们可以简单的以打开的订单和关闭的订单来��单的区分一下。打开的订单就是客��h��回款的订单。现在我们要写一些代码，来计��所有打开的订单的总额�?br>如果我们使用一个方法calculateValueOpenOrders(注意�Q�这个方法是写在调用方的�Q�我们的调用方的�c�d��定�ؓFoo�Q�，而方法体如下。可以看��个方法违反了TDA原理�Q?br>
public float calculateValueOpenOrders(ListOfOrders orders)
{
    float totalValue = 0.0f;
    for (int i=0; i<orders.getNumber(); i++)
    {
        Order a = orders.getOrder(i);
        if (a.isOpen)
        {
            totalValue += a.getValue();
        }
    }
    return totalValue;
}
原因��是客户端的Foo直接使用Orders来获取其中的一些信息，而不是告诉Orders我要做什么�?br>
��Refactoring.in.Large.Software.Projects.Performing.Complex.Restructurings.Successfully
现在我们做一下修改，把打开的订单的金额计算�U�d��到订单内部进行。如果订单是打开的，�q�回本订单的金额�Q�反之，�q�回0�?br>
public class ListOfOrders
{
    public float calculateValueOpenOrders()
    {
        float totalValue = 0.0f;
        for (int i=0; i<getNumber(); i++)
        {
            Order a = getOrder(i);
            totalValue += a.getOpenValue();
        }
        return totalValue;
    }
}

public class Order
{
    public float getOpenValue()
    {
        if (isOpen())
        {
            return getValue();
        }
        else
        {
            return 0;
        }
    }
}
我们可能会因为所有Order都要�q�回打开的订单的金额而感觉不爽。如果你打算多次使用TDA原理�Q�你可能通过增加一个方�?#8220;addOpenValue”来增加类order的柔性。但是，同时�q�也意味着�c�Order会知道另外的一些Order的存在。在�q�种情况下，我们可能会违反SOC�Q�即单一职责原理�Q�。我们不应该忽略�q�样一点：在��用一些设计原理的时候，�q�要兼顾�pȝ��的��^衡性。在�q�个例子中，�q�个�Ҏ��是否应该加入取决于它是否真的与这个类�?#8220;领域模型”所匚w��?br>新的实现方式不仅仅��代码更加��短，而且�q�包括如下的优点�Q?br>功能有了正确的归属。在大多数情况下�Q�上面第一�D�代码中的方法calculateValueOpenOrders通常是被攑ֈ�UI�c�M��或者是一些Helper�c�M��Q�而这些类通常有一些奇异的名字�Q�比如OpenOrders Calculator�Q�。这对于�q�个�Ҏ��来说�Q�不是一个正��的归属�?br>TDA原理��保�cȝ��使用应该局部化�Q�而不要散步到�pȝ��的各个角落。因此可以简化一些优化方案的实现�?br>

littlegai 2007-07-08 20:31 发表评论

The C++ Standard Library : A Tutoral and Reference ��M��W�记之错误和异常处理

littlegai — Tue, 26 Jun 2007 14:18:00 GMT
;C++标准库风��D�E�?它包含了设计和实现风格各不相同的不同来源的��Y�?错误处理和异常处理是一个典�?标准库中的string�c�M��支持更加�l�化的错误处�?它们会监��每一处有可能发生问题的地方�ƈ会在有错误的时候抛出异�?另外一�?比如STL和valarrays比较安全性而言更加注重效率.所以它们很��监��逻辑错误,�q�仅仅在�q�行旉��误发生的时候才抛出异常.
有三�U�标准异常类:
1.语言支持型异�?Exceptions for language support )
比如:
用new创徏对象��p�|的时�?会抛出bad_alloc异常;
dynamic_cast��p�|会抛出bad_cast异常;
函数抛出不可控异常的时候会抛出bad_exception异常或调用unexpected函数.

#include <iostream>
class E1
{

};
class E2
{
};
void f_throwE1() throw(E1)
{
    throw E1();
}
void f_throwE2() throw(E1)
{
    throw E2();
}
void f_throwE2AsBadException() throw (E1,std::bad_exception)
{
    throw E2();
}
int main()
{
    try
    {

        f_throwE1(); //1:抛出可控异常
        f_throwE2(); //2:抛出不可控异�?执行unexpected函数
        f_throwE2AsBadException(); //3:抛出不可控异�?被认为是bad_exception
    }
    catch(const E1 &e1)
    {
        std::cout<<"E1 error occured"<<std::endl;
    }
    catch(const std::bad_exception &e2)
    {
        std::cout<<"bad_exception occured"<<std::endl;
    }
    catch(const E2 &e2)
   {
       std::cout<<"E2 error occured"<   }
   catch(...)
   {
       std::cout<<"unknown exception occured"<   }
}
上面的程序中,执行1,会��生如下的�l�果:
E1 error occured
执行2,�q�没有被作�ؓ�c�d��E2的异常所捕获.而是出现了如下提�C?
terminate called after throwing an instance of 'E2'
忽略
现在执行3.�l�果�q�没有捕获到std::bad_exception异常.而是仍然出现了这��L��错误提示:
terminate called after throwing an instance of 'E2'
忽略
同样的的例子,上面是在linux下执行的情况.下面换做vs2003的vc7.执行3,�l�果�?
unknown exception occured
即也没有捕获到std::bad_exception,但是被更加通用�?..所捕获�?�q�是�~�译器情�늚�不同.
2.c++标准库的异常(Exceptions for the C++ standard library)
c++标准库的异常�c�通常从logic_error�cȝ��?逻辑错误从理��Z��来说,臛_��应该被程序所避免,例如通过对于函数参数�q�行额外的测�?c++提供了诸如invalid_argument,length error,out_of_range,domain_error�{�异常类.
3.在程序域之外的异�?Exceptions for errors outside the scope of a program)
此类异常通常难于避免.
异常�cȝ��头文�?br>异常的基�c�d��bad_exception�c�被定义�?lt;exception>�?
�c�bad_alloc�?lt;new>中被声明;
bad_cast和bad_typeid�?lt;typeinfo>中被声明;
ios_base::failure�?lt;ios>中被声明;
所有其他的�c�都被定义在�?
异常�cȝ��成员
在异常类中除�c�d��信息之外,唯一可以获取的信息来自于函数what():
namespace std {
    class exception {
      public:
            virtual const char* what() const throw();
            ...
      };
}

使用what来获取信�?
try {
    ...
}
catch (const exception& error) {
    //print implementation-defined error message
    cerr << error.what() << endl;
    ...
}
可以以下面的方式创徏标准异常:
string s;
...
throw out_of_range(s);

或�?br>throw out_of_range("out_of_range exception (somewhere, somehow)");
从标准异常类�l�承
例如:

#include <exception>
#include <iostream>
class MyException:public std::exception
{
private:
    char* errorMessage;
public:
    MyException(const char* errMsg)
    {
        errorMessage=new char[strlen(errMsg)];
        strcpy(errorMessage,errMsg);
    }
    ~MyException() throw()
    {
        if(errorMessage)
        {
            delete[] errorMessage;
            errorMessage=NULL;
        }
    }
    virtual const char* what() const throw()
    {
        return errorMessage;
    }

};
int main()
{
    try
    {
        throw MyException("Error Occured!!");
    }
    catch(const std::exception &e)
    {
        std::cout<<e.what()<<std::endl;
    }

}

littlegai 2007-06-26 22:18 发表评论

The C++ Standard Library : A Tutoral and Reference ��M��W�记之命名空�?2)

littlegai — Mon, 25 Jun 2007 13:18:00 GMT
命名�I�间是�ؓ了应对命名冲�H�这�U�情�늚�出现而��生的 .命名�I�间是可扩展�?你可以��用相同的命名�I�间来定义你的那些在物理上处于不同位�|�的�l��g.一个典型的例子��是namespace std.
你可以有三种选择来��用std命名�I�间.
1.使用std::作�ؓ前缀.
�?
std::cout << std::hex << 3.4 << std::endl;
2.使用using �q�行预定�?br>using std::cout;
using std::endl;
然后�q�样使用:
cout << std::hex << 3.4 << endl;
3.直接使用using.
using namespace std;
cout << hex << 3.4 << endl;
不要在代码上下文不明��的地方使用�q�种用法( 如头文�g�?.
c++标准中对�?span style="font-weight: bold; font-size: 14pt;">头文�?/span>引入使用了一�U�新的写�?�?
#include
�q�实际上是引入了c++的标准模板库的iostream.h文�g.
而对于旧的c语言的头文�g,可以使用�q�种方式引入:
#include //相当�?lt;stdlib.h>
#include //相当�?lt;string.h>
有意思的�?如果在引入头文�g的时候这样写,可以把c风格的函数加上std命名�I�间来��?
�?

#include <cstring>
#include<cstdio>
int main()
{
    std::printf("%d",std::strlen("hello world!"));
}

当然,仍然可采用兼容于c风格的头文�g引入方式:
#include

littlegai 2007-06-25 21:18 发表评论

重构--改善既有代码的设计读书笔�?�W�二�?3)

littlegai — Sun, 24 Jun 2007 13:35:00 GMT

难以通过重构手法完成的设计改�?/strong>
比如说在一个项目中�Q�我们很难（但还是有可能�Q�将“无安全需求情况下构造�v来的�pȝ��”重构�?#8220;安全性良好的�pȝ��”�?br>�q�种情况下我的办法就�?#8220;�?span style="BACKGROUND-COLOR: yellow">惌��重构的情�?#8221;。考虑候选设计方案时�Q�我会问自己�Q�将某个设计重构为另一个设计的隑ֺ�有多大？如果看上��d��单，我就不用担心选择是否得当�Q�于是我��׃��选择最��单的设计�Q�哪怕它不能覆盖所有潜在需求也没关�p�R��但如果预先看不出简单的重构办法�Q�我��׃��在设计上投入更多力气�?br>何时不该重构�Q?br>重写�Q�而非重构�Q�的一个清楚的讯号��是�Q�现有代�?span style="BACKGROUND-COLOR: yellow">�Ҏ��不能正常工作。你可能只是试着做点��试�Q�然后就发现代码中满是错误，�Ҏ��无法�E�_��q�作。记住，重构之前�Q�代码必��v码能够在大部�?/span>情况�?span style="BACKGROUND-COLOR: yellow">正常�q�作�?br>另外�Q�如果项目自己已�q?span style="BACKGROUND-COLOR: yellow">最后期�?/span>�Q�你也应�?span style="BACKGROUND-COLOR: yellow">避免重构。在此时机，从重构过�E�中赢得的生产力只有在最后期限过后才能体现出来，而那个时候已�l�时不我予�?br>Wrad Cunningharn的看法：未完成的重构工作�?#8220;债务”。过于复杂的代码所造成的维护和扩展的额外开销�Q�就�?span style="BACKGROUND-COLOR: yellow">利息。你可以承受一定程度的利息�Q�但如果利息太高你就会被压垮。把债务��理�?/span>是很重要的，你应该通过重构来偿�q�部分债务�?br>重构与设�?br>Alistair Cockburn�Q�有了设计，我可以思考更快，但是其中充满��漏�z��?br>有一�U�观点认为：重构可以成�ؓ“预先设计”的替代品。这意思是你根本不必做��M��设计�Q�只��按照最初想法开始编码，让代码有效运作，然后再将它重构成型。极限编�E�的支持者极力提倡这�U�办法�?br>但这不是最有效的途径。极限编�E�的爱好者们也会�q�行预先设计。他们会使用CRC�?/span>或类似的东西来检验各�U�不同的��x��Q�然后才得到�W�一个可被接受的解决�Ҏ��Q�然后才开始编码，然后才能重构。关键在于：重构改变�?/span>“预先设计”的角艌Ӏ�如果没有重构，��必��M��?#8220;预先设计”的正��无误，�q�个压力太大了�?br>

什么是CRC�?
CRC(Class-Responsibility-Collaborator)卡徏模是一�U�简单且有效的面向对象的分析技术。在一个OO(面向对象)开发项目中�Q�包括用戗��分析员和开发者在建模和设计过�E�中�l�常应用CRC卡徏模，使整个开发团队普遍的理解形成一致�?br>它由三部分组成：
1. �c?Class)
2. 职责(Responsibility)
3. 协作(Collaborator)
一个类代表许多�c�M��的对象。而对象是�pȝ��模型化中��x��的事物。他们可以是一个�h、地斏V��事情、或��M��对系�l�有重要性的概念。类名在CRC卡的�剙��?br>职责是类需要知道或做的��M��事物。这些职责是�c�自�w�所知的知识�Q�或�c�d��执行时所知的知识�?br>协作是指��取消息，或协助执行活动的其他�c�R��在特定情�Ş下，与指定的�c�L��一个设惛_��同完成一�?或许�?步骤。协作的�c�顺着CRC卡的双��排列�?br>
(上图��http://book.csdn.net/bookfiles/116/1001163602.shtml)

在可以重构的前提下，你只需要得��C��?span style="BACKGROUND-COLOR: yellow">��_��合理的解��x��案就够了�?br>如果你在预先设计时在所有有可能出现变化的地斚w��建立��L��z�L��，却在最后发现这些灵�z�L��都毫无必要�Q�这才是最大的��p�|。你知道�Q�这其中肯定有些灉|��性的��派不上用场�Q�但你却无法预测到底哪些�z�不上用场�?br>而有了重构，则只需要考虑�Q�把一个简单的解决�Ҏ��重构成这个灵�zȝ��解决�Ҏ��有多大难度？如果�{�案�?#8220;相当�Ҏ��”�Q�那么你��只需实现目前�?span style="BACKGROUND-COLOR: yellow">��单方�?/span>��可以了�?br>重构与性能
虽然重构必然会��软�g�q�行更慢�Q�但它也使��Y件的性能优化更易�q�行。除了对性能有严��D��求的实时�pȝ��Q�其他�Q

何情况下“�~�写快速��Y�?#8221;的秘密就是：首先写出可调软�g�Q�然�?span style="BACKGROUND-COLOR: yellow">调整它以求获得��够速度�?br>�~�写快速��Y件的�Ҏ��Q?br>1、时间预��法�?br>为每个组件分配资源（包括旉��资源和执行轨�q�）�Q�每个组件绝对不能超�q�自��q��预算�Q�就��拥�?#8220;可在不同�l��g之间调度预配旉��”的机制也不行。例如心律调节器�Q�在�q�样的系�l�中�Q�迟来的数据��是错误的数据�?br>2、持�l�关切法�?br>要求�E�序员在��M��旉��做�Q何事�Ӟ��都要设法保持�pȝ��的高性能�?br>�q�种方式通常不会起太大作用。�Q何修改如果�ؓ了提高性能�Q�通常会�ɽE�序难以�l�护�Q�因而减�~�开发速度。性能一旦被分散到程序各个角落，每次改善都只不过是从“对程序行为的一�?span style="BACKGROUND-COLOR: yellow">狭隘视角”出发而已�?br>3、利�?0%�l�计数据
90%的优化都是白费劲�Q�因为难得被执行�?br>所以以一�U?#8220;良好�?span style="BACKGROUND-COLOR: yellow">分解方式”来徏造自��q��E�序�Q�不�Ҏ��能投以��M��兛_��Q�直臌��入性能优化阶段�?br>优化的过�E�：��量-->优化-->�~�译-->��试-->再次��量.
使用性能热点��量工具“发现热点、去除热�?#8221;�Q�直到获得客��h��意的性能�?br>McConnell提供了关于这��Ҏ��术的更多信息�?/p>

很想了解相关技�?但是没有扑ֈ�具体资料.倒是有两个开源项�?/p> p-unit�?strong>junitperf
http://www.javapronews.com/javapronews-47-20030721ContinuousPerformanceTestingwithJUnitPerf.html

littlegai 2007-06-24 21:35 发表评论

littlegai — Wed, 20 Jun 2007 14:50:00 GMT
静态常量的初始�?/span>
书中�?现在可以在类�l�构中初始化整型的静态成员了(��N��以前不可�?).我想书中大概是这个意�?

class MyClass
{
public:
static const int num=100;
int values[num];
};
int main()
{
std::cout<<MyClass::num;
}
main的声�?/span>
在c++标准中只有两�U�main函数的写法会被接�?

int main()
{

}

int main (int argc, char* argv[])
{

}
与C语言不同,C++在main中没有返回值的情况�?会隐式的�q�回0.但这�U�情�?�~�译器在�~�译的时�?会给你警�?
复杂度问题和大写的O标志
大写的O标志是用来考量一个算法的旉��复杂度的.如果�q�算的时间与�q�算元素的个数接�q�于正比,那么旉��复杂度就是O(n).当然除此之外,�q�有�q��的时间复杂度.�q�里��的是,c++ 中的数学库中一些算法的实现都仔�l�考虑了时间复杂度的问�?

littlegai 2007-06-20 22:50 发表评论

重构--改善既有代码的设计读书笔�?�W�一�?2)

littlegai — Wed, 20 Jun 2007 13:42:00 GMT

�q�用多�?polymorphism)取代与�h格相关的条�g逻辑
在另一个对象的属性基��上运行switch语句�Q��ƈ不是什么好��L��。如果不得不使用�Q�也应该在对象自��q��数据上而不是在别�h的数据上使用。选择对象之间的传递关�pȝ��时候，应当考虑选择��稳定的对象的属性传递给易变的对象（如书中的��租期长度来自Rental�Q�稳定，不易变）传递给Movie�Q�不�E�_��Q�易变）�Q��?br>对于�c�A和类B�Q�如果A中存在因B而变化的属性或�Ҏ��体，则将它们�U�d��到B中，A中只保留�U�d��后B暴露�l�A的接口（或方法）�?br>�l�于.......我们来到�l�承(inheritance)
此部分包含的重构�Ҏ��Q?br>Self Encapsulate Field�Q�自��装域�?br>Move Method�Q�移动方法�?br>Replace Conditional with Polymorphism�Q�用多态替换条仉��择�?br>Replace Type Code with State/Strategy�Q�在�q�个�Ҏ��中��用了上面三个�Ҏ��作�ؓ步骤。即用状态、策略替换代码，��与�c�d��怾�的行为搬�U�d��模式内。在使用它的时候，多��用对于以�c�d��怾�的行��行Self Encapsulate Field作�ؓ�W�一步骤。从而确保�Q何时候都通过getter和setter两个函数来运行这些行为。第二步通常采用Move Method�Ҏ��Q�即把代码从��类的宿��M��搬移到子�c�M��厅R��第三步采用Replace Conditional with Polymorphism�Ҏ��Q�将switch�Q�if�{�条件分支语句�{变�ؓ多态�Ş式�?br>下面是一个小实验�Q?br>一、重构之前的代码�Q?br>

public class ClassA {
    public int getValue(TheType type)
    {
        switch(type)
        {
        case SmallValue:return 100;
        case MidValue:return 200;
        case BigValue:return 300;
        default:return 0;

        }
    }

    public static void main(String args[])
    {
        ClassA instanceA=new ClassA();
        System.out.println("theValueIs:"+instanceA.getValue(TheType.SmallValue));
    }
}

应用Self Encapsulate Field之后的效果：

public class ClassAModified {

    /**
     * @param args
     */
    public TheValue _theValue;
    public int getValue(TheType type)
    {
        switch(type)
        {
        case SmallValue:return 100;
        case MidValue:return 200;
        case BigValue:return 300;
        default:return 0;

        }
    }


    public TheValue get_theValue() {
        return _theValue;
    }

    public void set_theValue(TheType type) {
            }

}
public class TheValue
    {

    }


应用Move Method之后的效果：

public class ClassAModified {

    /**
     * @param args
     */
    public TheValue _theValue;
    public int getValue(TheType type)
    {
        return _theValue.getValue(type);
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

    public TheValue get_theValue() {
        return _theValue;
    }

    public void set_theValue(TheType type) {
        _theValue=new TheValue();
    }
    public class TheValue
    {
        public int getValue(TheType type)
        {
            switch(type)
            {
            case SmallValue:return 100;
            case MidValue:return 200;
            case BigValue:return 300;
            default:return 0;

            }
        }
    }


}

应用Replace Conditional with Polymorphism之后的效果：

public class ClassAModified {

    /**
     * @param args
     */
    public TheValue _theValue;
    public int getValue(TheType type)
    {
        return _theValue.getValue();
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

    public TheValue get_theValue() {
        return _theValue;
    }

    public void set_theValue(TheType type) {
        switch(type)
        {
            case SmallValue:_theValue= new SmallValue();
            case MidValue:_theValue= new MidValue();
            case BigValue:_theValue= new BigValue();
            default:_theValue=new TheValue();

        }
    }
    public class TheValue
    {
        public int getValue()
        {
            return 0;
        }
    }
    public class SmallValue extends TheValue
    {
        public int getValue()
        {
            return 100;
        }
    }
    public class MidValue extends TheValue
    {
        public int getValue()
        {
            return 200;
        }
    }
    public class BigValue extends TheValue
    {
        public int getValue()
        {
            return 300;
        }
    }

}

�l�语
重构的节奏：��试、小修改、测试、小修改、测试、小修改。。�?br>正是�q�种节奏让重构得以快速而安全的前进�?br>

littlegai 2007-06-20 21:42 发表评论

littlegai — Sun, 17 Jun 2007 09:19:00 GMT
        数据�l�构上面在讲到栈的时候，��Z��提了一下递归。实际上递归��是用栈来实现的。在很多��法书上�Q�对于一些用递归方式写成的算法，相应的也�l�出了栈的算法。这里我要把fibonacci数列分别用递归和栈的方式写出来�Q�由于我以前的算法教材丢�׃��Q�而数据结构中也没有给出相应的伪码�Q�所以只有自�׃��头写起了�?br>        首先是fibonacci的递归写法�Q�不是很标准�Q�但是很亲切�Q�：

int fib(int value)
{
    if(0==value)
        return 0;
    else
        if(1==value)
            return 1;
        else
        {
            return fib(value-1)+fib(value-2);
        }
}
        接下来要把这个算法�{换�ؓ使用栈的写法�?br>        首先�q�行一下分析。递归是逆向求结果的�Q�对于不能求出结果的函数�Q�先��运行场景压栈，然后递归调用自己�Q�如果仍然不能出�l�果�Q�就再将�q�行场景压栈�Q�一直到函数可以�q�回�l�果为止。此时依�ơ将�q�行场景�Ҏ��Q�完成运行场景，取得�q�回��|��再弹�?.....印象中的递归调用�q�程��是如此。如果我们要自己写递归求fibonacci数列�Q�就要自己手动用�E�序来模拟这个过�E�。我首先准备一个栈来存攄��果序列。在�q�个�l�果序列里面�Q�保证第一个结果和�W�二个结果��L��可以直接求得的数倹{��因为只需要n-1和n-2便能求出fib(n)�Q�所以我们在��法中要把多余的n-3弹出�Q�这��h��内的元素个数在每一�ơ调用的�q�程中逐渐减少�Q�一直到里面只剩下一个元素，在这个时候，刚才弹出的两个元素之和就是我们要求的fibonacci(n)�?br>        下面是算法：

int fibByStack(int value)
{
    int currentValue;
    currentValue=value;
    while(currentValue>=0)
    {
        fibStack.push(currentValue);
        currentValue--;
    }
    fibStack.pop();
    fibStack.pop();
    //1�?是n=1和n=0时的��|��Z��压入的是“�l�果”�Q�我��头两个元素弹出再压入这两个�?br>    fibStack.push(1);
    fibStack.push(0);
    while(true)
    {
        int topValue1,topValue2
        topValue1=fibStack.top();
        fibStack.pop();
        topValue2=fibStack.top();
        fibStack.pop();
        if(1==fibStack.size())
            return topValue1+topValue2;
        fibStack.pop();
        fibStack.push(topValue1+topValue2);
        fibStack.push(topValue2);
    }
}

littlegai 2007-06-17 17:19 发表评论

The C++ Standard Library : A Tutoral and Reference ��M��W�记�?�c�d��转换(1)

littlegai — Sun, 17 Jun 2007 06:56:00 GMT
在阅�ȝ��型�{换之�?�q�是先看一下关键字explicit(昑ּ�)
书上的例子中的类名叫做Stack,�q�样��L��觉有些误�?因�ؓ栈这个概念已�l�在我们的脑��中先入��Z��?�Ҏ��形成思维定式.那么我写一个和其他��M��概念都无关的例子:

class MyClass
{
    private:
    int _number;
    public:
    MyClass(int number)
    {
        _number=number;
    }
};
上面的类很普�?没什么特别的.我们可以�q�样创徏�q�个�cȝ��对象:

int main()
{
    MyClass instance=5;
}
�q�就比较有意思了,c++�q�能�q�样�?我以前的��没有见�q?那么explicit关键字的作用��是不让你这样写,如果你这样写�?�~�译器就会给你一个错误提�C?现在攚w��一下MyClass

class MyClass
{
    private:
    int _number;
    public:
    explicit MyClass(int number)
    {
        _number=number;
    }
};
main函数不变的情况下,�~�译器会�q�样提示�?
Explicit.cpp: In function ‘int main()’:
Explicit.cpp:14: 错误�Q?conversion from ‘int’ to non-scalar type ‘MyClass’ requested
�q�样,��只能这样写�?
MyClass instance(5);
好了,下面开始阅�ȝ��型�{换的部分.
1 static_cast
�q�个操作�W�的执行�q�程可以被认为是:它创��Z��一个新的对�?然后用要转换的值去初始化这个新对象.�q�个转换只有当一个类型�{换被声明�q�才能执�?
首先是一个简单的例子:

//一个简单的�c�d��转换
   int valueToBeConverted=int();
   using namespace std;
   cout<<static_cast<float>(valueToBeConverted)<<"\n";
很像其他语言中的昑ּ��c�d��转换.那么对于我自��q��c�d��何进行�{换呢?可以看一下下面的�q�个例子:

#include <iostream>

class MyClass2
{
   public:
    int IntMember1;
   MyClass2()
   {
      IntMember1=1;
   }
};
class MyClass1
{
   public:
   int IntMember1;
   virtual void  f()
   {
       std::cout<<IntMember1<<"\n";
   }
   explicit MyClass1(MyClass2 instance)
   {
       IntMember1=instance.IntMember1;
   }
};
int main()
{
   MyClass2 mc2Instance;
   MyClass1 mc1Instance=static_cast<MyClass1>(mc2Instance);
   mc1Instance.f();
}
注意看上面的�_�体字explicit.如果没有explict对于构造函数的修饰,那么万全可以��单爽快的�q�么�?
MyClass1 mc1Instance=mc2Instance;
换句话说,如果你想让别人写代码的时候不兛_��c�d��,舒舒服服的写��Z��认�ؓ不安全的代码,那么你就��L��explicit,如果你想让别人在写代码的时�?让那些不安全的类型�{换变得更�?昄��"一�?那么你就按上面这样写.然后让编译器狠狠的给他们一个警�?
2 dynamic_cast
This operator enables you to downcast a polymorphic type to its real static type. This is
the only cast that is checked at runtime. Thus, you could also use it to check the type of a
polymorphic value.

�q�个�q�算�W�能够让你把一个多态的�c�d��转换成它的真实的静态类�?�q�是唯一的在�q�行时进行检验的转换�Ҏ��.所以你同样需要在转换之前��验多态值的�c�d��.
首先dynamic_cast只能够用于指针或者引�?否则�~�译器会告诉你类��D��L��错误:
无法��?‘scInstance’ 从类�?‘SubClass’ 动态�{换到�c�d�� ‘class BaseClass’ (target is not pointer or reference)
�q�里使用书中的例�?

class Car;         // 臛_��拥有一个抽象函数的抽象�c?/span>
   class Cabriolet : public Car {

   };
   class Limousine : public Car {

   };
   void f(Car* cp)
   {
       Cabriolet* p = dynamic_cast<Cabriolet*>(cp);
       if (p == NULL) {
           //p�q��Cabriollet�c�d��

       }
   }

In this example, f() contains a special behavior for objects that have the real static type
Cabriolet. When the argument is a reference and the type conversion fails,
dynamic_cast throws a bad_cast exception (bad_cast is described on page 26).
Note that from a design point of view, it it always better to avoid such type-dependent
statements when you program with polymorphic types.
当参数是一个引用�ƈ且类型�{换失败的时�?dynamic_cast会抛��Z��个bad_cast异常.值得注意的是,从设计的角度来说,通常在进行多态类型的�E�序�~�写�?应该避免�q�样的类型依�?
3 const_cast
This operator adds or removes the constness of a type. In addition, you can remove a
volatile qualification. Any other change of the type is not allowed.
�q�个操作�W�添加或除去一个类型的帔R��?�Ҏ�?.另外,你可以除��M��个变量变化的能力.��M��对于�q�个�c�d��变量的变化都��不被允�?
让常量可修改的例�?

class MyClass
{
    public:
        int MemberValue;
        void showValue()
        {
            cout<<"My Value is"<<MemberValue<<"\n";
        }
        MyClass()
        {
            MemberValue=1;
        }
};
int main()
{
    const MyClass myValue;
    MyClass *ptr=const_cast<MyClass*>(&myValue);
    ptr->MemberValue=100;
    ptr->showValue();
}
上面的例子只是将一个const变得可以修改�?但是注意��C��中的�q�样一�?
In addition, you can remove a
volatile qualification. Any other change of the type is not allowed.
��g��q�可以将一个可变量转换为非可变�?�q�里没有查到相关资料,也许书的后面会有相应解释,所以这里先放一�?
4 reinterpret_cast
�q�个比较有趣,支持不兼容类型之间的转换.以下是例�?

#include <iostream>
using namespace std;
class ClassA
{
    public:
    int Value1;
    int Value2;
    int Value3;
    void showValue()
    {
        cout<<Value1<<","<<Value2<<","<<Value3<<"\n";
    }
};
class ClassB
{
    public:
    int Value1;
    int Value2;
    int Value3;
    ClassB()
    {
        Value1=1;
        Value2=2;
        Value3=3;
    }
};
int main()
{
    ClassB *b=new ClassB();
    ClassA *a=reinterpret_cast<ClassA*>(b);
    a->showValue();
}
同样,�q�种转换对于非基本类型来�?仍然只能支持指针和引�?
�q�些�q�算�W�的优点��是他们明确了类型�{换的意图,�q�且能够让编译器获取更多的信息来了解�q�些�c�d��转换的原�?然后当这些�{换操作越�q�他们的职能的时�?�~�译器会报告错误.
另外需要注意的�?�q�些�c�d��转换都只能接受一个参�?看下面的例子:
    static_cast(15,100)
上面不会产生你想要的�l�果.�q�里的逗号�q�不是用来连接两个参数的,而是作�ؓ逗号�q�算�W�出�?�q�里15会被舍弃,而采�?00作�ؓ参数构造Fraction.
所以还是需要采用下面的�Ҏ��才合�?
    Fraction(15,100)

littlegai 2007-06-17 14:56 发表评论

重构--改善既有代码的设计读书笔�?�W�一�?1)

littlegai — Fri, 15 Jun 2007 14:53:00 GMT
        以前看过一点这本书的英文版�?感觉相当不错,但是�׃��英文水��^有限,��L��感觉里面有些说法�Ҏ��来说比较生�ӆ,特别�q�有一些理论性的东西,如果只看英文,基本上是无从查�v�?好在�q�本书有了中文版(也许早就有了,我可是才刚刚扑ֈ�),高兴之余,�l�细品读,写写�W�记,潦记于此.
        先看看书中有关重构的定义�Q?br>        重构的定义：�?span style="BACKGROUND-COLOR: yellow">不改�?/span>代码外在行�ؓ的前提下�Q�对代码做出修改�Q�以改进�E�序�?span style="BACKGROUND-COLOR: yellow">内部�l�构。本质上��_��重构��是在代码写好之后改�q�它的设计�?br>        �q�个定义说得很清楚了�Q�基本上不需要进行�Q何的说明。我们只要将它当作原则去�늅��好了�?br>        然后书中讲了�Q?br>        快速而随�?quick and dirty)的设计一个简单的�E�序�q�没有错�?br>        于是我就有这��L��问题了：
        什么规模的�E�序才值得重构�Q?br>        然后书中�l�了我这样一个回�{�：
        如果你发现自己需要�ؓ�E�序��d��一个特性，而代码结构��?span style="BACKGROUND-COLOR: yellow">无法很方�?/span>的那么做�Q�那��先重构那个�E�序�Q��Ҏ��的��d��比较�Ҏ��q�行�Q�然后添加特性�?br>        重构之前要做�q�样一些准备：
        重构的第一�?-��Z��码徏立测试环境�?br>重构之前�Q�首先检查自己是否有一套可靠的��试机制。这些测试必��L��自我��查能力�?br>        下面是一些摘录：
        首先在代码中扑և�函数内的局部变量和参数。�Q何不会修改的变量都可以被当成参数传入新的函数�Q�至于会被修改的变量��需要格外小心。如果只有一个变量会被修改，可以把它当作�q�回倹{�?br>在找��Z��个函数的逻辑泥潭�q�将之提�l�到另外一个函��C��的时候，要格外注意返回倹{��如果你�l�常犯这��L��错误�Q�那么一定确保在修改前后函数的调用结果相一致�?
        代码应该表现自己的目的，�q�一炚w��帔R��要�?span style="BACKGROUND-COLOR: yellow">阅读代码的时候，我经常进行重�?/span>。这��P��随着对程序的理解逐渐加深�Q�我也就不断地把�q�些理解嵌入代码中，�q�么一来才不会遗忘我曾�l�理解的东西�?br>        几个重构的方法（下面的伪码是我自己写的）�Q?br>        1、Extract Method �Q�提取方法）
        2、appending assignment ,operator+=�Q?附添赋值动作）
        �q�两�U�重构方法结合的形式为：
        重构前：
        A=0;
        A++;
        if(expression)
          A++;
        重构后：
         A=0;
         A+=function1();
         TypeOfA function1()
         {
             if(expression)
               return 2;
             else
               return 1;
          }
         3、Replace Temp with Query�Q�字面上用查询取代��时变量）
         利用所谓的query method来取代��时变量。由于class内的��M��函数都可以取用（调用�Q�所谓query methods,所以它能够促进比较�q�净的设计，而非冗长复杂的函数�?br>          Replace Temp with Query的伪码例子：
          A=0;
          while(expression)
          {
             A++;
           }
          return "The Result is "+A;
          上面A是一个��时变�?所以可以用一个querymethod来取代：
           TypeA function1()
          {
             A=0;
             while(expression)
             {
                A++;
              }
             return A;
           }
�q�样�ȝ��序可以这样写:
           return "The Result is "+function1();
�l�箋摘抄�Q?br>重构可能会存在另外一个问题，��是性能。原本代码只执行一�ơ��@环，在重构以后可能要执行三次。如果��@环中的语句耗时很多�Q�就可能大大降低�E�序的性能。单单�ؓ了这个原因，许多�E�序员就不愿�q�行�q�个重构动作。但是请注意�q�里只是“可能”。除非进行评��，否则无法��定循环的执行时��_��也无法知道这个��@环是否经�怋�用以至于影响�pȝ��的整体性能。重构时�E�序人员不必担心�q�些�Q�优化时才去担心它们�Q�但那时候你已经处于一个比较有利的位置�Q�有更多选择可以�q�行有效优化�?br>使用Form Template Method�Q�字面上建立模板�Ҏ��Q�可以进一步减��重复代码。这会在书后面的章节讲到�?

littlegai 2007-06-15 22:53 发表评论

littlegai — Thu, 14 Jun 2007 14:06:00 GMT
在这一部分之前,书中介绍了基本类型的昑ּ�初始化以及简单的异常处理.
基本�c�d��的显式初始化是比较简单的.��是说你在定义一个整型变量的时�?有两�U�不同的情况:
int i1;         // undefined value
int i2 = int(); // initialized with zero

如果按照前一�U?会作"值未定义;如果按照后一�U?则自动被初始化�ؓ0.�q�样也就��保了你的类在初始化的时候有一个确定的初始�?
至于异常的处理等问题,书中会在后面有比较详�l�的描述.�q�里可以看到比较有意思的一�?��是指定函数抛出的异常类�?�q�于Java很像:
void f() throw(bad_alloc);
下面转入正题:命名�I�间.
有了命名�I�间,它将会取代函数和�c�M��用于全局,�q�作为它所�l�领的那些类和函数的唯一标识存在.�q�样可以避免命名冲突情况的出�?正如书中所�?
Unlike classes, namespaces are open for definitions and extensions in different modules. Thus
you can use namespaces to define modules, libraries, or components even by using multiple
files. A namespace defines logical modules instead of physical modules (in UML and other
modeling notations, a module is also called a package).

可以像这样定义一个命名空�?

namespace MyNameSpace
{
    class MyClass
    {
        private:
        char * _classInfo;
        public:
        char* getClassInfo()
        {
            return _classInfo;
        }
        MyClass(const char* info)
        {
            _classInfo=new char[strlen(info)];
            strcpy(_classInfo,info);
        }
        ~MyClass()
        {
            if(_classInfo)
            {
                std::cout<<"free classinfo";
                delete[] _classInfo;
            }
        }
    };
    void printMyClassInfo(MyClass &instance)
    {
        std::cout<<instance.getClassInfo();
    }
}
从上面可以看�?�q�个命名�I�间里面包括了一个类和一个函�?�c�M��包含了char*�c�d��的成员变�?函数printMyClassInfo 以一个MyClass�c�d��的引用作为参�?��Z��么要用引用呢?熟悉c++的�h应当很清�?我是通过实验才刚刚知道原�?�q�个原因我将会在后面说明.
好现在来看一下调用过�E?通常的调用过�E�是�q�样�?

int main()
{
    MyNameSpace::MyClass instance("MyClass!\n");
    MyNameSpace::printMyClassInfo(instance);
}
�q�没有�Q何问�?但有意思的�?�q�可以这栯��?

int main()
{
    MyNameSpace::MyClass instance("MyClass!\n");
    printMyClassInfo(instance);
}
看来c++中在使用一个命名空间的�c�L��者函数的时�?�q�个命名�I�间��p��"自动"引入�?当寻扑և�数printMyClassInfo的时候会在当前的上下文中�q�行��L��的同�?�q�会��C��前用到过的命名空间中��d��?
当然,通常情况下我们喜�Ƣ这样做:

using namespace MyNameSpace;
int main()
{
    MyClass instance("MyClass!\n");
    printMyClassInfo(instance);

}
但是�q�不是在��M��情况下都鼓励using namespace�q�种做法�?在书中将得比较清�?
Note that you should never use a using directive when the context is not clear (such as in header
files, modules, or libraries). The directive might change the scope of identifiers of a namespace,
so you might get different behavior than the one expected because you included or used your
code in another module. In fact, using directives in header files is really bad design.

上面�q�段话强调了当上下文�q�不明确的情况下(比如在一个头文�g,�l��g或者库里面),不要使用using�q�种写法,�q�个指��o会改变命名空间标识符的作用域,�q�样你就有可能引发和你预期不相同的行�?因�ؓ你会在另外一个组件中引用你的代码或��用它.事实�?��using标识�W�写在头文�g里面是一�U�相当不好的设计.
在这�?我看了一下c++�E�序设计语言�q�本�?发现命名�I�间除了像上面这样声明以�?�q�可以像�c�M��栯��h��?
在命名空间中�q�样定义
void printMyClassInfo(MyClass &);
然后在外面写函数的主�?br>
void MyNameSpace::printMyClassInfo(MyClass &instance)
{
    std::cout<<instance.getClassInfo();
}
好了,写了�q�么�?再来看看刚才留下来的那个问题.
其实很简�?一个函数如果传递的是�?那么��׃��在内存中产生一个一模一��L��"复本",而那个字�W�指针也会被复制一��?当传送的��D��q�它的作用域的时�?,��׃��被释放掉,而被复制�?本体"在程序运行结束之�?又会�?释放一��?.�q�样在运行的时�?它会提示你这��L��错误:
*** glibc detected *** double free or corruption (fasttop): 0x0804a008 ***

在我们的MyClassl�cȝ��析构�?我们有一个输�?所以这里就输出了两��?
free classinfofree classinfo

littlegai 2007-06-14 22:06 发表评论

littlegai — Wed, 13 Jun 2007 11:42:00 GMT

富爸爸研�I�过公司法和�E�法�Q��ƈ扑ֈ�了利用法律�ؓ他赚很多��q��Ҏ��?br>mortgage
KK: []
DJ: []
抉|��h��Q�源于法语mortir�Q�法语意思是��M��Q�因而抵��D��Ƒְ�是直到死的一�U�契�U?br>real estate
KK: []
DJ: []
不动产，�q�不�?#8220;真正”的胦产，来自于西班牙语，意思是贉|��的胦产�?br>我们仅仅是在技术上控制了不动��Q�却�q�不能占有它�Q�政府占有这些胦产，向我们征收不动��E��?br>奥肖内西华尔街股市投资经�?br>What Works On Wall Street:A Guide to the Best Performing In-vestment Strategies of All Time
提出两种不同的决�{�方法：
�l�验型的分析�Ҏ��或称直觉式分析方法。该�Ҏ��以知识，�l�验和常识�ؓ基础�?br>定量分析法或�U�精��统计法。这�U�方法以大量数据为基��Q�推论出各种关系�?br>在多数情况下�Q�直觉分析法的投资者常常做出错误的军_��Q�或败给几乎�U�机械的�Ҏ��。即�Q��h�cȝ��推断力远��于我们所惌��的�?/p>
企业取得�?不动产组�?购买抉|��?贴现合同投资研讨�?�|�宾逊准�?br>有些东西你的眼睛是看不到的，不动产就是不动��Q�股��就是公司股��，�q�些东西你能看到�Q�但是你看不��Z��么事重要的。决定某�U�东西是不是一��好的投资的�q�有�Q�交易、胦务协议、市场、管理、风险因素、现金流、企业结构、税法和很多其他的事情�?br>你�ؓ什么要付这么高的利率？你认��Z��的投资回报是多少�Q�这��Ҏ��资于你的长期财务战略��d��吗？你打��用多大比例计算修理费用�Q�你知道�q�个城市刚刚宣布要在那个地区修�\以改善交通状况吗�Q�一条大道就要从你的房前�I�过�Q�你知道�q�些吗？我知道现在市场看好，但是你知道是什么在驱动市场�Q�商业经��还是贪婪？你认��U�趋势会�l�持多久�Q�如果你的房子租不出去，你将怎么办？

��q�不是现�?
成�ؓ-->�?->拥有
大多��C�h�q�求做而不是追�?#8220;成�ؓ”
一个拥有失败者心态的人将一直失�?br>不要在对方��n上下功夫�Q�而要在你对对方的看法上下功夫
丹尼��?格鲁�?《情商�?br>父母会说很多�?#8220;应该”�Q�小孩说很多�?#8220;感觉”
父母�q�不一定就是成�q��h
作�ؓ一个成�q��h应当意识��C��必须��d��什么�ƈ且去做，即��你可能感觉上�q�不喜欢做这件事
我的富爸�怸�许我��_��
“我付不�v�?#8221;
“我做不到”
“做事要稳�?#8221;
“别赔�?#8221;
“如果你失败了�q�且再也��M��了��n�Q�该怎么办？ ”
他不许我说这些是因�ؓ他坚信语�a�是�h�c�L��有媄响力的工��P��一个�h所说的和所想的�l�将变�ؓ现实�?br>用圣�l�里面的话即使：
语言��变��肉，留在我们体内�?/p>

littlegai 2007-06-13 19:42 发表评论

数据�l�构��M��W�记�Q�栈�Q�不只是C++的东西）

littlegai — Mon, 11 Jun 2007 14:11:00 GMT
栈在概念斚w��实没有提的必要了。看了数据结构的�q�一部分�Q�就��书中的一��段代码实现了。这里用��C��标准库中的stack。下面就是根据输入的十进制正数获取二�q�制正数的程序（书上是八�q�制�Q�：

1 #include <stack>
2 #include <iostream>
3 using namespace std;
4 int _tmain(int argc, _TCHAR* argv[])
5 {
6     stack<int> binaryStack;
7     int decimalValue;
8     cout<<"please input decimal value:";
9     cin>>decimalValue;
10     while(decimalValue)
11     {
12         binaryStack.push(decimalValue%2);
13         decimalValue=decimalValue/2;
14
15     }
16     cout<<"\n"<<"the binary result is:";
17     while(!binaryStack.empty())
18     {
19         int result=(int)binaryStack.top();
20         binaryStack.pop();
21         cout<<result;
22     }
23     cout<<"\n";
24     return 0;
25 }
另外��Z��看了一下C#和JAVA�Q�当然也支持栈。但是这些东西在我��^时��用的时候却很少用到�Q�或者在用到的时候去“重复发明轮子�?#8221;。作��Z��个经典的数据�c�d��Q�栈理应是被�l�大多数语言支持的（不知道PB怎样�Q�。所以在�q�里要树立一�?#8220;重用轮子”的意识：
C#的十�q�制转二�q�制实现�Q?br>
1 class Class1
2     {
3         ///

4         /// 应用�E�序的主入口炏V�?br> 5         ///

6         [STAThread]
7         static void Main(string[] args)
8         {
9             //
10             // TODO: 在此处添加代码以启动应用�E�序
11             //
12             Stack binaryStack=new Stack();
13             Console.WriteLine("Please input decimal value:");
14             String sDecimal=Console.ReadLine();
15             int decimalValue=Int32.Parse(sDecimal);
16             while(decimalValue!=0)
17             {
18                 binaryStack.Push(decimalValue%2);
19                 decimalValue=decimalValue/2;
20             }
21             Console.WriteLine("The binary result is:");
22             while(binaryStack.Count!=0)
23             {
24                 Console.Write(binaryStack.Pop());
25             }
26             Console.WriteLine();
27         }
28     }

JAVA的十�q�制转二�q�制实现�Q?br>
1 import java.io.BufferedReader;
2 import java.io.InputStreamReader;
3 import java.util.Stack;
4 public class hello1 {
5     public static void main(String args[])
6     {
7         try {
8             Stack<Integer> binaryStack=new Stack<Integer>();
9             int decimalValue;
10             System.out.println("please input decimal value:");
11             BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
12             decimalValue=Integer.parseInt(bufferedReader.readLine());
13             while(decimalValue!=0)
14             {
15                 binaryStack.push(decimalValue%2);
16                 decimalValue=decimalValue/2;
17             }
18             System.out.println("the binary result is:");
19             while(!binaryStack.empty())
20             {
21                 System.out.print(binaryStack.pop());
22
23             }
24         } catch (Exception e) {
25             // TODO Auto-generated catch block
26             e.printStackTrace();
27         }
28
29
30     }
31     }
通过比较�Q�会发现C#不大�?#8220;�?#8221;的感觉，JAVA和C++更脓�q�于《数据结构》中对于数据�c�d��“�?#8221;的操作的定义。另外支持模板或者范型的特点让�h用�v来��M��感觉十分舒服。在�q�里提醒自己�Q�以后这三种语言�?#8220;�?#8221;可用了！

littlegai 2007-06-11 22:11 发表评论

数据�l�构��M��W�记�Q�冒泡排�?不要只注意最坏的情况�Q?

littlegai — Sun, 10 Jun 2007 14:34:00 GMT

数据�l�构�W�一章讨��Z��一些有关算法的问题.在这一部分再次引入了那个经典的��法--冒��排序法�?br>如果让我来描�q�C��下这个算法的�q�程的话�Q�我会这��h��q�ͼ�
从第一个元素开始和依次�q�行比较�Q�大的那个放在后面，一直到最后一个元素。这��h��后一个元素就会成为最大的那个�Q�除刚才产生的最大的那个元素外，再次从头开始比较，一直到�W�一个元素没得可比�ؓ止�?br>�q�是我的理解。进而通过�q�个理解�Q�我可以写出�q�个��法来。这没有问题。但是当我看到原版的��法的时候，我立卛_��感觉出差别来了：

1 void bubble_sort(int a[],int n)
2 {
3      for(i=n-1,change=TRUE;i>1&&change;--i)
4      {
5          change=FALSE;
6          for(j=0;j<i;++j)
7              if(a[j]>a[j+1]{a[j]<-->a[j+1];change=TRUE;}
8      }
9 }
注意变量change。这里体现的思�\是：如果在某一�ơ比较过�E�中没有�U�d��M��元素�Q�那么就没有必要再从头比较一�ơ了。因为实际上已经得到了一个排好序的数�l��?br>�q�样对于相当多的情况来讲�Q�减��了很多的不必要操作�Q�自然��^均时间复杂程度就降低了�?br>因�ؓ我往往只考虑到比较坏甚至极端的情况（比如完全逆序�Q�，所以自然就会忽略这些看上去不太坏，甚至是非常好的情况，�q�样一个直接的�l�果��是让那些好的情况下的操作也变得�J�琐异常�Q�而仅仅是��Z��照顾那些比较难于出现的个别异常情况，现在��x��Q�这样做不可取。日后应当注意�?

littlegai 2007-06-10 22:34 发表评论

The C++ Standard Library : A Tutoral and Reference ��M��W�记�?模板(1)

littlegai — Sat, 09 Jun 2007 15:53:00 GMT
最�q�开始系�l�学习STL.首先扑ֈ��q�本�?-The C++ Standard Library : A Tutoral and Reference然后一边看书一�Ҏ��着里面的例子做�?个�h认�ؓ比较重要的内容将会在�q�里�q�行记录.
与此相关的阅��d��实验�q�程都是在linux下进行的,所以这些读书笔��C��会在linux下完�?�q�里不由得感叹一�?-博客园的博客�pȝ��的通用性确实做得非常好,臛_��我在fire fox下面下��用没有感觉到��M��的差�?
首先是模板Template.

template<class T>
class MyClass
{
private:
T value;
public:
const T getValue()
{
return value;
}
void assign(const MyClass<T> &m)
{
value=m.value;
}

MyClass(T theValue)
{
value=theValue;
}

};

上面的MyClass��是我的模板�c?然后我按照如下的方式�q�行调用,是没有问题的:

MyClass<int> i1(1);
MyClass<int> i2(2);
cout<<"\n";
cout<<i1.getValue()<<"\n";
cout<<i2.getValue()<<"\n";
i1.assign(i2);
cout<<i1.getValue()<<"\n";
exit(0);
但是如果�q�样,��׃��出现问题.

MyClass<int> i1(1);
MyClass<float> f3(3.9);
f3.assign(i1);
�~�译器会告诉�?
TemplateExp.cpp: In function ‘int main()’:
TemplateExp.cpp:36: 错误�Q?�?‘MyClass::assign(MyClass&)’ 的调用没有匹配的函数
TemplateExp.cpp:13: 附注�Q?备选�ؓ�Q?void MyClass::assign(const MyClass&) [with T = float]
因�ؓ在编译器看来
void assign(const MyClass<int> &m)�?br>void assign(const MyClass<float> &m)是不同的.
�q�样��必��assign�q�行修改.我在�q�里建立了一个新的函数assignX,如下:

template <class X>
void assignX(MyClass<X> &m)
{
value=m.getValue();
}
在调用的时�?�q�样写就没有问题�?

MyClass<int> i1(1);
MyClass<float> f3(3.9);
f3.assignX(i1);
cout<<f3.getValue()<<"\n";
exit(0);
有一炚w��要注�?在assignX�?不能够只接��用m.value而要使用m.getValue().正如书中所�?
Note that the argument x of assign() now differs from the type of *this. Thus, you can't
access private and protected members of MyClass<> directly. Instead, you have to use
something like getValue() in this example.
�׃��c�d��不同�?即MyClass不同于MyClass)所以就不能使用this.因而要另外建立一个获取值的函数.
实际上上面写的代码和书中�q�是有所不同�?比较重要的区别是函数assign.
书中的参��Cؓ:
template
assign(const MyClass& x)
�q�样实际上是不能得到x.getValue()�?�~�译器会�l�出�q�样的提�C?
TemplateExp.cpp:36:   instantiated from here
TemplateExp.cpp:20: 错误�Q?passing ‘const MyClass’ as ‘this’ argument of ‘const T MyClass::getValue() [with T = int]’ discards qualifiers
但是修改�?br>template
assign(MyClass& x)
��׃��会有问题�?br>

littlegai 2007-06-09 23:53 发表评论

Domain-Driven Design: Tackling Complexity in the Heart of Software 语句�_�摘.3.

littlegai — Thu, 31 Aug 2006 15:22:00 GMT

Chapter Three. Binding Model and Implementation
If the design, or some central part of it, does not map to the domain model, that model is of little value, and the correctness of the software is suspect. At the same time, complex mappings between models and design functions are difficult to understand and, in practice, impossible to maintain as the design changes. A deadly divide opens between analysis and design so that insight gained in each of those activities does not feed into the other.
        如果一�U�设�?或者它的一些核心�ƈ没有与域模型相关联，那么�q�个模型��没有�h��|��q�且以此而开发出来的软�g的正��性也值得怀疑。同�Ӟ��模型与功能设计之间复杂的对应关系会变得难于理解，�q�且当设计变化的时候，它们��很隄��护。一�U�致命的分歧��此在分析与设计之间出现�Q�以至于那些分析设计�z�d��中所获得的见解不能彼此满��?/span>

Design a portion of the software system to reflect the domain model in a very literal way, so that mapping is obvious. Revisit the model and modify it to be implemented more naturally in software, even as you seek to make it reflect deeper insight into the domain. Demand a single model that serves both purposes well, in addition to supporting a robust UBIQUITOUS LANGUAGE.

Draw from the model the terminology used in the design and the basic assignment of responsibilities. The code becomes an expression of the model, so a change to the code may be a change to the model. Its effect must ripple through the rest of the project's activities accordingly.

To tie the implementation slavishly to a model usually requires software development tools and languages that support a modeling paradigm, such as object-oriented programming.

        以书面的形式设计软�g�pȝ��的一部分�Q�进而与域模型相映射�Q�这样双方的对应关系��会变得明显。重新考虑�q�些模型�q�且通过修改让他们在软�g当中昑־�更加自然�Q�甚��x��当你在寻求一�U�方法，来让模型更加深刻的反映问题域的时候也要如此。追求尽可能��单的模型�Q�让它能够满��_��斚w��目的�Q��Y件方面和设计斚w��Q�）�Q�又能够支持��_��健全的通用语言�?/span>

        从模型中提取那些在存在于设计中，以及存在于（域专家的?�Q�职责所包含的基本工作中的那些术语。代码会因此成�ؓ对于模型的一�U�描�q�ͼ�所以对于代码的更改或许��是源自于对于模型的更改。从而，它们的媄响将会�L及到��目其他部分的行为�?br />        要牢固的把实现和模型�l�定在一��P��通常需要一些��Y件设计工具以及支持模型范例的语言�Q�例如面向对象程序设计�?br />

If the people who write the code do not feel responsible for the model, or don't understand how to make the model work for an application, then the model has nothing to do with the software. If developers don't realize that changing code changes the model, then their refactoring will weaken the model rather than strengthen it. Meanwhile, when a modeler is separated from the implementation process, he or she never acquires, or quickly loses, a feel for the constraints of implementation. The basic constraint of MODEL-DRIVEN DESIGN—that the model supports an effective implementation and abstracts key domain knowledge—is half-gone, and the resulting models will be impractical. Finally, the knowledge and skills of experienced designers won't be transferred to other developers if the division of labor prevents the kind of collaboration that conveys the subtleties of coding a MODEL-DRIVEN DESIGN.
        如果写代码的那些人对于模型没有责��L��的话�Q�或者他们�ƈ不能懂得如何让模型作用于应用�Q�那么模型对于��Y件来讲毫无用处。如果开发�h员不能够认识到对于代码的修改��是对于模型的修改的话，它们的重构将会��模型变得更糟�Q�而不是让它们更加健壮。同�Ӟ��当一个从事徏模的��Z��实现�q�程盔R��ȝ��时候，他（她）永远也不会获得，或者说会很快失��d��于实现的�U�束感。模型驱动设计的基本�U�束��x��--模型需要对那些有效的（�E�序�Q�实现提供支持，�q�且能够抽象关键的域知识--�ȝ��其一�Q�模型都会变得不切实际。最后，如果��目中的分工��L��了能够微妙的改善模型驱动设计代码�~�写的那些协作，那么团队中经验丰富的设计人员的知识和技术将不能�l�的其他设计人员带来提高�?br />

Any technical person contributing to the model must spend some time touching the code, whatever primary role he or she plays on the project. Anyone responsible for changing code must learn to express a model through the code. Every developer must be involved in some level of discussion about the model and have contact with domain experts. Those who contribute in different ways must consciously engage those who touch the code in a dynamic exchange of model ideas through the UBIQUITOUS LANGUAGE.
        ��M��专注于模型的技术�h员必��花旉��接触代码�Q�而不��Z��Q�她�Q�在��目中的首要角色是什么。�Q何负责修改代码的人必��d��会通过代码来描�q�模型。每一个开发�h员必��M��同程度的被纳入到�Ҏ��型的讨论以及和域专家的交��中。那些上�q�工作之外所涉及的项目�h员必��自觉地让那些接触代码的人通过通用语言动态的交换对于模型的意见�?/p>

littlegai 2006-08-31 23:22 发表评论

Domain-Driven Design: Tackling Complexity in the Heart of Software 语句�_�摘.2.

littlegai — Tue, 29 Aug 2006 13:25:00 GMT

Chapter Two. Communication and the Use of Language

A project faces serious problems when its language is fractured. Domain experts use their

jargon while technical team members have their own language tuned for discussing the domain

in terms of design.

The terminology of day-to-day discussions is disconnected from the terminology embedded in

the code (ultimately the most important product of a software project). And even the same

person uses different language in speech and in writing, so that the most incisive

expressions of the domain often emerge in a transient form that is never captured in the

code or even in writing.

Translation blunts communication and makes knowledge crunching anemic.

Yet none of these dialects can be a common language because none serves all needs.

         当用于交��的语言出现断层的时候，��目��会面��一�p�d��严重的问题。域专家们与技术团队自

说自话�?br />        日常讨论所用的术语不再与代码（它们会成��Y仉��目的重要部分�Q�中的术语相联系。甚臛_��

一个�h会在交流中和在记录中所用的术语不相一��_��以至于问题域中那些重要的表达方式出现得如此短

暂进而��它们无法被捕获到代码中去甚至无法被记录下来�?/p>
Use the model as the backbone of a language. Commit the team to exercising that language

relentlessly in all communication within the team and in the code. Use the same language in

diagrams, writing, and especially speech.

Iron out difficulties by experimenting with alternative expressions, which reflect

alternative models. Then refactor the code, renaming classes, methods, and modules to

conform to the new model. Resolve confusion over terms in conversation, in just the way we

come to agree on the meaning of ordinary words.

Recognize that a change in the UBIQUITOUS LANGUAGE is a change to the model.

Domain experts should object to terms or structures that are awkward or inadequate to

convey domain understanding; developers should watch for ambiguity or inconsistency that

will trip up design.
        把模型作为通用语言的核心。推动整个团队在各种各样的交��中以及在编码中严格的实践这�U?/p>
语言。在图表、记录特别是谈话中统一交流方式�?br />        通过选择性的表达方式�Q�即那些对应不同模型的表达方式来消除通用语言中的隄��。然后重�?/p>
代码�Q�重新命名那些类、方法模块，使它们和新的模型�怸�致。我们对那些常用词汇的理解渐渐的达成

一��_��q�以此来解决交谈期间的那些�؜淆�?br />        要知道，对于通用语言的�Q何变化都是对模型的变化�?br />       域专家们应当�U�极反对那些��尬的或者不能充分传辑֟�概念的术语，开发者应当时时留意含义不

明确或者有矛盾的地方，�q�些地方会给设计埋下隐患�?br />Play with the model as you talk about the system. Describe scenarios out loud using the

elements and interactions of the model, combining concepts in ways allowed by the model.

Find easier ways to say what you need to say, and then take those new ideas back down to

the diagrams and code.
        当你谈论�pȝ��的时候，多多使用模型。大声地使用模型所提供的那些元素和交互方式描述情节

�Q�以模型所接受的方式联�l�域中的概念。尽可能��单的表达你所要表辄��东西�Q�然后反�q�头来把�q�些�?/p>
路�{变�ؓ图表和代码�?br />

littlegai 2006-08-29 21:25 发表评论

Domain-Driven Design: Tackling Complexity in the Heart of Software 语句�_�摘.1.

littlegai — Mon, 21 Aug 2006 12:50:00 GMT
Part I: Putting the Domain Model to Work
A domain model is not a particular diagram; it is the idea that the diagram is intended to convey. It is not just the knowledge in a domain expert's head; it is a rigorously organized and selective abstraction of that knowledge. A diagram can represent and communicate a model, as can carefully written code, as can an English sentence.
域模型�ƈ非一�U�特�D�的图，却是�q�种图所要传辄��含义。它�q�不仅是域专家头脑中的知识，它是严格�l�织出来的，�q�且有选择的抽象的知识。一张图�C�可以展��C��及表达一�U�模型，同样的，一�D�仔�l�斟酌的代码可以�Q�一句英文也可以�?br />In domain-driven design, three basic uses determine the choice of a model.
1.The model and the heart of the design shape each other.
2.The model is the backbone of a language used by all team members.
3.The model is distilled knowledge.
在DDD中，三种基本用途决定了模型的选择�?br />1.模型和设计的核心交相辉映�?br />2.模型是所有团队成员交��方式的中心�?br />3.模型是精化后的知识�?img src ="http://m.shnenglu.com/qzb2006e/aggbug/11539.html" width = "1" height = "1" />

littlegai 2006-08-21 20:50 发表评论

中文一区字幕,激情视频亚洲,久久国产精品网站

关于javascript callback

关于HttpApplication

如果sharepoint 不能卸蝲

修复Visual Studio

Nebula Tips (1)

javascript学习

Ready start

Running...

Keep running

Stop!

Direct Show �W�记

重构--改善既有代码的设计读书笔�?�W�四�?1)

重构--改善既有代码的设计读书笔�?�W�三�?6)

重构--改善既有代码的设计读书笔�?�W�三�?5)

The C++ Standard Library : A Tutoral and Reference ��M���W�记之auto_ptr

重构--改善既有代码的设计读书笔�?�W�三�?4)

重构--改善既有代码的设计读书笔�?�W�三�?3)

The C++ Standard Library : A Tutoral and Reference ��M���W�记之错误和异常处理

The C++ Standard Library : A Tutoral and Reference ��M���W�记之命名空�?2)

重构--改善既有代码的设计读书笔�?�W�二�?3)

重构--改善既有代码的设计读书笔�?�W�一�?2)

The C++ Standard Library : A Tutoral and Reference ��M���W�记�?�c�d��转换(1)

重构--改善既有代码的设计读书笔�?�W�一�?1)

数据�l�构��M���W�记�Q�栈�Q�不只是C++的东西）

数据�l�构��M���W�记�Q�冒泡排�?不要只注意最坏的情况�Q?

The C++ Standard Library : A Tutoral and Reference ��M���W�记�?模板(1)

Domain-Driven Design: Tackling Complexity in the Heart of Software 语句�_�摘.3.

Domain-Driven Design: Tackling Complexity in the Heart of Software 语句�_�摘.2.

Domain-Driven Design: Tackling Complexity in the Heart of Software 语句�_�摘.1.

The C++ Standard Library : A Tutoral and Reference ��M��W�记之auto_ptr

The C++ Standard Library : A Tutoral and Reference ��M��W�记之错误和异常处理

The C++ Standard Library : A Tutoral and Reference ��M��W�记之命名空�?2)

The C++ Standard Library : A Tutoral and Reference ��M��W�记�?�c�d��转换(1)

数据�l�构��M��W�记�Q�栈�Q�不只是C++的东西）

数据�l�构��M��W�记�Q�冒泡排�?不要只注意最坏的情况�Q?

The C++ Standard Library : A Tutoral and Reference ��M��W�记�?模板(1)