Просмотр сообщений

В этом разделе можно просмотреть все сообщения, сделанные этим пользователем.


Сообщения - Jordan

Страницы: [1] 2 3 ... 18
1
Общий раздел / Объясните ООП на пальцах
« : Декабрь 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
}

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

2
За моё почти годовое отсутствие на этом форуме, новостей событий не произошло. Форуму явно не хватает активности.

3
Общий раздел / Re: Oberon-07/13: заметки
« : Ноябрь 14, 2014, 01:54:16 pm »
Точнее так.

Может вынести array в пространство имён std?

M: STD.ARRAY OF INTEGER;

M.Add(5);
M.Remove(5);
M.Clear();

4
Общий раздел / Re: Oberon-07/13: заметки
« : Ноябрь 14, 2014, 01:49:43 pm »
Может вынести array в пространство имён std?

M: ARRAY * OF INTEGER;

Std.M.Add(5);
Std.M.Remove(5);
Std.M.Clear();

Все новые фичи добавлять в такое пространство.

Чем хуже вариант из stl?

M: STD.VECTOR OF INTEGER;
Mas: STD.VECTOR OF INTEGER OF INTEGER; двухмерный

M.PUSH_BACK(idx);
M.PUSH_FRONT(idx);
M.RESERVE(size);
M.SIZE();

и т.д

Ну и SORT добавить. Так как void* то нет. Каждый раз писать заново.

5
Урочище Флуда / Re: Что - то скучно у вас...
« : Ноябрь 14, 2014, 01:41:46 pm »
Если не разрабатывать для оберона ide. Тогда можно взять, ide и настроить под оберон. Выйдет дешевле.

6
Общий раздел / Re: Project Oberon on FPGA
« : Ноябрь 13, 2014, 10:09:54 am »
Алексей, есть новости? Как продвигаются дальнейшие эксперименты?

7
Урочище Флуда / Re: Что - то скучно у вас...
« : Ноябрь 13, 2014, 10:06:46 am »
Уфф  окинул взглядом Оберонную активность на этом форуме на этом форуме (за последний год) - и есть ощущение, что тема исчерпала себя  :D Господа... что скажете?

Уже все обсудили ;) Хотя я тут собираюсь закинуть тему про динамические массивы в ебероне (сейчас доку пишу) - можно будет пообсуждать.

Да вы, гурман. ;)

8
Урочище Флуда / Re: Что - то скучно у вас...
« : Ноябрь 13, 2014, 10:06:04 am »
Уфф  окинул взглядом Оберонную активность на этом форуме на этом форуме (за последний год) - и есть ощущение, что тема исчерпала себя  :D Господа... что скажете?

Все тролли сыты! :D

9
Урочище Флуда / Re: Что - то скучно у вас...
« : Ноябрь 13, 2014, 10:03:55 am »
А что с любителям Оберона во всепланетном масштабе ( я про обьединение многочисленных  наследников таки почившего после долгих мучений BB)?

Здравствуй Дизер.

Хладный труп, обсуждают, дописывают и герметизируют. :)

10
Общий раздел / Re: 14 сентября, обероновстреча.
« : Сентябрь 16, 2014, 11:36:34 am »
Иван Денисов сделал удобный плейлист для просмотра.

Что то как то встреча, тихо прошла, не медведей не цыган. :)

11
Объясните неучу, что это даёт в практическом плане?

12
Общий раздел / Re: Делаем строку на O7
« : Март 15, 2014, 03:42:53 pm »
vlad

MODULE test;
IMPORT JS;
 
VAR
  S1: STRING;
  S2: STRING;
BEGIN
  S1 := "Hello ";
  S2 := "World!";
    JS.alert(S1 + S2);
END test.

Eberon на STRING ругается.
Цитировать
line 5: undeclared identifier: 'STRING'

Изменения ещё не внесены в язык? Компилю в режиме Eberon.

13
Общий раздел / Re: Делаем строку на O7
« : Март 15, 2014, 03:33:50 pm »
Что, то я сглючил. Код же в js компилируется. Спишем, на недосып.

14
Общий раздел / Re: Делаем строку на O7
« : Март 15, 2014, 02:47:43 pm »
Вот что получилось в oberonjs:
https://github.com/vladfolts/oberonjs/wiki/eberon-strings
Критикуйте :)

Что критиковать? Отличная работа, теперь в языке нормальные строки, которые должны быть.
Как дела обстоят с юникодом? Будет отдельный тип вроде WSTRING, или при компиляции можно выбрать, считать STRING unicod'ом?

Во free pascal'е 2 вариант, есть ключ компиляции, который string заменяет на wstring. Исходники переделывать не нужно. По умолчанию utf8. Как мне кажется, лучше сделать по умолчанию utf32, а уже в зависимости от системы, внутренние функции будут конвертировать в системную кодировку. К примеру в windows utf16, в linux utf8.

15
Общий раздел / Re: Online компилятор Oberon-07/11.
« : Январь 22, 2014, 04:48:28 pm »
Статья Вирта в переводе.

Хорошие идеи: взгляд из Зазеркалья

Цитировать
Аналогичным примером является инструкция проверки границ массива. Она сравнивала индекс массива с нижней и верхней границами массива и вызывала системное прерывание, если значение индекса не находилось в этом диапазоне, объединяя, тем самым, две инструкции сравнения и две инструкции ветвления.

Страницы: [1] 2 3 ... 18