posts - 58,  comments - 75,  trackbacks - 0
看看今天的奥运概念股和北京概念股的涨势。都是靠前的。今年8月8日才开始的奥运,在股市中现在就开始了。再看看这些股在前期的准备,就可知,开始的时间更早了。今年股市会围绕奥运展开吗?要留意拉。想想在这个大事下,有多少消费会被迸发出来,有哪些概念会让人感兴趣,有什么行业会收益呢,他们会在什么时候会一一表现出来呢?
posted @ 2008-01-02 15:47 walkspeed 阅读(388) | 评论 (0)编辑 收藏
    对于程序开发,解依赖是很重要的。设计时要考虑到程序中有那些依赖关系,如何将他们解开。解依赖并不是说将这些依赖关系打断,不要依赖了。而是接触对实现的依赖。当一个模块的实现变了,它的变化不会对这个模块有依赖的模块产生大的影响,这就是解依赖了。
    解依赖有利于大规模的程序开发。大规模的开发,一个软件被分成了很多的模块,解依赖后,这些模块才可能单独开发,对某模块有深入了解的人才能更关注与这个模块的开发。大家在交流是关注与依赖的交互,而不是实现的细节,有利于在更高层次上讨论问题。
    解依赖有利于程序的修改和升级。
    解依赖有利于模块测试,集成测试。
    解依赖有利于开发库的形成。

    解依赖中有两个总要的概念。模块和接口。模块的规模可大可小。大的模块可以是一个库,甚至是一个软件,小的模块是一个函数,或一个成员。模块的目的是将一个确定的功能包装起来,向外提供一个统一的访问接口。接口是一种声明,表示某个模块有那些能力。

posted @ 2007-12-29 09:50 walkspeed 阅读(1102) | 评论 (3)编辑 收藏
头文件 regex.hpp

常用的类
boost::regex 正则表达式

boost::cmatch 以char数组为容器,存储匹配返回值。
boost::smatch 以std::string为容器,存储匹配返回值。

boost::regex_match 匹配算法
boost::regex_search 查找算法
boost::regex_replace 替换算法

简单例子

#include <iostream>

#include <boost/regex.hpp>

int main( int argc, char* argv[] )
{
    char *buf = "This is boost::regex example";

    boost::regex exampleregex( "boost::regex" );
    boost::cmatch result;

    if( boost::regex_search( buf, result, exampleregex ) )
    {
        std::cout << result.str() << std::endl;
    }

    return 0;
}

注意regex.hpp的包含。要在开发工具中设置boost头文件所在位子。


posted @ 2007-12-28 14:01 walkspeed 阅读(8474) | 评论 (0)编辑 收藏
瑞银事件好像让大家知道了中石油为何表现如此。同时也告诉大家中石油是个好股票,只是
被人操纵了,才变成这样。而问题又回来了,我们该买中石油吗?

我想应该没有什么别的答案吧,买,一定要买。
看看中石化,神化都是什么价格。中石油就不应该实在这个价格。

他垄断。在这个关乎国家、民族根本利益的行业里,在可预期的时间里还是垄断。垄断就有
垄断的利润。

他是能源。石油是工业社会的血液,想一想吧。中国在加速工业化的过程,能少了石油吗。
新能源在现在这个能源消费体系里还是很少以部分(还是可怜的少),作为概念是没有问题
可是从市场的角度,他们还没有到动摇石油的底部。要不然美国不用打伊拉克啦。

他也是资产。每个国家都要储备他,想黄金一样,要储备来稳定市场。

买它,一定要买。

什么时候买。看自己啦。
posted @ 2007-12-28 13:15 walkspeed 阅读(475) | 评论 (0)编辑 收藏
    要在分布式系统中找到一个对象,甚至是对象的某个实例,我们必须给他们一个唯一标识。
    可以领用UUID来生成我们需要的唯一标识。但是在snmp中并没有选着UUID来标识每个对象,而是使用
了自己设计的Oid。这是为何呢?本人认为,UUID虽可以唯一表示对象及其实例,但是UUID之间没有什么
关系,不能形成一种结构来表示对象之间的关系。而Oid的显现却能满足以上两点,唯一表示对象和显示
对象之间的结构,甚至是对象的实例的唯一标识和实例之间的关系。
    这也给我们一个启示,分布式系统中对象的标识除了具有唯一性外,要有一定显示对象之间关系的能
力,会更好。
posted @ 2007-08-31 14:01 walkspeed 阅读(2030) | 评论 (1)编辑 收藏
     摘要: 接口的使用者不应该在使用完接口后直接销毁接口,而应该将接口返还给接口提供者。接口提供者来管理接口的声明周期。  阅读全文
posted @ 2007-08-07 09:49 walkspeed 阅读(1673) | 评论 (1)编辑 收藏
当我们使用函数时习惯于C函数的格式,即如下形式
resulttype funname( arglist );
返回值类型 函数名( 参数列表 );

在Boost.Function中,我们可以方便的定义定义函数对象。不过在定义用来表示类成员函数的函数对象时
第一个参数是类指针。而且在调用时,要传入一个类实例的指针。这样用起来并不是很方便,因为调用者
要知道类实例。这实际上没有实现解耦。而解耦是我们使用回调或委托设计的一个目标。

为了解决这个问题,我们要使用Boost.Bind库

Boost.Bind是一个函数对象工厂。他用来产生我们需要的函数对象。好了,有了它,你可以在你设计中大
量使用Boost.Function。不用再去定义类成员函数形式的函数对象啦,只用定义普通函数对象。

一个简单的例子

class CExample
{
public:
    bool printstr( const std::string &str )
    {
        std::cout << "CExample::printstr" << str << std::endl;
        return true;
    }
};

//定义一个函数对象
boost::function< bool ( const std::string& ) > printstr;

//用Boost.Bind创建一个函数对象,赋给printstr
CExample example;
printstr = boost::bind( &CExample::printstr, &example, _1 );

好了,我们创建了一个函数对象,而且调用时不再需要类实例拉。用Boost.Function和Boost.Bind大大
的简化了Command模式的实现。

在上面的例子中要个古怪的对象"_1"。这个叫做站位符,他代表这个位置有个参数,但现在还不知道参
数是什么。_1代表参数列表中的第一个位置上的参数。Boost.Bind一共定义了9个站位符对象。如下
_1,_2,_3,_4,_5,_6,_7,_8,_9。分别代表参数列表中位子。

Boost.Bind产生的函数对象可以直接使用,利用上面的例子。

bool b = boost::bind( &CExample::printstr, &example, _1 )( "Hello World" );


posted @ 2007-07-20 17:15 walkspeed 阅读(11807) | 评论 (3)编辑 收藏
Boost.Function库用来提供一个对象化的函数指针。

函数指针对设计很有用。它使调用者可以延期调用,调用时机由调用者确定。而且可以改变
响应者,以应对不同的要求。

C中的函数指针只能用于自由函数。在C++中除了自由函数还有函数对象和类成员函数,这些
C的函数指针是无法用的。这要求能适应C++语言的函数指针。既然C++语言本身没有提供,
那就提供一个库。stl提供了,但是定义了很多类型,使用起来并不是很方便,而且函数参数
的个数被限定在两个以下,更能是备受限制。Boost.Function库提供了一个好的解决方案。

Boost.Function库可以支持自由函数,函数对象,类成员函数。而且参数个数多达10个。
Boost.Function库利用模板技术来实现。生成的代码有很高的运行效率。本库可以不用编译
直接使用。

Boost.Function的头文件。
function.hpp

定义一个Boost.Function的对象(是一个返回值类型为int,第一个参数是std::string类型
第二个参数是float类新)

boost::function< int ( std::string, float ) > funptr;

上面这个定义方式是一种容易理解的定义方式。但有些编译器不支持,如果想更多的编译器
支持,则用下面这种定义方式

boost::function2< int, std::string, float > funptr;

注意模板中有3个类型,而function类却是boost::function2。应为返回值类型不计算在参数
类型中(原因很简单,C++的编译器不会根据返回类型不同来区分函数定义的不同)。

int freefun( std::string str, float f )
{
    std::cout << str << " : " << f << std::endl;
    return 0;
}

class CFun
{
public:
    int operator() ( std::string str, float f )
    {
        std::cout << str << " : " << f << std::endl;
        return 0; 
    }
}

上面定义了一个自由函数和一个函数对象。下面将把他们付给function对象。

赋值为自由函数
funptr = &freefun;

赋值为函数对象
CFun fun;
funptr = fun;

以上两种情况的调用方法一致,如下
funptr( "float =", 10.0 );

Boost.Function对象要能指向类型原函数,其定义要如下

class FreeClass
{
public:
    int out( std::string str, float f )
    {
        std::cout << str << " : " << f << std::endl;
        return 0; 
    }
};

boost::function< int ( FreeClass*, std::string, float ) > funptr;

跨平台的定义方法
boost::function3< int, FreeClass*, std::string, float > funptr;

赋值方法
funptr = &FreeClass::out;

调用方法
FreeClass fc;

funptr( &fc, "float =", 10.0 );


posted @ 2007-07-18 13:28 walkspeed 阅读(9621) | 评论 (2)编辑 收藏
领域分析--认识领域分析

软件分析的开端一般是需求分析。但是在实践中,发现了很多的问题。
1 用户的需求并不是有用户提出。在和用户或软件的风险承担者交谈后,会常发现,他们对自己想要的
软件并不是很清楚,会提出一些笼统的要求。在开发出一个原型后,他们会修正或更改,甚至推翻他们
的需求。你会发现是你在不断的提出、完善需求,用户或风险承担者只是在裁决你的需求。而这样下去
你的软件要不断的改,好像遥遥无期。
2 需求多是一种功能的集合。软件出来后,如果有了改动,或在新的项目中去复用以前的软件会发现很
难。对每个需求,你不得不从头开始。

领域分析和需求分析不同,它不是面向功能的。而是面向问题的。这有些像考试中解题。针对特定的问
题,来提供解决方案,并在这个方案的直接指导下解出题目。这个直接指导很有意义,应为直接指导表
示解题的方案将被应用到解题的过程中(即是可实现的)。

领域分析不是对要构造的软件进行全面的分析。而是对软件涉及到的特定的领域进行分析(如写多媒体
软件,你要对音视频领域进行分析)。而领域是与特定的知识相关联的(如音视频领域中关于音频、视
频编解码知识,领域分析要搞清楚这个领域中的知识,找出各知识点中的关系,并对它们进行抽象,形
成模型。领域分析强调的是问题域。这就是说它面对的是一个相对确定的范围。软件要解决的是一个相
对确定的范围。也有利于测试软件。

领域分析不能代替需求分析,但是可以脱离需求来对特定的领域进行分析。领域分析后产生的设计要直
接指导实现,可以映射到软件中。由于领域分析是面对问题的,它产生的软件不一定能满足需求,可能
根本就对应不上需求。但是它是特定问题的解决方案,可以作为一个机制来支持需求的实现。而且特定
的问题或着说这种反应某个领域中的知识关系的软件其对应的是一种稳定的需求,比较容易复用、测试
和发展。

面对需求分析得到是一种应用的要求。而根据软件涉及的领域进行分析,得到的是它的基本机制。应用
是多样的,而机制其实就只有那么几个。根据应用的要求来组合这些机制。这样需求的变化,并不会去
过多的冲击你通过领域分析得到的模型和实现。你要做的是对他们进行组合。
posted @ 2007-07-11 15:54 walkspeed 阅读(2113) | 评论 (3)编辑 收藏
    new出来的空间如果没有主动销毁,在程序退出时仍可能有内存的泄露。
操作系统描述到,在进程退出时会销毁它所使用的所有内存空间,但这只是
一个模型上的构想和描述。在实际的操作系统的实现上并不能做到这一点。
因为,要实现在进程退出时销毁它所使用的内存空间,就要给每个被使用的
内存空间打一个标,表示这段内存空间被那个进程使用。在这种情况下,如
果有多个使用小内存量的进程,并且被频繁的创建和销毁,那么光记住那些
进程标致就要占用很大的内存空间,这是一个很不划算的方案。所以在实际
中,操作系统并没有给每个进程使用的内存空间打标。这样,有些小内存是
没有被回收的,如果多次开关这个程序就会发现,有内存被大量的占用,而
不能被释放。
    所以那些在程序中只有一个实例,并且是被new出来的对象,也应该主动
的去手动销毁,而不能依赖程序退出时由系统销毁。

    被new出来的对象其销毁是两个步骤。
    1 析构对象。条用对象的析构函数,将对象占用的资源释放掉。
    2 释放内存。将对象所占用的内存释放掉。
    
    如果new出来的对象没有被销毁,会造成连个层面上的泄露。
    1 对象泄露。他会造成背对象占用的资源也没有销毁或释放。比如在对象
中占有文件的句柄,在析构时才释放。如果对象泄露了,这个句柄是不会被释
放的。那个文件会一直被占用。如果文件打开时是独占的,那么及时对象所在
的程序退出了,别的程序也别想访问这个文件。
    2 内存泄露。所占用的内存不能被释放。

posted @ 2007-05-31 10:50 walkspeed 阅读(2431) | 评论 (5)编辑 收藏
仅列出标题  下一页

<2018年10月>
30123456
78910111213
14151617181920
21222324252627
28293031123
45678910

常用链接

留言簿(4)

随笔分类(64)

随笔档案(58)

文章分类(3)

文章档案(3)

相册

收藏夹(9)

C++零碎

好友

搜索

  •  

积分与排名

  • 积分 - 140327
  • 排名 - 152

最新评论

阅读排行榜

评论排行榜