精华区文章阅读

发信人: allen (猪头的岁月), 信区: Programming
标  题: 女娲补天
发信站: 哈工大紫丁香 (Wed Apr 10 15:51:11 2002) , 转信

女娲造人

                                                ----构造析构与对象的生死

作者：HolyFire

在《由始至终----构造与析构》最后我提到了C++中的构造函数和析构函数与对象的生和死
有着很大的关系，好好运用还能控制对象的生死，使得编程的思路更接近现实世界的规律
。

我们先回忆一下，在对象创建的时候，合适的构造函数将被自动调用，而对象销毁的时候
，析构函数将被自动调用。在构造函数与析构函数可以被随意调用的情况下，也就是被声
明为public的时候，这没有任何问题，但是一旦我们将他们的可视性改为private与prote
cted呢，那么情况就有所改观了。

声明为private的时候，那么除了类本身可以调用外，还有用friend关键字赋予信任关系的
对象（一般是类或者函数）可以访问。

#include <iostream>

using namespace std;

class A{

public:

        static A * CreateA( void )

                {

                cout << "Create a A instance By class A's Member Function" <<
endl;

                return new A;

                }

private:

        A(){ }

friend A * CreateA( void );

};

A * CreateA( void )

{

        cout << "Create a A instance By class A's friend Function" << endl;

        return new A;

}

void main()

{

        A * a1 = A::CreateA();

        A * a2 = CreateA();

        delete a1;

        delete a2;

        cin.get();

}

结果是：

Create a A instance By class A's Member Function

Create a A instance By class A's friend Function

如果你直接用A a这样的方式，是无法创建A的实例的，编译器会告诉你，它帮不上忙。

当然，将析构函数声明为私有也可以限制将A的实例销毁的条件，那么

        delete a1;

        delete a2;

也会遭到编译器的抗议，我们需要另外写一个函数或者类来销毁他们。

在现实生活中有很多事物是有限的。比如说太阳系中只有一个太阳，如果有两个太阳会出
什么乱子呢，真的是难以想象。在创建的对象有条件限制的时候，我们可以写文档告诉别
人在编程的时候注意，但是随着工程的日益庞大，不要说别人，连自己也有可能忘记，在
对条件限制要求非常严格的情况下，我们的知识便派上了用场。

结合刚才讲的将构造函数声明为私有的内容和《独一无二----静态成员变量》的内容，我
们可以设计一个只能有一个实例的类型。下面是C++的源代码，这个例子中，对实例的销毁
也加上了限制。

#include <iostream>

using namespace std;

class A{

private:

        static A * a;    //一个静态成员变量，类的所有实例所共有的

        A(){ cout << "This is class A , I couldn't direct Creat instance" << e
ndl; }

        ~A(){ cout << "This is Class A , I coudn't direct Destroy instance" <<
endl; }

public:

        void ShowInstance(){ cout << this << endl; }

friend A * CreatObjectOfA( void );             //委托信任关系，由于类没有提供创
建实例的方法，那么这个任务就交给了这个函数了。

friend void DestroyObjectOfA( A * a );             //对应创建，这个函数负责销毁
产生的实例

};

A* A::a = NULL;

A * CreatObjectOfA( void )

{

        if( A::a == NULL )       //之前有没有创建过A的实例

                {//没有

                A::a = new A;

                cout << "This is a Class A Instance Creat By CreatObjectOfA Fu
nction ." << endl;

                }//创建过的话就不用再创建了

        return A::a;     //由于A::a是静态成员变量，那么返回的都是同一个指针

}

void DestroyObjectOfA( A * _a )

{

        if( A::a != NULL )//对应创建，如果现在有实例被创建过，那么销毁它

                {

                delete A::a;

                A::a = NULL;

                cout << "This is a Class A Instance Destroy By DestroyObjectOf
A Function ." << endl;

                }

        _a = NULL;

}

void main()

{

        A * a1 , * a2 , * a3;

        a1 = CreatObjectOfA();

        a2 = CreatObjectOfA();

        a3 = CreatObjectOfA();

        a1->ShowInstance();

        a2->ShowInstance();

        a3->ShowInstance();

        DestroyObjectOfA( a1 );

        DestroyObjectOfA( a2 );

        DestroyObjectOfA( a3 );

        cin.get();

}

结果是：

This is class A , I couldn't direct Creat instance

This is a Class A Instance Creat By CreatObjectOfA Function .

00864898       //指向的都是同一个地方

00864898

00864898

This is Class A , I coudn't direct Destroy instance

This is a Class A Instance Destroy By DestroyObjectOfA Function .

至始至终只有一个实例被创建和销毁了

无论你创建多少次，这个类的实例最多有一个，这正是我们想要的。只要你肯去想，有很
多有趣的事物在等着你。

将构造函数与析构函数声明为protected(保护)，那么我们的目的就是这个类将作为基类，
而且这个基类不能直接实例化。为什么要这样做，事实上我们在理解事物和对大量事物进
行抽象的时候，会有一些不完整的片断，他们单独的出现是不合适的。比如说一些简单加
工后的半成品，甚至是现实中找不到例子的，他们的语义是残缺不全的。也有完全抽象化
的，比如说：“人”，不具体到男人，女人，小孩，大人，就无法用现实的思想来考虑它
。

那么就用一个C++的例子来实现一下，从而掌握它。

#include <iostream>

using namespace std;

class A{

protected:

       A(){ cout << "This is class A , I couldn't direct Creat instance" << en
dl;}

};

class B : public A{

public:

       B(){ cout << "This is class B public inherit From class A , I could Cre
at instance By class B" << endl; }

};

void main()

{

       B b;

       cin.get();

}

结果是：

This is class A , I couldn't direct Creat instance

This is class B public inherit From class A , I could Creat instance By class
B

这个例子很简单，我们不需要花多少时间就能理解。

到现在才回到标题上来似乎有些突然，但是没有上面的解释，理解起来会有些困难，那么
废话少说，我们直接切入主题。

中国古老的传说中，人是女娲用泥巴做的，所以说，人不能随意创建，可以创建人的事物
可以是女娲。

女娲变出了男人和女人，女人可以生孩子，也就是可以创建人，但是只有男人才能让女人
生孩子，所以关系是，要创建人必须要有一个男人来让一个女人生孩子，生孩子的行为是
女人的，但是主动权也就是男人才有权利使用女人的行为，这是男人的行为。我们可以理
解为男人的行为是发一条消息来告诉女人，女人采用相应的行为来处理。

我们来整理一下：（我使用一种简化的模式来考虑问题，要点在于理清构造函数对于对象
生死的关系）

男人和女人都是人，女人可是生孩子，孩子也是人，所以孩子要分成男人和女人，那么女
人生孩子事实上是两种行为，生男孩，生女孩，男人也有两种行为，让女人生男孩，让女
人生女孩。

女娲{ 创造男人，创造女人 }

人{}

男人{ 人，让女人生男孩（男人），让女人生女孩（女人）}

女人{ 人，生男孩（男人），生女孩（女人）}

class Person{   //人

protected:

       Person(){}  //构造函数可以让派生类使用，也就是男人和女人使用

};

class Man;

class Woman;

class NvWa{      //女娲

public:

       Man * CreatAMan(void);      //创造男人

       Woman * CreatAWoman( void ); //创造女人

};

class Woman : virtual public Person{   //女人

private:

       Woman(){}

       Man * CreatAMan( void );          //生男孩（男人）

       Woman * CreatAWoman( void ); //生女孩（女人）

friend NvWa;

friend Man;

};

class Man:virtual public Person{  //男人

private:

       Man(){}

public:

       Man * GetABoy( Woman * woman )         //让女人生男孩（男人）

              {

              return woman->CreatAMan();

              }

       Woman * GetAGirl( Woman * woman )     //让女人生女孩（女人）

              {

              return woman->CreatAWoman();

              }

friend NvWa;

friend Woman;

};

Man * NvWa::CreatAMan( void )

{

       return new Man;

}

Woman * NvWa::CreatAWoman( void )

{

       return new Woman;

}

Man * Woman::CreatAMan( void )

{

       return new Man;

}

Woman * Woman::CreatAWoman( void )

{

       return new Woman;

}

void main()

{

       NvWa nvwa;  //女娲

       Man * man = nvwa.CreatAMan();                    //创造了一个男人

       Woman * woman = nvwa.CreatAWoman();       //创造了一个女人

       Man * boy = man->GetABoy( woman );    //男人让女人生了一个男孩

       Woman * girl = man->GetAGirl( woman ); //又让女人生了一个女孩

       delete man;

       delete woman;

       delete boy;

       delete girl;

}

其实细心的朋友不难发现，创建人可以抽象成一个行为，男人和女人都是人，但是这样做
不知道生下来的是男孩或是女孩，因为继承的特性不能由其基类来得知派生类的信息，这
个问题在C++中也有解决的办法，我会在以后的文章中介绍。

--

※ 来源:．哈工大紫丁香 http://bbs.hit.edu.cn [FROM: 202.110.225.196]

Programming 版 (精华区)