C++变态的多态和一种奇妙的实现

1. 我们如果要实现一个人，然后这个人（定义参数）有鼻子，眼镜，嘴巴和脸。我们通过函数修改各个参数。需要怎么做呢？

2. 我们先定义一个类person，person有四个参数nose、eye、mouth、face（这四个参数为了方便我们定义为string类型，实际上这四个参数肯定是类定义比较好）。但是这四个参数怎么修改呢。我们可以在person里面定义set函数一个一个的修改，但是如果我们在加了一个ear参数呢？还得再加一个修改ear的函数。这样很不利于扩展。我们如果增加ear参数，然后在ear类的函数中修改person的里面的esr不是就好了嘛？但是怎么做呢？以nose为例。我们可以在nose类的成员函数中定义一个函数用来修改person的nose。只要把person的指针当做参数传给nose的成员函数即可。

3. 先给出nose、eye、mouth、face的基类。

4. class Organ
   {
   public:
   virtual void setColor(Person person) = 0;//通过该函数修改person对应rogan的类。
   virtual string getOrganName() = 0;
   };
   继承于Organ的各个派生类
   class Eye :public Organ
   {
   public:
   void setColor(Person person)
   {
   person->setEye(this->Eyecolor);//直接调用peson的函数来修改person。当有ear加入的时候，我们只需要在person中加入ear的成员变量和setEar的成员函数即可。比较容易扩展。
   }
   Eye(string color):Eyecolor(color)
   {
   organName = “eye”;
   }
   string getOrganName()
   {
   return this->organName;
   }
   private:
   string Eyecolor;
   string organName;
   };
   class Face :public Organ
   {
   public:
   void setColor(Person person)
   {
   person->setFace(this->Facecolor);
   }
   Face(string color) :Facecolor(color)
   {
   organName = “face”;
   }
   string getOrganName()
   {
   return this->organName;
   }
   private:
   string Facecolor;
   string organName;
   };
   class Nose :public Organ
   {
   public:
   void setColor(Person person)
   {
   person->setNose(this->Nosecolor);
   }
   Nose(string color) :Nosecolor(color)
   {
   organName = “nose”;
   }
   string getOrganName()
   {
   return this->organName;
   }
   private:
   string Nosecolor;
   string organName;
   };
   class Mouth :public Organ
   {
   public:
   void setColor(Person person)
   {
   person->setMouth(this->Mouthcolor);
   }
   Mouth(string color) :Mouthcolor(color)
   {
   organName = “mouth”;
   }
   string getOrganName()
   {
   return this->organName;
   }
   private:
   string Mouthcolor;
   string organName;
   };
   整体代码实现：
   #include
   #include
   #include//这样的提前声明的方法只能定义指针参数和指针变量 比如funcA(Organ inB),Organ m_pB;
   //不能用与对象的定义 比如 Organ m_b 会报使用未定义的 class“Organ”;
   //也不能调用B类中的方法会报getOrganName”的左边必须指向类/结构/联合/泛型类型
   //因为没有先定义！class Organ仅仅是声明不是定义！
   //此时，只能定义指针参数和引用。不能定义对象，也不能以任何方式调用对象的成员很重要的一点。切记切记。***
   class Eye;
   class Face;
   class Mouth;
   class Nose;
   class Person
   {
   public:
   static Person instance_;
   static Person instance()
   {
   if (instance_ == nullptr)
   {
   instance_ = new Person();
   }
   return instance_;
   }
   void setEye(string eye)
   {
   this->eye = eye;
   }
   void setNose(string nose)
   {
   this->nose = nose;
   }
   void setMouth(string mouth)
   {
   this->mouth = mouth;
   }
   void setFace(string face)
   {
   this->face = face;
   }
   void addOrgan(Organ * or );//在这块只能这么定义，其他任何操作Organ类的成员函数和成员变量都会报错。
   /{
   cout << or ->getOrganName() << endl;使用了未定义类型“Organ”||“->getOrganName”的左边必须指向类/结构/联合/泛型类型
   }/**
   void loadColor();
   void display()
   {
   cout << “nose:” << this->nose << " eye:" << this->eye << " mouth:" << this->mouth << " face:" << this->face << endl;
   }
   private:
   map<string, Organ*> organMap;
   Person()
   {
   nose = “”;
   eye = “”;
   mouth = “”;
   face = “”;
   }

   string nose;
   string eye;
   string mouth;
   string face;
   };
   Person Person::instance_ = nullptr;
   class Organ
   {
   public:
   virtual void setColor(Person person) = 0;
   virtual string getOrganName() = 0;
   };
   class Eye :public Organ
   {
   public:
   void setColor(Person person)
   {
   person->setEye(this->Eyecolor);
   }
   Eye(string color):Eyecolor(color)
   {
   organName = “eye”;
   }
   string getOrganName()
   {
   return this->organName;
   }
   private:
   string Eyecolor;
   string organName;
   };
   class Face :public Organ
   {
   public:
   void setColor(Person person)
   {
   person->setFace(this->Facecolor);
   }
   Face(string color) :Facecolor(color)
   {
   organName = “face”;
   }
   string getOrganName()
   {
   return this->organName;
   }
   private:
   string Facecolor;
   string organName;
   };
   class Nose :public Organ
   {
   public:
   void setColor(Person person)
   {
   person->setNose(this->Nosecolor);
   }
   Nose(string color) :Nosecolor(color)
   {
   organName = “nose”;
   }
   string getOrganName()
   {
   return this->organName;
   }
   private:
   string Nosecolor;
   string organName;
   };
   class Mouth :public Organ
   {
   public:
   void setColor(Person person)
   {
   person->setMouth(this->Mouthcolor);
   }
   Mouth(string color) :Mouthcolor(color)
   {
   organName = “mouth”;
   }
   string getOrganName()
   {
   return this->organName;
   }
   private:
   string Mouthcolor;
   string organName;
   };
   void Person::addOrgan(Organ * or )
   {
   if (!this->organMap[or ->getOrganName()])
   {
   this->organMap[or ->getOrganName()] = or ;
   }
   }//正确的位置，要出现在类Organ后面
   void Person::loadColor()
   {
   for (auto iter : this->organMap)
   {
   auto x = iter.second;
   x->setColor(this);
   }
   }
   int main()
   {
   Person *p = Person::instance();
   p->addOrgan(new Eye(“Balck”));
   p->addOrgan(new Nose(“Green”));
   p->addOrgan(new Face(“Yellow”));
   p->addOrgan(new Mouth(“Apple”));
   p->loadColor();
   p->display();
   system(“pause”);
   return 0;
   }
   在这里我们用到了虚基类，多态函数的实现、单例模式。还有提前声明的使用注意点。