Оригинал темы здесь
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?
Хочется разобрать по полочкам и понять как делать, закат солнца в ручную.
Как оно всё в унутрях то работает.
Ещё пример.
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
}Получается ООП так же работает, просто скрывает данные нюансы? Или там всё же посложней реализация?
Просмотр сообщений
