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

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


Сообщения - Jordan

Страницы: [1] 2 3 ... 19
1
Общий раздел / Re: Закат солнца вручную!
« : Февраль 22, 2019, 05:46:21 pm »
Пока был на уровне STL все шло нормально. Но мне захотелось посмотреть как оно всё под капотоп то работает.

2
Общий раздел / Re: Закат солнца вручную!
« : Февраль 22, 2019, 05:44:10 pm »
На гитхабе посмотрел реализацию msvcrt, как реализован malloc

void* malloc(size_t _size)
{
   return HeapAlloc(hHeap, HEAP_ZERO_MEMORY, _size);
}

В dllmain при загрузке данной либы

Цитировать
     hHeap = HeapCreate(0, 100000, 0);
        if (hHeap == NULL)
return FALSE;

Ну ладно думаю, сделаю аналогично.

Цитировать
#include <windows.h>

#define S1(x) #x
#define S2(x) S1(x)


#define _Assert(Expression, File, Line)                            \
do {                                                               \
if(!(Expression))                                              \
{                                                              \
MessageBox(0, S2(Line), "", 0);    \
ExitProcess(0);                                                  \
}                                                              \
} while(0)


#define Assert(X) _Assert(X, __FILE__, __LINE__)


#define NULL 0

class Memory
{
private:
  HANDLE Heap;
 
public:
Memory()
{
  Heap = NULL;

  Heap = HeapCreate(0, 100000, 0);

  Assert(Heap != NULL);
}

void * Allocate(unsigned int Size)
{
  void * p = NULL;

  p = HeapAlloc(Heap, HEAP_ZERO_MEMORY, Size);
 
  Assert(p != NULL);
 
  return p;
}

void Deallocate(void * Src)
{
  Assert(Src != NULL);
 
  HeapFree(Heap, 0, Src);
}

};

Memory GlobalMemoryAllocator;

void * operator new(unsigned int Size)
{
  void * p = GlobalMemoryAllocator.Allocate(Size);

  return p;
}


void operator delete(void * Src)
{
  GlobalMemoryAllocator.Deallocate(Src);
}




class Mem
{
public:
  int m_Data;
};

Mem idl;

void Main()
{

Mem * p = new Mem;

        p->m_Data = 5;

        if (p->m_Data > 10)
        {
        p->m_Data = 100;
        }
       
  MessageBox(0, "Hello!", "MsgBox", 0);
 
  //Console Out;

  //Out.Write("Hello World!");
 
  ExitProcess(0);
}

Все равно не работает. Ассерты не срабатывают.

3
Общий раздел / Re: Закат солнца вручную!
« : Февраль 22, 2019, 05:05:27 pm »
Нагуглил, сделал проверку оп ассерту, один фиг не работает.

Цитировать
#include <windows.h>

#define Assert(Expression)                                      \
do {                                                               \
if(!(Expression))                                              \
{                                                              \
MessageBox(0, "#Expression", "Assert", 0);                      \
ExitProcess(0);                                                  \
}                                                              \
} while(0)

#define NULL 0

class Memory
{
private:
  HANDLE Heap;

public:
Memory()
{
}

void * Allocate(unsigned int Size)
{
  void * p = NULL;

  p = VirtualAlloc(NULL, Size, MEM_RESERVE, PAGE_READWRITE);
 
  Assert(p != NULL);
 
  return p;
}

void Deallocate(void * Src)
{
  Assert(Src != NULL);
 
  VirtualFree(Src, 0, MEM_RELEASE);
}

~Memory()
{
  HeapDestroy(Heap);
}

};

Memory GMAllocator;

/*void * operator new(unsigned int Size)
{
  void * p = GMAllocator.Allocate(Size);

  return p;
}*/


/*void operator delete(void * Src)
{
  GMAllocator.Deallocate(Src);
}*/




class Mem
{
public:
  int m_Data;
};

Mem idl;

void Main()
{

Mem * p = (Mem*)GMAllocator.Allocate(sizeof(Mem));

        p->m_Data = 5;

        if (p->m_Data > 10)
        {
        p->m_Data = 100;
        }
       
  MessageBox(0, "Hello!", "MsgBox", 0);
 
  //Console Out;

  //Out.Write("Hello World!");
 
  ExitProcess(0);
}

4
Общий раздел / Закат солнца вручную!
« : Февраль 22, 2019, 03:24:33 pm »
Приветствую!

Решил написать минимальное приложение на winapi.

Стал реализовывать работу с памятью через winapi.

Программа падает.

Как компилю.(использую mingw)
"..\..\mingw\bin\g++" -omain -s -nostdlib -fno-rtti -fno-exceptions -fno-use-cxa-atexit -Wall -Wformat -Werror main.cpp -lkernel32 -luser32

сам исходник

#include <windows.h>

class Memory
{
private:
  HANDLE Heap;

public:
Memory()
{
  Heap = HeapCreate(0,0x01000,0);
}

void * Allocate(unsigned int Size)
{
  return HeapAlloc(Heap, 0, Size);
}

void Deallocate(void * Src)
{
  HeapFree(Heap, 0, Src);
}

~Memory()
{
  HeapDestroy(Heap);
}

};

static Memory GlobalMemoryAllocator;

void * operator new(unsigned int Size)
{
  return GlobalMemoryAllocator.Allocate(Size);
}

void operator delete(void * Src)
{
  GlobalMemoryAllocator.Deallocate(Src);
}

class Mem
{
public:
  int m_Data;
};

void Main()
{

Mem * p = new Mem;

        p->m_Data = 5;

        if (p->m_Data > 10)
        {
        p->m_Data = 100;
        }


       
  MessageBox(0, "Hello!", "MsgBox", 0);
 
  //Console Out;

  //Out.Write("Hello World!");
 
  ExitProcess(0);
}

5
Общий раздел / qsort как так отсортировать
« : Сентябрь 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 будут разные. Не понимаю как всё это сделать.

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

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

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

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

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

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

7
Общий раздел / деструкторы С++ и аналог в си
« : Сентябрь 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++;
}

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

Вопрос в том, что в С++ деструктор для указателей объектов которые находятся в векторе не вызывается автоматически. Для чего это сделано?
Стоит ли в моей реализации поступить так же?

8
За то теперь ругается компилятор с++, си компилирует.

9
Разобрался нужно объявить struct widget_vector * childs;

10
Смысл в том, что бы не меняя язык, внешней программой генерировать типобезопасные контейнеры для си. Вообще подходит для любого языка. Потому и в обероне можно сделать типобезопасный stl, не меняя язык. Не так удобно, но работает.

11
Приветствую!

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

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; Не работает.

Это мои эксперименты с кодогенерацией.

12
Урочище Флуда / Re: Тихий пк
« : Февраль 21, 2018, 04:55:22 am »
Использовать ещё хочу как эмулятор всяких дендей. Знаю что можно какой нить распери по заюзать или на на soc системе типа атом. Но все же хочется именно на этом пк. В будущем поставлю видеокарту с пассивным охлаждением. Поиграть в старые игрушки с джойстика.

13
Урочище Флуда / Тихий пк
« : Февраль 21, 2018, 04:50:17 am »
Приветствую.

Есть пк с процессором phenon x4 9550 видеокарта встроенная в маиеринку.
Использую как медиацентр. Установил Коди программа для упорядочивания фильмов них проигрывания. В системнике 3 кулера в блоке питания на кулера процессора и на задней стенке. Шумит хочется сделать тише.

Идея такая убрать из корпуса 2 вентилятора. На боковой стенке напротив проца вырезать дырку для 140 вентилятора проставить его туда на 700 оборотов. Будет дуть в корпус ,и на радиатор проца. Ещё думаю отключить два ядра снизить напряжение с частотой. Как думаете  стоит такое делать или процессор будет перегреваться. Тдп проца 95 вт

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

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

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

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