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

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


Сообщения - Jordan

Страницы: [1] 2 3 ... 18
1
Общий раздел / Re: Вопросы по С/С++
« : Ноябрь 02, 2017, 06:54:56 pm »
Ты же общую идею кода понял, кроме внесения проверок на ошибки что можно улучшить в коде? Код намеренно использует стандарт c++98 без auto и т.д

2
Общий раздел / Re: Вопросы по С/С++
« : Ноябрь 02, 2017, 06:52:36 pm »
Ляксей здаров! Как исправить, что бы без уб?

Получается сразу после конструктора вызывается деструктор?

3
Общий раздел / Re: Вопросы по С/С++
« : Октябрь 28, 2017, 02:01:42 pm »
Разобрался.

Компилятор не на second ругался а на return с текстом, переделал.

const string & msg::str(const string & val)
{
  map<string, string>::iterator i = m_data.find(val);

  if (i == m_data.end())
  {
    m_buffer = "Error: Not foint string in " + val;
   
    return m_buffer;
  }
  else
  {
    return i->second;
  }
}

4
Общий раздел / Вопросы по С/С++
« : Октябрь 28, 2017, 01:43:42 pm »
Написал код для разбора файла формата:
{номер}{строка}

Пример

{100}{Hello!}

Код на С++

#ifndef _MSG_HPP
#define _MSG_HPP
/*******************************************************************************

*******************************************************************************/
class msg
{
public:
  msg(const string & name);
  ~msg();
  char read_char();
  bool read();
  const string & get();
  const string & str(const string & val);

private:
  size_t   m_line;
  size_t   m_tabs;
  string   m_buffer;
  ifstream m_input;
  map<string, string> m_data;
};
/*******************************************************************************

*******************************************************************************/
msg::msg(const string & name)
{
  m_input.open(name.c_str());
 
  m_line = 1;
  m_tabs = 0;
 
  while(read())
  {
    string f = get();
    read();
    string s = get();
    m_data.insert(pair<string, string>(f,s));
  }
 
  for (map<string,string>::iterator i = m_data.begin(); i != m_data.end(); ++i)
  {
    cout << i->first + " = " + i->second  << endl;
  }
}
/*******************************************************************************

*******************************************************************************/
msg::~msg()
{
  m_input.close();
}
/*******************************************************************************

*******************************************************************************/
char msg::read_char()
{
  char ch = m_input.get();
 
  m_tabs++;
 
  if (ch == '\n')
  {
    m_line++;
    m_tabs = 0;
  }
 
  return ch;
}
/*******************************************************************************

*******************************************************************************/
bool msg::read()
{
  m_buffer.clear();
 
  char ch = read_char();

  while ((ch == ' ') || (ch == '\n'))
  {
    ch = read_char();
  }

  if (ch == '{')
  {
    ch = read_char();

    while (ch != '}')
    {
      if (ch != '\n')
      {
        m_buffer.push_back(ch);
      }
      ch = read_char();
    }
  }
 
  if (ch == EOF)
  {
    return false;
  }
 
  return true;
}
/*******************************************************************************

*******************************************************************************/
const string & msg::get()
{
  return m_buffer;
}
/*******************************************************************************

*******************************************************************************/
const string & msg::str(const string & val)
{
  map<string, string>::iterator i = m_data.find(val);

  if (i == m_data.end())
  {
    return "Error: Not found string in " + val;
  }
  else
  {
    return i->second;
  }
}
/*******************************************************************************

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

Проблема в этой функции

const string & msg::str(const string & val)
{
  map<string, string>::iterator i = m_data.find(val);

  if (i == m_data.end())
  {
    return "Error: Not found string in " + val;
  }
  else
  {
    return i->second;
  }
}

Как вернуть second?

5
Общий раздел / Объясните ООП на пальцах
« : Декабрь 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
}

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

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

7
Общий раздел / 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();

8
Общий раздел / 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* то нет. Каждый раз писать заново.

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

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

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

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

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

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

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

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

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

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

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

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

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

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