Автор Тема: Объясните ООП на пальцах  (Прочитано 23499 раз)

Jordan

  • Sr. Member
  • ****
  • Сообщений: 282
    • Просмотр профиля
Объясните ООП на пальцах
« : Декабрь 06, 2016, 04:42:42 am »
Оригинал темы здесь http://forum.oberoncore.ru/viewtopic.php?f=12&t=5968

Продублирую сюда, может кто не может на оберкор заходить. Да и сишников полно, Влад и Ляксей. ;)

Приветствую. Давненько я тем не открывал.

Хотелось бы понять ООП, я знаю, что все совеременные языки поддерживают эту парадигму. Но мне хочется понять, как ООП работает изнутри на примере процедурного языка.

Пример С++.
class rect
{
public:
size_t x, y, w, h;
};

class widget
{
public:
private:
rect area;
};

class window: public widget
{
public:
private:
};



Что получилось, window наследует widget/
И теперь в window можно обращаться к классу rect

Теперь пример на си, хотелось бы узнать данный пример соответствует ООП парадигме

typedef struct
{
size_t x;
size_t y;
size_t w;
size_t h;
} gui_rect;

typedef struct
{
gui_rect area;
} gui_widget;

typedef struct
{
gui_widget widget;
} gui_window;

Теперь gui_window тоже обладает полями widget'а

Но обращаться приходится через переменную widget
Пример
gui_window win;
win.widget.area.x
На С++
window win;
win.x

В чём вопрос, я правильно понимаю, что допустим если транслировать С++ в С, то примерно получится тот же код?

#ifndef _LIB_GUI_H
#define _LIB_GUI_H
/*******************************************************************************

*******************************************************************************/
size_t gui_strlen(const char * src)
{
  size_t i = 0;
 
  while (src[i] != 0)
  {
    i++;
  }
 
  return i;
}
/*******************************************************************************

*******************************************************************************/
char * gui_strdup(const char * src)
{
  size_t l = gui_strlen(src);
 
  char * p = (char*)calloc(gui_strlen(src) + 1, sizeof(char));
 
  assert(p);

  memcpy(p, src, l);

  return p;
}
/*******************************************************************************

*******************************************************************************/
size_t gui_strcpy(char * dst, const char * src, size_t maxlen)
{
  const size_t srclen = strlen(src);
 
  if (srclen < maxlen)
  {
    memcpy(dst, src, srclen + 1);
  }
  else if (maxlen != 0)
  {
    memcpy(dst, src, maxlen - 1);
    dst[maxlen - 1] = '\0';
  }

  return srclen;
}
/*******************************************************************************

*******************************************************************************/
size_t gui_strcat(char * dst, const char * src, size_t maxlen)
{
    const size_t srclen = gui_strlen(src);
    const size_t dstlen = gui_strlen(dst);
   
    if (dstlen == maxlen)
    {
      return maxlen+srclen;
    }
   
    if (srclen < maxlen-dstlen)
    {
      memcpy(dst+dstlen, src, srclen+1);
    }
    else
    {
      memcpy(dst+dstlen, src, maxlen-dstlen-1);
      dst[maxlen-1] = '\0';
    }
   
    return dstlen + srclen;
}
/*******************************************************************************

*******************************************************************************/
#define GUI_WIDGET_TYPE_IS_WINDOW  0
#define GUI_WIDGET_TYPE_IS_BUTTON  1
/*******************************************************************************

*******************************************************************************/
typedef struct
{
  size_t x;
  size_t y;
  size_t w;
  size_t h;
} gui_rect;
/*******************************************************************************

*******************************************************************************/
typedef struct gui_list
{
  struct gui_widget * head;
  struct gui_widget * tail;
} gui_list;
/*******************************************************************************

*******************************************************************************/
typedef struct gui_widget
{
  size_t type;
  void * data;
  struct gui_widget * next;
  struct gui_widget * prev;
  gui_list childs;
  gui_rect area;
  char * title;
} gui_widget;
/*******************************************************************************

*******************************************************************************/
typedef struct
{
  gui_widget widget;
} gui_window;
/*******************************************************************************

*******************************************************************************/
typedef struct
{
  gui_widget widget;
} gui_button;
/*******************************************************************************

*******************************************************************************/
void gui_list_push_back(gui_list * list, gui_widget * elem)
{
  assert(list);
  assert(elem);

  if (list->head == NULL)
  {
    list->head = elem;
    elem->prev = NULL;
  }
  else
  {
    list->tail->next = elem;
    elem->prev = list->tail;
  }

  list->tail = elem;
  elem->next = NULL;
}
/*******************************************************************************

*******************************************************************************/
void gui_list_init(gui_list * list)
{
  assert(list);

  list->head = NULL;
  list->tail = NULL;
}
/*******************************************************************************

*******************************************************************************/
size_t gui_widget_get_type(gui_widget * src)
{
  assert(src);

  return src->type;
}
/*******************************************************************************

*******************************************************************************/
void gui_widget_set_type(gui_widget * src, size_t type)
{
  assert(src);

  src->type = type;
}
/*******************************************************************************

*******************************************************************************/
void gui_widget_set_size(gui_widget * src, size_t x, size_t y, size_t w, size_t h)
{
  assert(src);

  src->area.x = x;
  src->area.y = y;
  src->area.w = w;
  src->area.h = h;
}
/*******************************************************************************

*******************************************************************************/
void * gui_widget_get_data(gui_widget * src)
{
  assert(src);

  return src->data;
}
/*******************************************************************************

*******************************************************************************/
void gui_widget_set_data(gui_widget * src, void * ptr)
{
  assert(src);
  assert(ptr);

  src->data = ptr;
}
/*******************************************************************************

*******************************************************************************/
void gui_widget_set_title(gui_widget * src, const char * title)
{
  assert(src);

  if (src->title != NULL)
  {
    free(src->title);
    src->title = NULL;
  }
 
  src->title = gui_strdup(title);
}
/*******************************************************************************

*******************************************************************************/
void gui_widget_get_size(gui_widget * src, gui_rect * dst)
{
  assert(src);

  src->area.x = dst->x;
  src->area.y = dst->y;
  src->area.w = dst->w;
  src->area.h = dst->h;
}
/*******************************************************************************

*******************************************************************************/
size_t gui_widget_get_pos_x(gui_widget * src)
{
  assert(src);

  gui_rect rt;
 
  gui_widget_get_size(src, &rt);

  return rt.x;
}
/*******************************************************************************

*******************************************************************************/
size_t gui_window_get_pos_x(gui_window * src)
{
  assert(src);
  assert(gui_widget_get_type(&src->widget) == GUI_WIDGET_TYPE_IS_WINDOW);
  assert(gui_widget_get_data(&src->widget));
 
  return gui_widget_get_pos_x(&src->widget);
}
/*******************************************************************************

*******************************************************************************/
gui_window * gui_window_new(size_t x, size_t y, size_t w, size_t h, const char * title)
{
  gui_window * p = (gui_window*)calloc(1, sizeof(gui_window));
 
  assert(p);
 
  gui_widget_set_type(&p->widget, GUI_WIDGET_TYPE_IS_WINDOW);
  gui_widget_set_data(&p->widget, p);
  gui_widget_set_size(&p->widget, x, y, w, h);
  gui_widget_set_title(&p->widget, title);
 
  gui_list_init(&p->widget.childs);
 
  return p;
}
/*******************************************************************************

*******************************************************************************/
void gui_widget_attach(gui_widget * dst, gui_widget * src)
{
  assert(dst);
  assert(src);
 
  gui_list_push_back(&dst->childs, src);
}
/*******************************************************************************

*******************************************************************************/
void gui_window_attach_button(gui_window * dst, gui_button * src)
{
  assert(dst);
  assert(src);

  gui_widget_attach(&dst->widget, &src->widget);
}
/*******************************************************************************

*******************************************************************************/
bool gui_point_in_rect(size_t x, size_t y, gui_rect * rect)
{
  return (x > rect->x) && (x < rect->x + rect->w) && (y > rect->y) && (y < rect->y + rect->h);
}
/*******************************************************************************

*******************************************************************************/
gui_widget * gui_widget_contains(gui_widget * widget, size_t x, size_t y)
{
  for (gui_widget * i = widget->childs.head; i != NULL; i = i->next)
  {
    if (gui_point_in_rect(x, y, &i->area))
    {
      return i;
    }
  }

  return NULL;
}
/*******************************************************************************

*******************************************************************************/
#endif

Уточню вопрос, window наследуется от widget, это нужно понимать как window содержит в себе поля widget?

Хочется разобрать по полочкам и понять как делать, закат солнца в ручную. :D Как оно всё в унутрях то работает.

Ещё пример.

typedef struct
{
size_t hex;
} map_object;

typedef struct
{
map_object map_obj;
} critter_object;

typedef struct
{
map_object map_obj;
} item_object;

typedef struct
{
item_object item_obj;
} weapon_object;

size_t weapon_get_hex(weapon_object * obj)
{
return obj->item_obj.map_obj.hex
}

Есть map_object, от него наследуется critter_object и item_object. От item_object наследуется weapon_object.

Если писать в ООП стиле, то в map_object
Будет метод
size_t map_object::get_hex()
{
return hex;
}

И из наследуемых классов так же, можно вызвать get_hex

А в си, сложнее, придётся обращаться к через все поля пример

size_t weapon_get_hex(weapon_object * obj)
{
return obj->item_obj.map_obj.hex
}

Получается ООП так же работает, просто скрывает данные нюансы? Или там всё же посложней реализация?

vlad

  • Hero Member
  • *****
  • Сообщений: 1391
    • Просмотр профиля
Re: Объясните ООП на пальцах
« Ответ #1 : Декабрь 06, 2016, 05:38:25 am »
Да, это сишный аналог ООП из С++ (если отбросить виртуальные функции и виртуальное наследование - там сложнее).
Т.е., наследование в С это когда "родитель" идет первым полем в "наследнике". При этом для доступа к родителю приходится квалифицировать это поле. Приведение типа родитель -> наследние будет выглядеть как обычное сишное приведение типа: (derived*)base.

Чтобы сделать аналог dynamic_cast - придется вручную завести type info, на которую будет хранится указатель в каждом объекте. Эту же структуру можно использовать для реализации виртуальных функций.

Вобщем там особой магии со стороны компилятора С++ нет, можно делать ООП на голом С, но муторно.