请教, c语言的面向对象 (CU最近很安静啊)

Question

本帖最后由 三月廿七 于 2011-04-23 22:01 编辑

"面向对象"在我(菜鸟)看来就是"忽悠"的代名词， 鉴于"类" 比"结构体"容易码， 所以如下会采用"类" 这个潮流名词来描述问题，

假设我现在设计一个基类Actor，子类有 Player， Enemy， Effect

我想写一个通用的移动函数 move（）来更新对象的位置。effect的移动方式不同于player/enemy
effect 的移动方式有很多种，比如 从屏幕顶部落向底部 或是 从屏幕左端移向右端， 或是在屏幕内移动碰到边界反向， 或是 跟随作用者， 或是跟随使用者,
player/enemy 碰到边界是不会反向的， 只会停留在屏幕边界处。

我把move()函数主观定义在Actor类里面， 是这样写的

void move(Actor actor)
{
        int x = 0;
                int z = 0;

        switch (actor->direction)
        {
        case DIRECTION_UP:
                z = -1;
                break;
        case DIRECTION_DOWN:
                z = 1;
                break;
        case DIRECTION_LEFT:
                x = -1;
                break;
        case DIRECTION_RIGHT:
                x = 1;
                break;
        default:
                break;
        }

        actor->x += actor->vx * x;
        actor->vx += actor->ax;

        actor->z += actor->vz * z;
                actor->vz += actor->az;

        actor->y += actor->vy;
        actor->vy += actor->ay;

        if (actor->x < currentLevelRect[0])
        {
             
                   if ((actor->type == PLAYER) || (actor->type == ENEMY) )
                   {
                        actor->x = currentLevelRect[0];
                   }
                 
                   if (actor->type == EFFECT)
                   {
                         if ()
                         {}
                        
                         if ()
                         {}
                          
                         if ()
                         {}

                         if ()
                         {}
                   }
        }

}

/*************************/
void move(Actor actor)
{
        int x = 0;
                int z = 0;

        switch (actor->direction)
        {
        case DIRECTION_UP:
                z = -1;
                break;
        case DIRECTION_DOWN:
                z = 1;
                break;
        case DIRECTION_LEFT:
                x = -1;
                break;
        case DIRECTION_RIGHT:
                x = 1;
                break;
        default:
                break;
        }

        actor->x += actor->vx * x;
        actor->vx += actor->ax;

        actor->z += actor->vz * z;
                actor->vz += actor->az;

        actor->y += actor->vy;
        actor->vy += actor->ay;
}

moveEffect()
{
      moveActor();
            
      if ()
      {}
                        
      if ()
      {}
                          
      if ()
      {}

       if ()
       {}
}

这样会不会好一点，呢？

请教， 这个函数在概念上设计的合理吗？ 基类的这个函数应该根据类型判断移动方式吗？
有更好的设计方法吗？

Answer 1

C语言搞OO就是用链表

Answer 2

C语言搞OO就是用链表
新右卫门 发表于 2011-04-23 19:31

你这话说的很不专业， 很外行.

Answer 3

回复 3# 三月廿七

     平时工作都是修修补补 水平是比较低 工作了几年连main 函数都没写过

Answer 4

gobject

Answer 5

回复 1# 三月廿七

    瞎JB扯。你那段烂代码跟用C来OOP有个毛关系。懒得看。
   ps, C++和C的差别也不是只在OOP上，它们根本是不同的语言。别他妹的看不起C++.

    给出一种用C来OOP的办法。
    用C来OOP，关键在于定义一个包含函数指针的结构体。如果你想要这个结构体能够被继承，那就先用宏来定义机构体内的内容。
    比如：

1. #define CONTROL_COMMON \
2.     int type;\
3.     int x;\
4.     int y;\
5.     int w;\
6.     int h;\
7.     control *parent;\
8.     lp_list *controls;\
9.     void (*mouse_process)(control *this,int x,int y,int type);\
10.     void (*key_process)(control *this,int keyCode,int type);\
11.     void (*paint)(graphics *g,control *this);\
12.     void (*paint_front)(graphics *g,control *this);\
13.     void (*destroy)(control *this);

复制代码当你要继承和使用这个宏的时候，可以这样：

1. #define TEXT_CONTROL_COMMON \
2.     CONTROL_COMMON\
3.     void (*append_char_w)(control *this,lp_unicode uni);\
4.     int focus_y;
5. struct control_t
6. {
7.   CONTROL_COMMON
8. };
10. struct text_control_t
11. {
12.   TEXT_CONTROL_COMMON
13. };

复制代码然后你写一个初始化函数来初始化这个结构体，将其数据内容和函数指针初始化。这个初始化函数就好像C++里面的构造函数一样，只不过必须要人工写代码手动调用。
   最后你可以写一个销毁函数来销毁这个结构体。这个销毁函数就好像C++里面的析构函数一样。不过必须得手动调用。
   而多态能力的获得，也许你可以写一个函数来在运行时决定其结构体(函数指针指向的函数)。
   手动调用销毁函数这一事实导致C语言无法实现C++的RAII资源管理。
    剩下的东西我懒得讲了，用C来OOP？...擦，多么老掉牙的话题。

Answer 6

回复 1# 三月廿七

    OOP编程范式神马地方忽悠你了。你读过GOF的设计模式吗？擦，讨厌。
   神马静态类型语言动态类型语言这些差别导致OOP编程范式的不同或者OOP编程范式的使用方式，有研究过嘛？

   没深入了解某种范式就开始说是否忽悠你了，放什么厥词呢。至少也给我稍微深入研究点了再说啊！

Answer 7

本帖最后由 三月廿七 于 2011-04-24 09:17 编辑

用C来OOP，关键在于定义一个包含函数指针的结构体
//

这一句， 很好笑。"关键在于",   
而且你的回复偏离了帖子的主题。

Answer 8

回复 8# 三月廿七

用C来OOP，关键在于定义一个包含函数指针的结构体
三月廿七 发表于 2011-04-24 08:59

不管你信不信 在实际中的确是这么用的，下面摘自python源码。

1. #define _PyObject_HEAD_EXTRA            \
2.     struct _object *_ob_next;           \
3.     struct _object *_ob_prev;
6. #define PyObject_HEAD                   \
7.     _PyObject_HEAD_EXTRA                \
8.     Py_ssize_t ob_refcnt;               \
9.     struct _typeobject *ob_type;
12. typedef struct _object {
13.     PyObject_HEAD
14. } PyObject

复制代码

Answer 9

如果python 是你写的？ 我相信 "在实际中的确是这么用的".