久久国产精品国产自线拍免费,久久笫一福利免费导航 ,亚洲国产精品久久久久网站

老狼 — Tue, 24 Aug 2010 16:59:00 GMT

之前介绍�q�简单工厂模式、工厂模式，�q�节介绍下工厂家族的最后一�U�设计模�?-抽象工厂设计模式�?

实际上，如果对前两种模式熟练掌握的话�Q�这个相�Ҏ(gu��)��说最复杂的设计模式也不难理解�Q�它也可以理解�ؓ是在工厂模式基础上的升��?/div>

我们知道�Q�工厂模式将一个类的实例化延迟到子�c�，具体产品�cȝ��具体工厂�c�L��实例化，但这�U�关�p�d��本是一对一的，也就是说一个抽象工厂类对应一个抽象��品类�Q�多个具体工厂类对应多个具体产品�c�R��归�U�x��说就是一个工厂族只服务于一个��品族�?/div>

抽象工厂模式实现了工厂类与��品类一对多的关�p�，或者说工厂族与产品族实��C��一对多的关�p�R��它们的区别可以用一家工厂来形容�Q�工厂模式就像是�q�家工厂的一条生产线�Q�而抽象工厂模式就好比整个工厂的所有生产线�?/div>

老狼 2010-08-25 00:59 发表评论

老狼 — Tue, 24 Aug 2010 16:37:00 GMT

概念
代理�q�个词对我们来说非常熟�?zh��n)��Q�比如上�|�经�怋�用的代理服务器，�q�有销售代理商�{�。就是客户与目标之间的桥梁�?br>设计模式中的代理模式�Q�Proxy�Q�是�q�样定义的：为其他对象提供一�U�代理以控制对这个对象的讉K��?br>若要为其他对象提供代理服务，那么首先本��n也要��h��与被代理对象同样的方法，那么�q�样在访问时才能真正起到�Q�透明�Q�代理的作用�?br>所以代理类一般同被代理类是��承于同一个类的兄弟类�Q�区别就是他是�ؓ别�h服务的�?br>
�q�样说来�Q�表面看代理很风光，啥都得通过他，好像没他不行似的�Q�其实他��是个跑堂的�Q?/p>

�l�成部分
1.抽象主题�Q�基�c�，声明了代理对象和真实对象的共同点�Q?br>2.真实主题�Q�真正需要被调用的对象；
3.代理对象�Q�代理真实对象的对象�?/p>

分类
1.�q�程代理�Q�也��是��Z��个对象在不同的地址�I�间提供局部代表，�q�样可以隐藏一个对象存在于不同地址�I�间的事实。这个不同的地址�I�间可以是在本机器上�Q�也可以在另一台机器中�?br>2.虚拟代理�Q�是�Ҏ(gu��)��需要创建开销很大的对象，通过它来存放实例化需要很长时间的真实对象�Q��其只有在真正需要时才被创徏�?br>3.安全代理�Q�也叫保护代理，用来控制真实对象讉K��时的权限�Q�如果有必要的话�Q�可以给不同调用者提供不同的权限�?br>4.��指引�Q�是指当调用真实对象�Ӟ��代理处理另外一些事�Q�比如记录对此对象的调用�ơ数�{��?br>5.写时拯��Q�虚拟代理的一�U�，把复制推�q�到只有客户的需要时才进行�?br>6.�~�存代理�Q��ؓ某一个目标的操作�l�果提供临时存储�I�间�Q�以便其他客��L(f��ng)��可以�׃�n讉K��Q�有点缓存的味道�?br>7.防火墙代理：保护对象�Q�不让用戯��问，安全代理的特例�?br>8.同步代理�Q�可以让几个用户同时讉K��同一个对象而不产生冲突�?br>常用的是前四�U�代理方式�?/p>

UML�c�d��

实例代码
1�Q�Proxy.h

1#ifndef _PROXY_H
2#define _PROXY_H
3
4///@brief Abstract Base Class.
5class Subject
6{
7public:
8    Subject() {}
9    virtual ~Subject() {}
10    virtual void request() = 0;
11};
12
13///@brief Real entity class.
14class RealSubject: public Subject
15{
16public:
17    RealSubject();
18    virtual ~RealSubject();
19    virtual void request();
20};
21
22///@brief Proxy class, including a pointer of pointing to the Real-entity class.
23class Proxy: public Subject
24{
25public:
26    Proxy();
27    virtual ~Proxy();
28    virtual void request();
29
30private:
31    RealSubject* m_realSubject;
32};
33
34#endif

2�Q�Proxy.cpp

1#include "Proxy.h"
2#include <iostream>
3
4using namespace std;
5
6RealSubject::RealSubject()
7{
8    cout << "RealSubject constructor" << endl;
9}
10
11RealSubject::~RealSubject()
12{
13    cout << "RealSubject destructor" << endl;
14}
15
16///@brief Real-entity's request method.
17void RealSubject::request()
18{
19    cout << "RealSubject request" << endl;
20}
21
22Proxy::Proxy(): m_realSubject(NULL)
23{
24    cout << "Proxy constructor" << endl;
25}
26
27Proxy::~Proxy()
28{
29    cout << "Proxy destructor" << endl;
30    delete m_realSubject;
31    m_realSubject = NULL;
32}
33
34///@brief Proxy's request method.
35void Proxy::request()
36{
37    cout << "Proxy request" << endl;
38
39    ///@brief Construct it when necessary.
40    if (!m_realSubject) {
41        m_realSubject = new RealSubject();
42    }
43
44    m_realSubject->request();
45}

3�Q�Main.cpp

1#include "Proxy.h"
2#include <iostream>
3
4using namespace std;
5
6int main()
7{
8    Subject* proxy = new Proxy();
9    proxy->request();
10
11    delete proxy;
12    proxy = NULL;
13
14    return 0;
15}

老狼 2010-08-25 00:37 发表评论

老狼 — Mon, 09 Aug 2010 16:30:00 GMT

前面已经介绍�q�简单工厂模式，�q�提及虽然简单工厂模式有很多优点�Q�但其破坏了开�?��闭原则�Q�Open-Close Principle�Q�对扩展开发，对修改关闭）。即每增加一�U�算法，都要对工厂类�q�行修改�?br>在这里将��单工厂模式稍作改�q�，既成了工厂方法模式�?br>定义一个用于创建对象的接口�Q�让子类军_��实例化哪一个类�Q�工厂方法��得一个类的实例化延迟到其子类�?/p> UML�c�d��Q?br>

老狼 2010-08-10 00:30 发表评论

老狼 — Mon, 09 Aug 2010 13:34:00 GMT

��单工厂模式又被称为静态工厂模式。简单工厂模式是�׃��个工厂对象决定创建出哪一�U��品类的实例。简单工厂模式是工厂模式家族中最��单实用的模式�Q�可以理解�ؓ是不同工厂模式的一个特�D�实现�?/p>
UML�c�d��Q?br>
�c�d��中只列出主要�Ҏ(gu��)��Q�而只有工厂类中给��Z��构造和析构函数�Q��ƈ且都是私有。目的是��q�个工厂�cȝ��作用只是“��Z��?#8221;�Q�自�׃��需要实例化�Q�所以将构造和析构声明为私有（�q�个只适用�?#8220;��?#8221;工厂模式�Q��?br>代码�Q��ؓ减小��幅�Q�代码只实现部分�Q��ƈcode��C��个cpp文�g中）�Q?br>

1#include <iostream>
2
3using namespace std;
4
5/// @brief Base operation class.
6class Operation
7{
8protected:
9    double m_numA;
10    double m_numB;
11
12public:
13    Operation(): m_numA(0.0), m_numB(0.0) {
14        cout << "Operation constructor" << endl;
15    }
16
17    virtual ~Operation() {
18        cout << "Operation destructor" << endl;
19    }
20
21    double virtual getResult() = 0;
22};
23
24/// @brief The class implement the add operation.
25class OperAdd: public Operation
26{
27public:
28    OperAdd(double a, double b) {
29        cout << "OperAdd constructor" << endl;
30        m_numA = a;
31        m_numB = b;
32    }
33
34    ~OperAdd() {
35        cout << "OperAdd destructor" << endl;
36    }
37
38    double getResult() {
39        return (m_numA + m_numB);
40    }
41};
42
43/// @brief The class OperSub, OperMul and OperDiv omitted.
44
45class OperFactory
46{
47public:
48    enum OPER_TYPE {
49        ADD = 1,
50        SUB = 2,
51        MUL = 3,
52        DIV = 4
53    };
54
55    static Operation* createOperation(OPER_TYPE oper, double a, double b);
56};
57
58Operation* OperFactory::createOperation(OPER_TYPE oper, double a, double b)
59{
60    Operation* pOper = NULL;
61
62    switch (oper) {
63    case ADD:
64        pOper = new OperAdd(a, b);
65        break;
66    default:
67        break;
68    }
69
70    return pOper;
71}
72
73int main()
74{
75    Operation* pOper = OperFactory::createOperation(OperFactory::ADD, 2.1, 3.3);
76
77    if (pOper) {
78        cout << pOper->getResult() << endl;
79
80        delete pOper;
81        pOper = NULL;
82    }
83
84    return 0;
85}

��单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断�Q�根据客��L(f��ng)��的选择条�g动态实例化相关的类�Q�对于客��L(f��ng)��来说�Q�去除了与具体��品的依赖。但��单工厂模式的工厂�c�L��开攄��Q�如果要增加其它产品�Q�则要修改工厂类�Q�这一点违背开�?��闭原则�Q�Open-Close Principle�Q�对扩展开发，对修改关闭）。而要克服�q�一�~�点�Q�则要��用工厂方法模式（Factory Method�Q�，�q�种�l�过改进工厂模式��在下一节介�l��?

老狼 2010-08-09 21:34 发表评论

老狼 — Mon, 09 Aug 2010 10:09:00 GMT

摘要: 模板�Ҏ(gu��)��模式是一�U�很��单但却很常见的设计模式，它常常在不知不觉中被使用。概念：定义一个操作中的算法的骨架�Q�而将具体的执行步骤�g�q�到子类中。模板方法��得子�c�d��以不改变��法的结构而只是重新定义算法的步骤�Q��得不同步骤��生不同的效果。说的更��单点�Q�就是执行的框架由基�c�L��定，而框架中的方法及执行��序由子�c�L��重定义。UML�c�d��Q?nbsp;上图的代码很好实玎ͼ��是基类的模板函��C��调用了operation1�?.. 阅读全文

老狼 2010-08-09 18:09 发表评论

老狼 — Mon, 19 Jul 2010 15:39:00 GMT

摘要: 所谓的单�g�c�d��是保证一个类仅有一个实例，�q�提供一个访问它的全局讉K��炏V�?nbsp; Singleton可以看作是一�U�经�q�改�q�的全局变量�Q�既在一个进�E�中只能有唯一的实例，不允��生第二个�q�样的对象�?虽然单�g�c�L��最��单的设计模式�Q�但仍需��心使用�Q�主要需注意�Q?1.构造函�?既然是只能有一个实例，那么构造函数自然不能被外部随意调用�Q�所以需要将其声明�ؓ�U�有�Q�private�Q�，包括默认构造、拷... 阅读全文

老狼 2010-07-19 23:39 发表评论

C和C++之间库的互相调用

老狼 — Wed, 25 Mar 2009 06:34:00 GMT

昨晚有个朋友问我关于在C中调用C++库的问题�Q�今天午饭后�Q�由于脖子痛的厉完��没有加入到我们�l�的“每天一�?#8221;的行列中去，所以正好将C和C++之间的库调用关系做个�ȝ��?/p>

1.extern "C"的理解：
很多��?C"表示的C语言�Q�实际�ƈ非如此，"C"表示的是一�U�链接约定，只是因C和C++语言之间的密切关�p�而在它们之间更多的应用而已。实际上Fortran和汇�~�语�a�也常�怋�用，因�ؓ它们也正好符合C实现的约定�?br>extern "C"指��o描述的是一�U�链接约定，它�ƈ不媄响调用函数的定义�Q�即时做了该声明�Q�对函数�c�d��的检查和参数转换仍要遵��@C++的标准，而不是C�?/p>

2.extern "C"的作用：
不同的语�a�链接性是不同的，那么也决定了它们�~�译后的链接�W�号的不同，比如一个函数void fun(double d)�Q�C语言会把它编译成�c�M��_fun�q�样的符��P��C链接器只要找到该函数�W�号��可以链接成功，它假讑֏�数类型信息是正确的。而C++会把�q�个函数�~�译成类似_fun_double或_xxx_funDxxx�q�样的符��P��在符号上增加了类型信息，�q�也是C++可以实现重蝲的原因�?br>那么�Q�对于用C�~�译器编译成的库�Q�用C++直接链接势必会出��C��能识别符��L(f��ng)��问题�Q�是的，需要extern "C"的时��L��了，它就是干�q�个用的。extern "C" 的作用就是让�~�译器知道要以C语言的方式编译和�q�接��装函数�?/p>

3.在C++中调用C库的例子�Q?br>1).做一个C动态库�Q?br>

// hello.c:

#include <stdio.h>

void hello()
{
printf("hello\n");
}

�~�译�q�copy到系�l�库目录�?也可以自己定义库目录�Q�man ldconfig):
[root@coredump test]# gcc --shared -o libhello.so hello.c
[root@coredump test]# cp libhello.so /lib/
2).写个C++�E�序去调用它�Q?br>

// test.cpp

#include <iostream>

#ifdef __cplusplus
extern "C" {               // 告诉�~�译器下列代码要以C链接�U�定的模式进行链�?/span>
#endif

void hello();

#ifdef __cplusplus
}
#endif

int main()
{
  hello();

  return 0;
}

�~�译�q�运行：
[root@coredump test]# g++ test.cpp -o test -lhello
[root@coredump test]# ./test
hello
[root@coredump test]#
3).__cplusplus宏的条�g�~�译�Q?br>��Z��么要加这个条件编译呢�Q�小沈阳有话�Q�小妹，�q�是��Z��么呢�Q?br>因�ؓ�q�种技术也可能会用在由C头文件��生出的C++文�g中，�q�样使用是�ؓ了徏立�v公共的C和C++文�g�Q�也��是保证当这个文件被用做C文�g�~�译�Ӟ��可以��L��C++�l�构�Q�也��是��_��extern "C"语法在C�~�译环境下是不允许的�?br>比如�Q�将上面的test.cpp更名为test.c�Q�将头文件改为stdio.h�Q�将条�g�~�译��L��Q�再用gcc�~�译��可以看到效果。而即使做了上面的修改�Q�如果用g++�~�译��可以正�怋�用，�q�就是我上面说的“公共的C和C++文�g”的意思�?/p>

4.C调用C++库：
C++调用C库看上去也不是那么困难，因�ؓC++本��n��有向前(向C)兼容的特性，再加上纯天然的extern "C"�U�定�Q��得一切都是那么自然。而让C调用C++的库��g��没那么�Ҏ(gu��)��Q�不�q�也不是不可以的�?br>说到�q�里我得休息一下，大中午的�Q�出��L��根烟先，不过我也�怿�如果你不知道�{�案�Q�看到这里的时候肯定在到处找板砖，恨不得敲开我的脑壳子。我能理解，我也�?f��n)惯了，我有个学姐一看到我第一反应��是扔出一块砖头先�Q?br>�a�归正传，�q�是要借助�q�纯天然的extern "C"�?/p>

1)做一个C++库：

// world.cpp

#include <iostream>

void world()
{
std::cout << "world" << std::endl;
}

�~�译�q�copy到系�l�库目录�?
[root@coredump test]# g++ --shared -o libworld.so world.cpp
[root@coredump test]# cp libworld.so /lib/
2)做一个中间接口库�Q�对C++库进行二�ơ封装：

// mid.cpp

#include <iostream>

void world();

#ifdef __cplusplus
extern "C" {  // 即�ɘq�是一个C++�E�序�Q�下列这个函数的实现也要以C�U�定的风格来搞！
#endif

  void m_world()
  {
    world();
  }

#ifdef __cplusplus
}
#endif

其中�Ҏ(gu��)��m_world即�ؓlibworld库中world�Ҏ(gu��)��的二�ơ封装，�~�译�q�copy到系�l�库目录�?
[root@coredump test]# g++ --shared -o libmid.so mid.cpp -lworld
[root@coredump test]# cp libmid.so /lib/
3).C�E�序通过链接二次接口库去调用C++库：

// test.c

#include <stdio.h>

int main()
{
m_world();

return 0;
}

�~�译�q�运行：
[root@coredump test]# gcc test.c -l mid -o test
[root@coredump test]# ./test
world
[root@coredump test]#
注：如果对于C++库中含有�cȝ��Q�可以在二次接口函数中生成��(f��)时对象来调用对应的功能函敎ͼ�当然要根据实际情冉|��定了�?/p>

5.靠，�q�了午休旉��了，收工�Q?/p>

老狼 2009-03-25 14:34 发表评论

linux中的动态库和静态库

老狼 — Wed, 25 Feb 2009 15:10:00 GMT

1.概念和区别：
静态库��是在编译过�E�中一些目标文件的集合。静态库在程序链接的时候��用，链接器会��程序中使用到函数的代码从库文�g中拷贝到应用�E�序中。一旦链接完成，在执行程序的时候就不需要静态库了�?
�׃��每个使用静态库的应用程序都需要拷贝所用函数的代码�Q�所以静态链接的文�g会比较大�?/p>

相对于静态函数库�Q�动态函数库在编译的时候�ƈ没有被编译进目标代码中，而只是作些标记。然后在�E�序开始启动运行的时候，动态地加蝲所需模块�Q�因此动态函数库所产生的可执行文�g比较?y��u)��。由于函数库没有被整合进你的�E�序�Q�而是�E�序�q�行时动态的甌��q�调用，所以程序的�q�行环境中必��L��供相应的库。动态函数库的改变�ƈ不媄响你的程序，所以动态函数库的升�U�比较方�ѝ�?/p>

2.命名�Q?br> 静态库的名字一般�ؓlibxxxx.a�Q�其中xxxx是该lib的名�U��?br> 动态库的名字一般�ؓlibxxxx.so.major.minor�Q�xxxx是该lib的名�U�ͼ�major是主版本��P��minor是副版本受��版本号也可以没有，一般都会徏立个没有版本��L(f��ng)��软连接文仉��接到全名的库文�g�?/p>

3.创徏�Q?br>无论静态库�q�是动态库�Q�创建都分�ؓ两步�Q�第一步创建目标文�Ӟ��W�二步生产库�?br>1).静态库的创建：
#gcc -c test.c -o test.o
#ar rcs libtest.a test.o
名字为libtest.a的静态库��q��产了�Q�其中选项�Q?br>r 表明��模块加入到静态库中；
c 表示创徏静态库�Q?br>s 表示生��索引�Q?br>�q�有更多选项像增加、删除库中的目标文�g�Q�包括将静态库解包�{�可以通过man来获得�?br>2).动态库的创建：
#gcc -fPIC -c test.c -o test.c
#gcc --share test.o -o libtest.so
-fPIC ��Z��跨��^�?/p>

4.使用�Q?br>�~�译链接目标�E�序的方法是一��L(f��ng)��Q?br>#gcc main.c -L. -ltest -o main
-L.指定现在本目录下搜烦库，如果没有�Q�会到系�l�默认的目录下搜索，一般�ؓ/lib�?usr/lib下�?br>对于静态库�Q�这个步骤之后就可以��libtest.a库删掉，因�ؓ它已�l�被�~�译�q�了目标�E�序�Q�不再需要它了�?br>而对于动态库�Q�libtest.so库只是在目标�E�序里做了标讎ͼ�在运行程序时才会动态加载，那么从哪加蝲呢？加蝲目录会由/etc/ld.so.conf来指定，一般默认是/lib�?usr/lib�Q�所以要惌��动态库��利加蝲�Q�你可以��库文�gcopy��C��面的两个目录下，或者设�|�export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/XXX/YYY�Q�后面�ؓ你自己动态库的目录，再或者修�?etc/ld.so.conf文�g�Q�把库所在的路径加到文�g末尾�Q��ƈ执行ldconfig��h��。这��P��加入的目录下的所有库文�g都可见�?/p>

另外�q�有个文仉��要了�?etc/ld.so.cache�Q�里面保存了常用的动态函数库�Q�且会先把他们加载到内存中，因�ؓ内存的访问速度�q�远大于��盘的访问速度�Q�这样可以提高��Y件加载动态函数库的速度了�?/p>

最后提一点，当同一目录下既有动态库又有静态库�Q��ƈ且两个库的名字相同时�Q�编译时会如何链接呢�Q?/p>

gcc�~�译旉��认都是动态链接，如果要指定优先链接静态库�Q�需要指定参数static�?/p>

老狼 2009-02-25 23:10 发表评论

老狼 — Mon, 12 Jan 2009 15:22:00 GMT

在C++中，除了支持C语言中的隐式�c�d��转换外，同时引入了四�U�显�C�的�c�d��转换函数�Q�以��切的标识出正在�q�行的�{换类型�?br>函数原型为（均�ؓ模板函数�Q�：
static_cast(expression)
const_cast(expression)
reinterpret_cast(expression)
dynamic_cast(expression)

前三个是在编译时期进行类型�{换的�Q�而最后一个则是在�q�行时期�q�行转换的，即dynamic_cast函数需要RTTI的支持，如果是VC下，需要手动打开RTTI支持选项�?/p>

static_cast主要完成相关�c�d��之间的�{换，比如整型到枚举、整型到��点�{�。但static_cast不能转换掉expression的const、volitale、或者__unaligned属�?/p>

const_cast一般用于强制消除对象的帔R��性，它是唯一能做到这一点的 C++ 风格的强制�{型，但需注意的是只能转换指针或引用类型，而不能�{换普通常量类型�?br>如：
const int a = 1;
int b = const_cast (a);
是错误的�?/p>

reinterpret_cast用于字节数相同的�c�d��之间的�{换，常用的就是整型和指针之间、函数指针类型之间进行�{换。操作符仅仅重新解释了对象的比特模型而没有进行二�q�制转换�Q�需谨慎使用�Q�一般只在把�c�d��映射回原有类型时使用�?/p>

dynamic_cast主要用于�c�d��ơ间的上行�{换和下行转换�Q�还可以用于�c�M��间的交叉转换�?br>在类层次间进行上行�{换时�Q�dynamic_cast和static_cast的效果是一��L(f��ng)��Q?br>在进行下行�{换时�Q�dynamic_cast��h��c�d��查的功能�Q�比static_cast更安全�?br>你能用dynamic_cast把指向基�cȝ��指针或引用�{换成指向其派生类或其兄弟�cȝ��指针或引用，而且你能知道转换是否成功。失败的转换��返回空指针�Q�当�Ҏ(gu��)��针进行类型�{换时�Q�或者抛出异常（当对引用�q�行�c�d��转换�Ӟ��?br>

老狼 2009-01-12 23:22 发表评论

老狼 — Thu, 25 Dec 2008 16:03:00 GMT

erase()函数的功能是用来删除容器中的元素

函数原型:
iterator erase(iterator where);
iterator erase(iterator first,iterator last);
basic_string& erase(size_type p0=0,size_type n=np);

删除某个容器里的某个元素�Q�c.erase(T);
看似一个简单的动作�Q�然而对不同�c�d��的容器，内部却做了截然不同的事情�Q�后面介�l��?/p>

假设有这样一个题目，��某个容器中所有满��x��件N == X的元素删除，按照常规的思�\应该有类��D��L(f��ng)��代码�Q?br>

// 假设Container和container分别表示一�U�容器和对应的一个对�?/span>
Container<T>::iterator it;
for (it = container.begin(); it != container.end(); ++it) {
if (N == X)
container.erase(it);
}

然而这��L(f��ng)��代码对于��M��U�容器都是错误的
容器按内存分配方式可以分为链表容器和数组容器�?br>所谓的链表容器指的是一�U�表现方式，包括list、slist�{�这样基于节点的容器�Q�动态分配内存块�Q�和set、map、multiset、multimap�{�关联容器（�q��?w��i)实玎ͼ��Q�而数�l�容器指的是在一块连�l�的内存上保存元素的�q�箋内存容器�Q�比如vector、deque、string�{��?/p>

OK�Q�现在说说erase对他们的操作�Q�链表容器以list��Z��Q�当执行container.erase(it)�Ӟ��实�W�一个满��x��件的元素删除了，但这时it指针已经被删除了�Q�它也不指向��M��元素了，所以也只能到此为止了，也就是说上面的代码对于链表容器来说只能正��删除第一个满��x��件的元素�Q�针对这个问题我们首先想到的��是在删除指针之前，�l�其做个备䆾�Q�很好，不错的主意，我们一般采用的�Ҏ(gu��)��是徏立个临时变量�Q�这个��(f��)时变量可以在�E�序循环中适当的位�|��用，看下列代码实玎ͼ�是将�q�个临时变量直接建立在erase实现里，�q�样做更��z�，也显得专业些�Q�以删除int型链表中所有偶��Cؓ例，也是大家都喜�Ƣ的一个例子）�Q?br>

  list<int>::iterator it;
  for (it = lt.begin(); it != lt.end(); ) {
    if (*it % 2 == 0)
      lt.erase(it++);
    else
      ++it;
  }

链表容器使用erase删除节点�q�有一个特点，��是会将下一个元素的地址�q�回�Q�所以也可以�q�样实现�Q?/p>

  list<int>::iterator it;
  for (it = lt.begin(); it != lt.end(); ) {
    if (*it % 2 == 0)
      it = lt.erase(it);
    else
      ++it;
  }

当然用list容器本��n提供的算法也是个不错的主意（挂回调）�Q?/p>

  bool evenNumber(int n)
  {
    return (n % 2 == 0);
  }



  lt.remove_if(evenNumber);

数组容器以vector��Z��Q�当执行container.erase(it)�Ӟ��和上面提到的一��P��W�一个满��x��件的元素删除了，但这时数�l�容器不允许中间�?#8220;�I�隙”�Q�所以会做个大动作，��是��被删元素后面所有的元素前移�Q�参考STL源码�Q�，而数�l�容器记录的是下标，所以删除元素后�Q�当前下标定位的元素也就��理成章的变成了原有队列中的下一个元素，同样以删除偶��Cؓ例，代码如下�Q?/p>

  vector<int>::iterator it = v.begin();
  for (it = v.begin(); it != v.end(); ) {
    if (*it % 2 == 0)
      v.erase(it);
    else
      ++it;
  }

也可以��用reverse_iterator�q�代器，�q�且在某些删除操作中会有更好的效率（因�ؓ它会使上面提到的“大动�?#8221;变小一些）�Q?/p>

  vector<int>::reverse_iterator ri = v.rbegin();
  for ( ; ri != v.rend(); ) {
    if (*ri % 2 == 0)
      v.erase((++ri).base());
    else
      ++ri;
  }

老狼 2008-12-26 00:03 发表评论

老狼 — Sun, 07 Dec 2008 13:14:00 GMT

C++中几�?/font>所有的�c�都�?/font>拯��构造函敎ͼ�析构函数和赋值操作符重蝲函数�Q�即使你不显�C�定义，�~�译器也会自动生成的�Q?/font>它们提供的都是一些最基本的功�?/font>�?/font>

拯��构造函�?/font>�Q?/font>一�U�特�D�的构造函敎ͼ�他由�~�译器调用来完成一些基于同一�cȝ��其他对象的构件及初始化；

析构函数�Q?/font>摧毁一个对象�ƈ保证它被��d��清除�Q?/font>

赋值操作符�Q�以已有对象��?/font>�l?/font>另一对象�q�行新的�?/font>倹{�?/font>

所谓的大三律（rule of three, the law of the big three or the big three�Q�正是在规则他们之间的关�p�：

1.如果�c�d��义了析构函数�Q�那么也应该定义拯��构造和赋��D��符�Q?/font>

2.如果�c�d��有需要动态分配的成员�Q�那么该�c�d��d��义拷贝构造和赋��D��符�Q?/font>

一句话�Q�析构函数、拷贝构造、赋��D��符重蝲应该��L��同时出现。下面一个简单的例子�E�序对这个定律做了论证：

1#include <iostream>
2
3using namespace std;
4
5class Test
6{
7  public:
8    Test()
9    {
10      _pdata = new char[100];
11    };
12
13    ~Test()
14    {
15      delete [] _pdata;
16    };
17
18  private:
19    char* _pdata;
20};
21
22
23int main()
24{
25  Test a;
26  Test b;
27
28  b = a;
29
30  return 0;
31}
32

上面�q�么一�D늮�单的代码看似没什么问题，然而却隐藏着严重的内存泄霌Ӏ?br>�?5行定义了一个类的对象，同时对象a中的数据成员_pdata也在堆中分配了内存，同理26行对对象b做了同样的事情，然�?8行处��a赋值给b�Q�默认赋��D��符做的是对数据成员逐个的赋��|��或者说是做了浅拯��Q�所以对象b中的成员_pdata指向了跟对象a中的_pdata的同一块内存，在析构的时候就会��生a中的_pdata指向的那块内存被释放了两�ơ，而原先对象b中分配的内存却没有释攄��问题�?br>如果��?6�?8行换成Test b = a或Test b(a)�Q�结果是一��L(f��ng)��Q�不同的是调用的是拷贝构造函数�?br>
既然知道了问题所在，那么解决的方法当然自己来定义拯��构造和赋��D��符了，具体做法��׃��列�D了�?br>
在某些情况下�Q�实现类的拷贝构造函数和赋值操作符是非帔R��烦的时候，特别是确定程序中不会做拷贝和赋值操作的时候，��d��现它们确实有点得不偿失。而不定义又怕出��C��q�问题，在这里有个��y妙（与其说��y妙不如说��h��:-)�Q�的�Ҏ(gu��)��Q�就是可以只��它们声明�ؓprivate成员而不��d��现它们。这��h��可以防止了会有�h��L��C��用它们，也防止了�~�译器自动生成�?br>
��Z��提一下拷贝构造被调用的三�U�场合：
1.在声明语句中用一个对象初始化另一个对象；
2.��一个对象作为参数按��D��用方式传递给另一个对象时生成对象副本�Q?br>3.生成一个��(f��)时对象作为函数的�q�回�l�果�Q?br>

老狼 2008-12-07 21:14 发表评论

老狼 — Tue, 25 Nov 2008 07:06:00 GMT

先看一个例子：

1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4
5char* fun(const char* src)
6{
7  static char dest[32] = "";
8
9  strcpy(dest, src);
10
11  return dest;
12}
13
14int main()
15{
16  char s1[32] = "";
17  char s2[32] = "";
18
19  strcpy(s1, fun("hello"));
20  strcpy(s2, fun("world"));
21
22  printf("%s %s\n", s1, s2);
23  printf("%s %s\n", fun("hello"), fun("world"));
24
25  return 0;
26}

��M��下这个程序，先看�q�个�E�序写的有问题没�Q�假设fun函数的参数长度小�?2�Q�？如果你对�q�个�E�序中的fun函数�q�回一个局部变量的数组产生了疑问，那么我希望你是没注意到我使用的static�c�d��Q�若你仍有疑问，��你先回去查查static变量的作用域和生命周期的概念�?br> OK�Q�是�q�行�q�个�E�序的时候了�Q�看一下运行结果是否跟你想象的一样呢�Q�如果是一��L(f��ng)��Q�那么这��文章你不用看了�Q�因��Z��已经掌握了我下面要说的问题了。好吧，对于不理解运行结果的朋友�Q�我们来分析一些下面那个printf语句�Q�首先要知道printf中的表达式、函数的执行��序是至叛_��左的�Q�也��是先执行了fun("world")�q�回了dest的地址�Q�然后再执行fun("hello")也返回了dest的地址�Q�而这两次�q�回的dest用的同一块地址�Q�因为是static�c�d��Q�，也就是第二次的执行覆盖了�W�一�ơ执行的�l�果�Q�对dest地址�q�行了重新的赋��|��所以结果就是打��C��个hello了�?/p>

我们在写C/C++�E�序的时候，�l�常需要从调用函数中取得自己想要的数据�Q�这��需要调用者和函数之间要有个内存的交互�Q�我们通常采用的方法是传递一个指针给被调函数�Q�作��调函数的输出参数�Q�这也是我们常用的、规范的做法�?br> 但有很多�E�序员比较习(f��n)惯直接取�q�回��|��q�就面��(f��)一个问题就是普通局部变量都是在栈上分派的，会随着函数的结束而弹栈释放，那么��׃��出现�q�回局部变量数�l�的问题�Q�这时有��Z��惛_��用malloc或new在堆上分�z�ֆ�存，没错�Q�这��h��避免了前面说的问题，但这样又会带来新的问题，��是需要在外部对这块内存进行释放，�q�个是比较难把握的，多次释放会出现程序的crash�Q�忘记释放了会出现内存leak�Q�所以这�U�方法也不被推荐。还有�h惛_��了更另类的方法，��是上面例子中的static�c�d��Q�没错，static变量也是全局的，但就会出��C��面程序的�q�行�l�果�Q�可以认��Z��是我们想要的�l�果�Q�也��是错误的结果）�?br> 所以，我们要慎用返回函数内部的static内存的这�U�设计，但如果在无法改变设计模式的情况下�Q�有些系�l�函数的实现�Q�比如inet_ntoa�Q�可以通过在man手册中看到这��L(f��ng)��一句话�Q�The string is returned in a statically allocated buffer, which subsequent calls will overwrite�Q�，那么在自�׃��用的时候一定要注意�Q�不要试图保存返回的内存地址或引用，而要保存�q�回内存的内容，也就是例子程序中的strcpy两行�?br>
inet_ntoa的错误��用（判断两个IP地址是否相等�Q�：

1struct in_addr addr1;
2struct in_addr addr2;
3
4// �|�络包中包含了源地址
5addr1.s_addr = 0x6500A8C0 // 192.168.0.101
6addr2.s_addr = 0x6600A8C0 // 192.168.0.102
7
8// �q�个if语句��永�q��ؓ�?/span>
9if (strcmp(inet_ntoa(addr1), inet_ntoa(addr2)) == 0) {
10 // do something
11} else {
12 // do other thing
13}

老狼 2008-11-25 15:06 发表评论

三元�q�算�W�的使用

老狼 — Fri, 14 Nov 2008 04:03:00 GMT

三元�q�算�W�对于C�E�序员来说应该是很熟�(zh��n)�的了，有时它可以��代码更简�z�、清晎ͼ�所以深得一部分�E�序员的喜爱�Q�但在��用上是不是每一个程序员都知道它的准��用法呢�Q�今天有人给我看了一个非常简单的�E�序�Q�问我�ؓ什么编译出错，我才知道原来真的有�h会忽略这个问题，代码如下�Q?br>

#include <iostream>

using namespace std;

int main()
{
  int a = 1;

  (a != 1) ? a = 2 : cout << "hello" << endl;

  return 0;
}

发现问题了吗�Q�我让他把cout�Ҏ(gu��)��了printf�Q�又让他仔细看了�~�译错误的信息，�q�且man printf看返回倹{�?br>是的�Q�三元运��符的两个表辑ּ�是需要的int�c�d��Q�而cout�q�回值是void*�Q�看来我们常用的未必都是我们真正掌握�?img src="http://www.shnenglu.com/CuteSoft_Client/CuteEditor/images/emsmile.gif" align=absMiddle border=0>

老狼 2008-11-14 12:03 发表评论

老狼 — Tue, 14 Oct 2008 07:56:00 GMT

getopt�Q�）原型�Q?/span>

int getopt( int argc, char *const argv[], const char *optstring );

参数argc、argv分别对应main函数的参敎ͼ�表示参数个数和参数数�l�，optstring为选项字符丌Ӏ�getopt函数调用会返回第一个选项�Q�如果以相同的参数再�ơ调用的话会�q�回下一个选项�Q�以此类推，当参数列已经到结��时getopt()函数�q�回-1�Q�当遇到一个未知的选项�?getopt �q�回'?'�Q��ƈ且每�ơ都会重新设�|�相应的全局变量�?

getopt()讄��的全局变量包括�Q?/div>

1.optarg(char*) -- 指向当前选项参数的指针；

2.optind(int) -- 再次调用getopt()时的下一个argv指针的烦引；

3.optopt(int) -- 最后一�ơ调用getopt()�q�回的已知选项�Q?/div>

4.opterr(int) -- 变量opterr被初始化�?。如果不希望getopt()输出出错信息�Q�将全域变量opterr设�ؓ0卛_��Q?/div>

用一个自己应用到的例子来��单解析该函数�Q?/div>

1 #include <stdio.h>
2 #include <unistd.h>
3
4 int main(int argc, char** argv )
5 {
6   int ch�Q�destConsole = 0;
7   int def = 0;
8   char* buf[4];
9
10   opterr = 0;
11   while ((ch = getopt(argc, argv, "Of:h:p:"))!= -1) {
12     switch(ch) {
13       case 'O':
14         buf[0] = optarg;
15         break;
16       case 'f':
17         buf[1] = optarg;
18         break;
19       case 'h':
20         buf[2] = optarg;
21         break;
22       case 'p':
23         buf[3] = optarg;
24         break;
25       default:
26         def = 1;
27     }
28   }
29
30   printf("buf[0]: %s\n", buf[0]);
31   printf("buf[1]: %s\n", buf[1]);
32   printf("buf[2]: %s\n", buf[2]);
33   printf("buf[3]: %d\n", atoi(buf[3]));
34
35   return 0;
36 }

�q�是一个记录日志的�E�序部分代码�Q�没做出错处理）�Q�同时支持终端输出、写文�g、远�E�传输等功能�Q�还有一些写数据库等�Q�不一一列�D�Q��?/span>

选项字符串�ؓ�Q?#8220;Of:h:p:”�Q?/span>

O表示是无参数选项�Q�终端输出判断部分在14行，可以加一行给�l�端输出讄��标记�Q�比如destConsole=1�Q�无参数自然对应30行就应该打印�I�；

f、h、p都�ؓ有参数选项�Q�如果都有设�|�有效，那么对应的就会在31-33行分别打印文件名、主机名、端口号�?/span>

�q�行�l�果�Q?/span>

[root@develop-x /]# ./testOpt -O -f test.txt -h 192.168.0.111 -p 6666

buf[0]:

buf[1]: test.txt

buf[2]: 192.168.0.111

buf[3]: 6666

复杂命��o行处理getopt_long()可以参考man和getopt()�Q�主要是增强了长选项的功能�?/div>

老狼 2008-10-14 15:56 发表评论

C++构造函数调用构造函数的问题

老狼 — Wed, 08 Oct 2008 10:51:00 GMT

1 #include <iostream>
2
3 using namespace std;
4
5 class Test
6 {
7   public:
8     int _mX;
9     int _mY;
10
11     Test(int n)
12     {
13       _mX = n;
14       cout << this << endl;
15     }
16
17     Test()
18     {
19       cout << this << endl;
20       Test(0);
21     }
22 };
23
24 int main()
25 {
26   Test test;
27
28   return 0;
29 }

执行一下这�D�代码，打印��Z��两个不同的对象地址�Q�因��Z��带参数的构造函数实现里去调用带参数的构造函数时�Q��ƈ没有完成对象内部的函数调用，而是优先选择了通过带参数构造函数又构造出了一个新的对象�?/div>

所以在实际应用中，我们应该�Q?/div>

1. 我们要尽量避免构造函数间的调用；

2. 有�h�?f��n)惯在默认构造里�Ҏ(gu��)��员进行初始化�Q�带参构造里�q�行赋值或更�ؓ复杂的处理，但实际各个构造函数的关系应该�q�列�Q�我们应该在每个构造函数里都做成员初始化的操作�Q�或者把成员初始化和每个构造函数要�q�行的同��L(f��ng)��操作��装��Z��个类的私有成员函敎ͼ�在每个构造函数里调用该成员函敎ͼ�

3. 如果实在避免不了构造函��C��间的调用�Q�那��只能用必杀了，采用new的方式，即上面的代码20行改�?span style="FONT-SIZE: 13px; COLOR: rgb(57,57,57); LINE-HEIGHT: 21px; FONT-FAMILY: verdana">new (this)Test(0)�Q��构造函数在已经分配好的内存上执行，而不是重新分配新的内�?span style="FONT-SIZE: 13px; COLOR: rgb(0,0,0)">;

老狼 2008-10-08 18:51 发表评论