干货 | C语言实现面向对象编程（附代码）

多态

多态与继承是紧耦合的关系，但它通常作为面向对象技术中最强大的优点之一。

子类从继承父类的接口，每个子类是单独的实体，每个子类需要对同一消息有单独的应答。

每个子类对同一消息的应答采用继承的相同接口，但每个子类可以有不同的实现，这就是多态。

在猫和狗的例子中，猫类、狗类都继承了哺乳动物父类的“叫”的方法，但猫类、狗类的叫声并不一样，所以猫类、狗类可以采用不同的“叫”的实现。

以下代码演示了多态。

代码：

#include  struct Mammal { int eyeColor; void (*ShowEyeColor)(struct Mammal *this); int callNum; void (*Call)(struct Mammal *this);
}; void ShowEyeColor(struct Mammal *this) { if (this->eyeColor == 1) { printf("眼睛是绿色\n");
    } else { printf("眼睛是蓝色\n");
    } return;
} void Call(struct Mammal *this) { printf("叫%d声\n", this->callNum); return;
} /* struct Mammal 的构造函数 */ void Mammal(struct Mammal *this, int eyeColor, int callNum) { this->eyeColor = eyeColor; this->ShowEyeColor = ShowEyeColor; this->callNum = callNum; this->Call = Call; return;  
} struct Dog { struct Mammal mammal; }; void Bark(struct Dog *this) { int i; for (i = 0; i < this->mammal.callNum; i++) { printf("汪 ");
    } printf("\n"); return;
} /* struct Dog 的构造函数 */ void Dog(struct Dog *this, int eyeColor, int callNum) {
    Mammal(this, eyeColor, callNum); this->mammal.Call = Bark; return;
} // struct Dog 的析构函数 void _Dog(struct Dog *this)
{

} struct Cat { struct Mammal mammal; }; void Meow(struct Cat *this) { int i; for (i = 0; i < this->mammal.callNum; i++) { printf("喵 ");
    } printf("\n"); return;
} /* struct Cat 的构造函数 */ void Cat(struct Cat *this, int eyeColor, int callNum) {
    Mammal(this, eyeColor, callNum); this->mammal.Call = Meow; return;
} // struct Cat 的析构函数 void _Cat(struct Cat *this)
{

} int main(void) { struct Dog myDog; Dog(&myDog, 1, 3); struct Cat myCat; Cat(&myCat, 2, 5); struct Mammal *myMammal; myMammal = &myDog;
    myMammal->Call(myMammal);
    myMammal = &myCat;
    myMammal->Call(myMammal);

    _Dog(&myDog);
    _Cat(&myCat); return 0;
}

#include  struct Window { int length; int width; void (*ShowWindow)(struct Window *this);
}; void ShowWindow(struct Window *this) { printf("这是长%d厘米、宽%d厘米的窗户\n", this->length, this->width); return;
} void Window(struct Window *this, int length, int width) { this->length = length; this->width = width; this->ShowWindow = ShowWindow; return;
} void _Window(struct Window *this)
{

} struct House { struct Window *window; int livingRoomNum; int bedRoomNum; int bathRoomNum; void (*ShowHouse)(struct House *this);
}; void ShowHouse(struct House *this) { printf("这是%d室%d厅%d卫的房子\n", this->bedRoomNum, this->livingRoomNum, this->bathRoomNum); return;
} void House(struct House *this, int livingRoomNum, int bedRoomNum, int bathRoomNum) { this->livingRoomNum = livingRoomNum; this->bedRoomNum = bedRoomNum; this->bathRoomNum = bathRoomNum; this->ShowHouse = ShowHouse; return;
} void _House(struct House *this)
{

} void main() { struct House myHouse; House(&myHouse, 2, 3, 2); /* 组合是一种低耦合，如果不初始化，子类只是存放了一个空指针来占位关联。
       此处是与继承关系的区别。继承是一种强耦合，在继承关系中，无论如何子类拥有父类全部的信息。*/ struct Window myWindow1; myHouse.window = &myWindow1;
    Window(myHouse.window, 100, 50); /* 通过获得其它对象的引用而在“运行时”动态定义 */ myHouse.ShowHouse(&myHouse);
    myHouse.window->ShowWindow(myHouse.window);

    _Window();
    _House(); return;
}