Последние сообщения

Страницы: [1] 2 3 ... 10
1
Общий раздел / Re: BlackBox без MDI
« Последний ответ от Ivan Denisov Октябрь 15, 2018, 03:56:43 am »
Переделал для 1.7
2
Общий раздел / qsort как так отсортировать
« Последний ответ от Jordan Сентябрь 18, 2018, 03:03:35 pm »
Приветствую!

Код

typedef struct critter
{
  int number;
  int value;
  char * name;
} critter;

int comp(const void* a, const void* b)
{
        const critter* k = (const critter*)a;
        const critter* m = (const critter*)b;
        int s = ((k -> number) - (m -> number));

        return s;
}

  critter mas[5];
 
  mas[0].number = 5;
  mas[1].number = 4;
  mas[2].number = 3;
  mas[3].number = 2;
  mas[4].number = 1;
 
 
  qsort(mas, 5, sizeof(critter), comp);
 
  for (size_t i = 0; i < 5; i++)
  {
    printf("%d\n", mas.number);
  }


Как перестроить функцию сравнения так, что бы в аргументы можно было передать не только number, но и value

int comp(const void* a, const void* b)
{
        const critter* k = (const critter*)a;
        const critter* m = (const critter*)b;
        int s = ((k -> number) - (m -> number)); // в аргументы функции можно было передать value не изменяя функцию

        return s;
}

Так не надо.
int comp(const void* a, const void* b)
{
        const critter* k = (const critter*)a;
        const critter* m = (const critter*)b;
        int s = ((k -> value) - (m -> value));

        return s;
}

Генерируется код

typedef struct critter_vector
{
  size_t total;
  size_t pos;
  critter * data;
} critter_vector;

int critter_vector_compare_int(const void *a, const void *b)
{
  return *(int *)a - *(int *)b;
}

void critter_vector_sort_int(critter_vector * src)
{
 qsort(src->data, critter_vector_size(src), sizeof(critter), critter_vector_compare_int); //как передать не только number но и value
}

Так как поля critter будут разные. Не понимаю как всё это сделать.
3
Общий раздел / Re: деструкторы С++ и аналог в си
« Последний ответ от Jordan Сентябрь 18, 2018, 06:58:59 am »
Понял. Без умного указателя деструктор объектов в векторе не вызывается.

Сначала нужно удалить вручную память по указателям, после чего при выходе из области видимости вектора, он уничтожается.

Получается, что к примеру указатель на объект может быть и в другом векторе или контейнере и при уничтожении вектора, указатель в другой контейнере будет не валиден.

Тогда, нужно в моем случае сделать два контейнера, с возможностью вызова деструктора и без.

unique_ptr_vector деструкор вызовется автоматически при уничтожении вектора, вручную контролировать уникальность, так как в си такую проверку не сделать

ptr_vector массив указателей при уничтожении вектора, проходить в ручную по массиву и вызывать деструктор
4
Общий раздел / Re: деструкторы С++ и аналог в си
« Последний ответ от valexey_u Сентябрь 18, 2018, 12:57:02 am »
Для этого сделаны умные указатели (то есть в деструкторе уже указателя вызывается деструктор объекта на который он указывает): https://en.cppreference.com/w/cpp/memory/shared_ptr
https://en.cppreference.com/w/cpp/memory/unique_ptr

Умный указатель это не что-то вшитое в язык, это обычный класс, такой в плюсах можно сделать самостоятельно.
5
Общий раздел / деструкторы С++ и аналог в си
« Последний ответ от Jordan Сентябрь 16, 2018, 07:38:37 pm »
Приветствую!

Написал прогу которая генерирует типизированные контейнеры для си. По ходу написания всплыл вопрос о деструкторах.

Код на основе которого генерируется контейнер

typedef struct NAME_vector
{
  size_t total;
  size_t pos;
  TYPE * data;
} NAME_vector;

inline NAME_vector * NAME_vector_new(size_t count)
{
  NAME_vector * p = (NAME_vector*)calloc(1, sizeof(NAME_vector));
 
  p->total = count;
  p->pos   = 0;
  p->data  = (TYPE*)calloc(p->total, sizeof(TYPE));
 
  return p;
}

inline void NAME_vector_clear(NAME_vector * src)
{
  src->pos = 0;
}

inline size_t NAME_vector_size(NAME_vector * src)
{
  return src->pos;
}

inline size_t NAME_vector_capacity(NAME_vector * src)
{
  return src->total;
}

inline TYPE * NAME_vector_get(NAME_vector * src, size_t idx)
{
  assert(idx <= NAME_vector_size(src));

  return &src->data[idx];
}

inline void NAME_vector_free(NAME_vector * src)
{
  for (size_t i = 0; i < NAME_vector_size(src); i++)
  {
    TYPE * j = NAME_vector_get(src, i);
    NAME_destroy(j);
  }
 
  free(src->data);
  free(src);
}

/*
inline void NAME_vector_free(NAME_vector * src)
{
  free(src->data);
  free(src);
}
*/

inline void NAME_vector_set(NAME_vector * src, size_t idx, TYPE val)
{
  memcpy(&src->data[idx], &val, sizeof(TYPE));
}

inline void NAME_vector_resize(NAME_vector * src, size_t count)
{
  if (count > src->total)
  {
    src->total = count;
    src->data  = (TYPE*)realloc(src->data, src->total * sizeof(TYPE));
  }
}

inline void NAME_vector_push_back(NAME_vector * src, const TYPE val)
{
  if (src->pos + 1 > src->total)
  {
    src->total = src->total * 2;
    src->data  = (TYPE*)realloc(src->data, src->total * sizeof(TYPE));
  }

  memcpy(&src->data[src->pos], &val, sizeof(TYPE));
  src->pos++;
}


Код деструктора для вектора

inline void critter_ptr_vector_free(critter_ptr_vector * src)
{
  for (size_t i = 0; i < critter_ptr_vector_size(src); i++)
  {
    critter * j = critter_ptr_vector_get(src, i);
    critter_destroy(j);
  }
 
  free(src->data);
  free(src);
}

Сам код данного объекта

#define critter_max (32)

typedef struct
{
  char * name;
  uint16_t base [critter_max];
  uint16_t bonus[critter_max];
} critter;

void critter_init(critter * src, const char * name)
{
  src->name = strdup(name);

  for (size_t i = 0; i < critter_max; i++)
  {
    src->base = 5;
  }
 
  for (size_t j = 0; j < critter_max; j++)
  {
    src->bonus[j] = 7;
  }
}

void critter_destroy(critter * src)
{
  free(src->name);
}

Вроде все понятно. При уничтожении ветора все объекты будут корректно уничтожены, главное реализовать деструктор для хранимого объекта.

Но если хранить не объекты а указатели на объекты.

typedef struct NAME_ptr_vector
{
  size_t total;
  size_t pos;
  TYPE ** data;
} NAME_ptr_vector;

inline NAME_ptr_vector * NAME_ptr_vector_new(size_t count)
{
  NAME_ptr_vector * p = (NAME_ptr_vector*)calloc(1, sizeof(NAME_ptr_vector));
 
  p->total = count;
  p->pos   = 0;
  p->data  = (TYPE**)calloc(p->total, sizeof(TYPE*));
 
  return p;
}

inline void NAME_ptr_vector_clear(NAME_ptr_vector * src)
{
  src->pos = 0;
}

inline size_t NAME_ptr_vector_size(NAME_ptr_vector * src)
{
  return src->pos;
}

inline size_t NAME_ptr_vector_capacity(NAME_ptr_vector * src)
{
  return src->total;
}

inline TYPE * NAME_ptr_vector_get(NAME_ptr_vector * src, size_t idx)
{
  assert(idx <= NAME_ptr_vector_size(src));

  return src->data[idx];
}

inline void NAME_ptr_vector_free(NAME_ptr_vector * src)
{
  for (size_t i = 0; i < NAME_ptr_vector_size(src); i++)
  {
    TYPE * j = NAME_ptr_vector_get(src, i);
    NAME_destroy(j);
  }
 
  free(src->data);
  free(src);
}

/*
inline void NAME_ptr_vector_free(NAME_ptr_vector * src)
{
  free(src->data);
  free(src);
}
*/

inline void NAME_ptr_vector_set(NAME_ptr_vector * src, size_t idx, TYPE * val)
{
  src->data[idx] = val;
}

inline void NAME_ptr_vector_resize(NAME_ptr_vector * src, size_t count)
{
  if (count > src->total)
  {
    src->total = count;
    src->data  = (TYPE**)realloc(src->data, src->total * sizeof(TYPE*));
  }
}

inline void NAME_ptr_vector_push_back(NAME_ptr_vector * src, TYPE * val)
{
  if (src->pos + 1 > src->total)
  {
    src->total = src->total * 2;
    src->data  = (TYPE**)realloc(src->data, src->total * sizeof(TYPE*));
  }

  src->data[src->pos] = val;
  src->pos++;
}

Генерируется вектор указателей. Код почти аналогичен.

Вопрос в том, что в С++ деструктор для указателей объектов которые находятся в векторе не вызывается автоматически. Для чего это сделано?
Стоит ли в моей реализации поступить так же?
6
Общий раздел / Re: Опережающее определение struct в си
« Последний ответ от kkkk Сентябрь 15, 2018, 05:56:18 pm »
Имя тэга после ключевого слов struct должно отличаться от имени, задаваемого "переменной"-типом через typedef, так как в С++ это способы определения синонимичны, а в С - нет. Поэтому в Си компилируется без проблем, а в С++ это повторное задание идентификатора в той же области видимости
7
Общий раздел / Re: Опережающее определение struct в си
« Последний ответ от Jordan Сентябрь 15, 2018, 05:27:57 pm »
За то теперь ругается компилятор с++, си компилирует.
8
Общий раздел / Re: Опережающее определение struct в си
« Последний ответ от Jordan Сентябрь 15, 2018, 05:24:39 pm »
Разобрался нужно объявить struct widget_vector * childs;
9
Общий раздел / Re: Опережающее определение struct в си
« Последний ответ от Jordan Сентябрь 15, 2018, 04:03:14 pm »
Смысл в том, что бы не меняя язык, внешней программой генерировать типобезопасные контейнеры для си. Вообще подходит для любого языка. Потому и в обероне можно сделать типобезопасный stl, не меняя язык. Не так удобно, но работает.
10
Общий раздел / Опережающее определение struct в си
« Последний ответ от Jordan Сентябрь 15, 2018, 04:00:15 pm »
Приветствую!

Есть такой код

typedef struct
{
  char * name;
} widget;

void widget_destroy(widget * src)
{
  unised(src);
}

И такой

typedef struct
{
  size_t total;
  size_t pos;
  widget * data;
} widget_vector;

Этот вектор генерируется прогой.

#ifndef _CONTAINERS_widget_H
#define _CONTAINERS_widget_H
typedef struct
{
  size_t total;
  size_t pos;
  widget * data;
} widget_vector;

inline widget_vector * widget_vector_new(size_t count)
{
  widget_vector * p = (widget_vector*)calloc(1, sizeof(widget_vector));
 
  p->total = count;
  p->pos   = 0;
  p->data  = (widget*)calloc(p->total, sizeof(widget));
 
  return p;
}

inline void widget_vector_clear(widget_vector * src)
{
  src->pos = 0;
}

inline size_t widget_vector_size(widget_vector * src)
{
  return src->pos;
}

inline size_t widget_vector_capacity(widget_vector * src)
{
  return src->total;
}

inline widget * widget_vector_get(widget_vector * src, size_t idx)
{
  assert(idx <= widget_vector_size(src));

  return &src->data[idx];
}

inline void widget_vector_free(widget_vector * src)
{
  for (size_t i = 0; i < widget_vector_size(src); i++)
  {
    widget * j = widget_vector_get(src, i);
    widget_destroy(j);
  }
 
  free(src->data);
  free(src);
}

/*
inline void widget_vector_free(widget_vector * src)
{
  free(src->data);
  free(src);
}
*/

inline void widget_vector_set(widget_vector * src, size_t idx, widget val)
{
  memcpy(&src->data[idx], &val, sizeof(widget));
}

inline void widget_vector_resize(widget_vector * src, size_t count)
{
  if (count > src->total)
  {
    src->total = count;
    src->data  = (widget*)realloc(src->data, src->total * sizeof(widget));
  }
}

inline void widget_vector_push_back(widget_vector * src, const widget val)
{
  if (src->pos + 1 > src->total)
  {
    src->total = src->total * 2;
    src->data  = (widget*)realloc(src->data, src->total * sizeof(widget));
  }

  memcpy(&src->data[src->pos], &val, sizeof(widget));
  src->pos++;
}
typedef struct
{
  size_t total;
  size_t pos;
  widget ** data;
} widget_ptr_vector;

inline widget_ptr_vector * widget_ptr_vector_new(size_t count)
{
  widget_ptr_vector * p = (widget_ptr_vector*)calloc(1, sizeof(widget_ptr_vector));
 
  p->total = count;
  p->pos   = 0;
  p->data  = (widget**)calloc(p->total, sizeof(widget*));
 
  return p;
}

inline void widget_ptr_vector_clear(widget_ptr_vector * src)
{
  src->pos = 0;
}

inline size_t widget_ptr_vector_size(widget_ptr_vector * src)
{
  return src->pos;
}

inline size_t widget_ptr_vector_capacity(widget_ptr_vector * src)
{
  return src->total;
}

inline widget * widget_ptr_vector_get(widget_ptr_vector * src, size_t idx)
{
  assert(idx <= widget_ptr_vector_size(src));

  return src->data[idx];
}

inline void widget_ptr_vector_free(widget_ptr_vector * src)
{
  for (size_t i = 0; i < widget_ptr_vector_size(src); i++)
  {
    widget * j = widget_ptr_vector_get(src, i);
    widget_destroy(j);
  }
 
  free(src->data);
  free(src);
}

/*
inline void widget_ptr_vector_free(widget_ptr_vector * src)
{
  free(src->data);
  free(src);
}
*/

inline void widget_ptr_vector_set(widget_ptr_vector * src, size_t idx, widget * val)
{
  src->data[idx] = val;
}

inline void widget_ptr_vector_resize(widget_ptr_vector * src, size_t count)
{
  if (count > src->total)
  {
    src->total = count;
    src->data  = (widget**)realloc(src->data, src->total * sizeof(widget*));
  }
}

inline void widget_ptr_vector_push_back(widget_ptr_vector * src, widget * val)
{
  if (src->pos + 1 > src->total)
  {
    src->total = src->total * 2;
    src->data  = (widget**)realloc(src->data, src->total * sizeof(widget*));
  }

  src->data[src->pos] = val;
  src->pos++;
}
typedef struct
{
  size_t total;
  widget * objs;
  bool * used;
} widget_object_pool;

inline widget_object_pool * widget_object_pool_new(size_t count)
{
  widget_object_pool * p = (widget_object_pool*)calloc(1, sizeof(widget_object_pool));

  p->total = count;
  p->objs  = (widget*)calloc(p->total, sizeof(widget));
  p->used  = (bool*)calloc(p->total, sizeof(bool));
 
  return p;
}

inline void widget_object_pool_free(widget_object_pool * src)
{
  for (size_t i = 0; i < src->total; i++)
  {
    //widget_destroy(&src->objs[i]);
  }
 
  free(src->objs);
  free(src->used);
  free(src);
}

inline bool widget_object_pool_find_free(widget_object_pool * src, size_t * idx)
{
  for (size_t i = 0; i < src->total; i++)
  {
    if (src->used[i] == false)
    {
      *idx = i;
     
      return true;
    }
  }

  return false;
}

inline void widget_object_pool_remove(widget_object_pool * src, widget * val)
{
  size_t i = 0;
 
  while ((i < src->total) && (&src->objs[i] != val))
  {
    i++;
  }

  if (i < src->total)
  {
    src->used[i] = false;
  }
}

inline widget * widget_object_pool_alloc(widget_object_pool * src)
{
  size_t i = 0;

  assert(widget_object_pool_find_free(src, &i));
 
  src->used[i] = true;
   
  return &src->objs[i];
}
typedef struct widget_hash_node
{
  widget data;
  char * key;
  size_t hash;
  struct widget_hash_node * next;
  struct widget_hash_node * prev;
} widget_hash_node;

typedef struct widget_hash_list
{
  struct widget_hash_node * head;
  struct widget_hash_node * tail;
} widget_hash_list;

typedef struct widget_hash
{
  size_t total;
  widget_hash_list * list;
} widget_hash;

inline size_t widget_hash_size(widget_hash * src)
{
  return src->total;
}

inline widget_hash * widget_hash_new(size_t count)
{
  widget_hash * p = (widget_hash*)calloc(1, sizeof(widget_hash));
 
  p->total = count;
  p->list  = (widget_hash_list*)calloc(p->total, sizeof(widget_hash_list));

  return p;
}

inline void widget_hash_list_push_back(widget_hash_list * list, widget_hash_node * 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;
}

inline unsigned int widget_hash_hashed(const char * str)
{
  unsigned int hash = 0;

  for(; *str; str++)
    hash = (hash * 1664525) + (unsigned char)(*str) + 1013904223;

  return hash;
}

inline widget_hash_node * widget_hash_node_new(const char * key, widget data)
{
  widget_hash_node * p = (widget_hash_node*)calloc(1, sizeof(widget_hash_node));
 
  p->hash = widget_hash_hashed(key);
  p->key  = strdup(key);
  memcpy(&p->data, &data, sizeof(widget));
 
  return p;
}

inline widget_hash_node * widget_hash_find_node(widget_hash * src, const char * key)
{
  size_t h = widget_hash_hashed(key) % src->total;
 
  for (widget_hash_node * i = src->list[h].head; i != NULL; i = i->next)
  {
    if (strcmp(i->key, key) == 0)
    {
      return i;
    }
  }

  return NULL;
}

inline void widget_hash_insert(widget_hash * src, const char * key, widget data)
{
  widget_hash_node * i = widget_hash_find_node(src, key);
     unised(data);
  if (i == NULL)
  {
    i = widget_hash_node_new(key, data);
    widget_hash_list_push_back(&src->list[i->hash % src->total], i);
  }
}

inline widget * widget_hash_find(widget_hash * src, const char * key)
{
  widget_hash_node * i = widget_hash_find_node(src, key);
 
  if (i != NULL)
  {
    return &i->data;
  }
 
  return NULL;
}

inline void widget_hash_list_destroy(widget_hash_list * list)
{
  widget_hash_node * curr;
  widget_hash_node * next;

  curr = list->head;

  while (curr != NULL)
  {
next = curr->next;
free(curr);
curr = next;
}

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

inline void widget_hash_free(widget_hash * src)
{
  for (size_t i = 0; i < src->total; i++)
  {
    if (src->list[i].head != NULL)
    {
      widget_hash_list_destroy(&src->list[i]);
    }
  }
}

inline void widget_hash_list_remove(widget_hash_list * list, widget_hash_node * elem)
{
  if (elem == list->head)
  {
    if (elem->next != NULL)
    {
      list->head = elem->next;
      elem->next->prev = NULL;
    }
    else
    {
      list->head = NULL;
    }
  }
  else if (elem == list->tail)
  {
    if (elem->prev != NULL)
    {
      list->tail = elem->prev;
      elem->prev->next = NULL;
    }
    else
    {
      list->tail = NULL;
    }
  }
  else
  {
    elem->next->prev = elem->prev;
elem->prev->next = elem->next;
  }
}
inline widget * widget_new()
{
  widget * p = (widget*)calloc(1, sizeof(widget));
 
  return p;
}
#endif
Каждый в своих h файлах

Но мне нужно что бы работал вот такой код

typedef struct
{
  char * name;
  widget_vector * childs;
} widget;

Как объявить widget так что бы код стал валидным?

#include "widget.h"
#include "containers/containers_widget.h"

Если объявить код так,

#include "containers/containers_widget.h"//widget_vector
#include "widget.h"

Естественно  компилятор ругается на отсутствие widget

В С++ можно так

class widget; и все ок

В си

struct widget; Не работает.

Это мои эксперименты с кодогенерацией.
Страницы: [1] 2 3 ... 10