Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
Всего: 28
0
#define double 1
#define float 2
#if REAL==float
#define fft_create_arrays f_fft_create_arrays
#define getx f_getx
#define fft f_fft
#define invfft f_invfft
#define normalize_fft f_normalize_fft
#define fft1n f_fft1n
#define fftn f_fftn
#define invfftn f_invfftn
#define realfftmag f_realfftmag
#define normalize_fftn f_normalize_fftn
#endif
#undef double
#undef floathttps://github.com/borsboom/vocoder/blob/master/fft.h
gammaker,
05 Сентября 2018
0
#include <type_traits>
struct TPred1 {};
struct TPred2 {};
template<typename P1, typename P2> struct TAnd1: P1, P2 {TAnd1(P1, P2) {}};
template<typename P1, typename P2> struct TAnd2: P1, P2 {TAnd2(P1, P2) {}};
template<typename T, T v> struct my_integral_constant {enum {value=v};};
template<class T, class From> struct my_is_base_of:
my_integral_constant<bool, __is_base_of(T, From)> {};
template<typename P1, typename P2> std::enable_if_t<
my_is_base_of<TPred1, P1>::value &&
my_is_base_of<TPred1, P2>::value,
TAnd1<P1, P2>> operator&&(P1 p1, P2 p2)
{return {p1, p2};}
template<typename P1, typename P2> std::enable_if_t<
my_is_base_of<TPred2, P1>::value &&
my_is_base_of<TPred2, P2>::value,
TAnd2<P1, P2>> operator&&(P1 p1, P2 p2)
{return {(p1, p2};}
template<typename T> struct is_callable
{
template<typename T1> struct dummy;
template<typename CheckType> static short check(dummy<decltype(
std::declval<std::remove_reference_t<CheckType>>()())>*);
template<typename CheckType> static char check(...);
enum: bool {value = sizeof(check<T>(nullptr)) == sizeof(short)};
};
struct IntellisenseKiller
{
template<typename T, typename = std::enable_if_t<
std::is_function<T>::value &&
is_callable<T>::value
>> IntellisenseKiller(const T&) {}
IntellisenseKiller(bool) {}
};
IntellisenseKiller eat4GbRam = true;
Обнаружился ещё один способ превратить Visual Studio 2017 в тормозной, пожирающий 4 ГБ оперативы, блокнот с подсветкой синтаксиса.
Это минимальный пример, который я выделил из своей библиотеки и порезал всё, что не вызывает баг. Вроде бы не связанные между собой куски кода, но глюки студии вызывают только вместе. Целый день потратил на поиск причины глюка.
Случайно обнаружил, что длина получившегося фрагмента кода 42 строки. Я не подгонял, честно. Так что можно сказать, что ошибка в 42 строке. Без этой строки Intellisense заработает.
gammaker,
12 Июля 2017
−19
#include "IO/FileWriter.h"
#include "IO/FileReader.h"
#include "IO/FileSystem.h"
#include "IO/FormattedWriter.h"
#include "Range/Generators/Recurrence.h"
#include "Range/Decorators/TakeByLine.h"
#include "Range/Decorators/Map.h"
#include "Platform/Endianess.h"
using namespace Intra;
using namespace IO;
using namespace Range;
void TestFileSyncIO(FormattedWriter& output)
{
//Открываем файл для записи как временный объект и сразу же записываем в него текст.
OS.FileOpenOverwrite("TestFileSyncIO.txt")
.PrintLine("Fibonacci sequence: ", Take(Recurrence([](int a, int b) {return a+b;}, 1, 1), 10))
.PrintLine("Closing file.");
//Здесь временный объект удаляется и файл закрывается сам.
//Файл можно присвоить строчке, потому что возвращаемый тип FileReader является диапазоном символов,
//а мои контейнеры умеют инициализироваться от любых диапазонов соответствующих типов элементов, беря все их элементы.
//В этом случае файл читается целиком в строку и закрывается, так как его временный объект удаляется.
String fileContents = OS.FileOpen("TestFileSyncIO.txt");
output.PrintLine("Written file contents:")
.PrintLine(fileContents);
INTRA_ASSERT_EQUALS(
TakeByLine(fileContents).First(), //TakeByLine не выделяет память, а возвращает StringView из уже существующей строчки
"Fibonacci sequence: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]");
INTRA_ASSERT_EQUALS(
ToString(Map(ByLine(fileContents), &String::Length)), //ByLine сохраняет каждую строку в String, для них возвращается длина и этот диапазон переводится в строку. Все эти действия происходят внутри ToString
"[54, 13]");
INTRA_ASSERT_EQUALS(
ToString(Map(OS.FileOpen("TestFileSyncIO.txt").ByLine(), &String::Length)), //Аналогично предыдущему, но строки берутся напрямую из файла и тоже внутри ToString
"[54, 13]");
//Чтобы не выделять память для строк, можно предоставить внешний буфер.
char buf[100];
INTRA_ASSERT_EQUALS(
ToString(Map(OS.FileOpen("TestFileSyncIO.txt").ByLine(buf), &StringView::Length)),
"[54, 13]");
//Если размера внешнего буфера не хватает, строка разбивается на несколько частей, ограниченных размером буфера.
char smallBuf[10];
INTRA_ASSERT_EQUALS(
ToString(Map(OS.FileOpen("TestFileSyncIO.txt").ByLine(smallBuf), &StringView::Length)),
"[10, 10, 10, 10, 10, 4, 10, 3]");
//Всё это счастье работает с циклом range-based for:
size_t sumLength = 0;
for(auto str: OS.FileOpen("TestFileSyncIO.txt").ByLine(buf))
sumLength += str.Length();
INTRA_ASSERT_EQUALS(sumLength, 67);
//При желании можно сохранять окончания строк:
sumLength = 0;
for(auto str: OS.FileOpen("TestFileSyncIO.txt").ByLine(buf, Tags::KeepTerminator))
sumLength += str.Length();
INTRA_ASSERT_EQUALS(sumLength, 71);
//Ну и конечно файл можно открыть по-нормальному и читать из него, в том числе и бинарные данные:
FileReader file = OS.FileOpen("TestFileSyncIO.txt");
uint value = file.ReadRaw<uintLE>(); //Читаем беззнаковое число в порядке байт little-endian
INTRA_ASSERT_EQUALS(char(value & 255), 'F');
INTRA_ASSERT_EQUALS(char((value >> 8) & 255), 'i');
INTRA_ASSERT_EQUALS(char((value >> 16) & 255), 'b');
INTRA_ASSERT_EQUALS(char((value >> 24) & 255), 'o');
value = OS.FileOpen("TestFileSyncIO.txt").ReadRaw<uintBE>(); //Читаем беззнаковое число в порядке байт big-endian
INTRA_ASSERT_EQUALS(char(value & 255), 'o');
INTRA_ASSERT_EQUALS(char((value >> 8) & 255), 'b');
INTRA_ASSERT_EQUALS(char((value >> 16) & 255), 'i');
INTRA_ASSERT_EQUALS(char((value >> 24) & 255), 'F');
//Можно даже копировать поток и работать с двумя потоками независимо. При этом на уровне ОС по-прежнему открыт только один файл.
FileReader file2 = file;
uint value1 = file.ReadRaw<uintLE>();
uint value2 = file2.ReadRaw<uintLE>();
INTRA_ASSERT_EQUALS(value1, value2);
}
Продолжаю делать свою убийцу стандартной библиотеки C++. Вот пример её использования.
Те, кому кажется, что C++ громоздкий и невыразительный, просто не умеют его готовить.
gammaker,
02 Апреля 2017
−11
inline int8_t log2(size_t value)
{
static constexpr int8_t table[64] =
{
63, 0, 58, 1, 59, 47, 53, 2,
60, 39, 48, 27, 54, 33, 42, 3,
61, 51, 37, 40, 49, 18, 28, 20,
55, 30, 34, 11, 43, 14, 22, 4,
62, 57, 46, 52, 38, 26, 32, 41,
50, 36, 17, 19, 29, 10, 13, 21,
56, 45, 25, 31, 35, 16, 9, 12,
44, 24, 15, 8, 23, 7, 6, 5
};
value |= value >> 1;
value |= value >> 2;
value |= value >> 4;
value |= value >> 8;
value |= value >> 16;
value |= value >> 32;
return table[((value - (value >> 1)) * 0x07EDD5E59A4E28C2) >> 58];
}
Случайно наткнулся на такую магию.
Вроде проще способ был - без массивов и плясок с умножением на магическую константу с переполнением.
gammaker,
06 Марта 2017
−19
class Int {
int * i;
public:
Int(int j = 0):i(new int(j)){}
int* pointer(){return i;}
int& value(){return *i;}
~Int(){delete i; i = nullptr;}
};
int& operator*(shared_ptr<Int>& i) {
return i->value();
}
int* operator&(shared_ptr<Int>& i) {
return i->pointer();
}
int main() {
shared_ptr<Int> k(new Int(16));
*k = 64;
return *k;
}Этот код по-видимому является проявлением сразу двух синдромов - ООП головного мозга и shared_ptr головного мозга. А ещё const'ов не хватает.
gammaker,
02 Ноября 2016
−51
ProcessorInfo ProcessorInfo::Get()
{
ProcessorInfo result;
String allCpuInfo = IO::DiskFile::ReadAsString("/proc/cpuinfo");
result.BrandString = allCpuInfo().Find(StringView("\nmodel name"))
.Find(':').Drop(2).ReadUntil('\n');
result.CoreNumber = allCpuInfo().Find(StringView("\ncpu cores"))
.Find(':').Drop(2).ReadUntil('\n').ParseAdvance<ushort>();
result.LogicalProcessorNumber = (ushort)allCpuInfo().Count(StringView("processor "));
result.Frequency = ulong64(1000000*allCpuInfo().Find(StringView("\ncpu MHz"))
.Find(':').Drop(2).ReadUntil('\n').ParseAdvance<double>());
return result;
}http://www.gamedev.ru/projects/forum/?id=218183&page=5#m70
gammaker,
12 Сентября 2016
+318
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>, GenericString<Char, Allocator>> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>&, GenericString<Char, Allocator>> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>&&, GenericString<Char, Allocator>> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<const GenericStringView<Char>&, GenericString<Char, Allocator>> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>, GenericString<Char, Allocator>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>&, GenericString<Char, Allocator>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>&&, GenericString<Char, Allocator>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<const GenericStringView<Char>&, GenericString<Char, Allocator>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>, GenericString<Char, Allocator>&&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>&, GenericString<Char, Allocator>&&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>&&, GenericString<Char, Allocator>&&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<const GenericStringView<Char>&, GenericString<Char, Allocator>&&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>, const GenericString<Char, Allocator>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>&, const GenericString<Char, Allocator>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericStringView<Char>&&, const GenericString<Char, Allocator>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<const GenericStringView<Char>&, const GenericString<Char, Allocator>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>, GenericStringView<Char>> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>, GenericStringView<Char>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>, GenericStringView<Char>&&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>, const GenericStringView<Char>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>&, GenericStringView<Char>> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>&, GenericStringView<Char>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>&, GenericStringView<Char>&&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>&, const GenericStringView<Char>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>&&, GenericStringView<Char>> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>&&, GenericStringView<Char>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>&&, GenericStringView<Char>&&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<GenericString<Char, Allocator>&&, const GenericStringView<Char>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<const GenericString<Char, Allocator>&, GenericStringView<Char>> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<const GenericString<Char, Allocator>&, GenericStringView<Char>&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<const GenericString<Char, Allocator>&, GenericStringView<Char>&&> {typedef GenericString<Char, Allocator> _;};
template<typename Char, typename Allocator> struct CommonTypeRef<const GenericString<Char, Allocator>&, const GenericStringView<Char>&> {typedef GenericString<Char, Allocator> _;};Кто-нибудь знает, как сократить этот комбинаторный взрыв частичных специализаций без макросов?
gammaker,
18 Августа 2016
+319
template<typename OpeningBracketRange,
typename ClosingBracketRange,
typename StopTokenRange,
typename CommentBlockRangePairRange,
typename RecursiveCommentBlockRangePairRange>
Meta::EnableIf<
IsFiniteForwardRange<OpeningBracketRange>::_ &&
IsFiniteForwardRange<ClosingBracketRange>::_ &&
IsFiniteForwardRange<StopTokenRange>::_ &&
IsFiniteForwardRange<CommentBlockRangePairRange>::_ &&
IsFiniteForwardRange<RecursiveCommentBlockRangePairRange>::_,
decltype(Meta::Val<R>().Take(0))> ReadRecursiveBlock(int& counter, size_t* ioIndex,
OpeningBracketRange openingBracket, ClosingBracketRange closingBracket, StopTokenRange stopToken,
CommentBlockRangePairRange commentBlocks, RecursiveCommentBlockRangePairRange recursiveCommentBlocks)
{
R start = me();
size_t index = 0;
const size_t openingBracketLen = openingBracket.Count();
const size_t closingBracketLen = closingBracket.Count();
const size_t stopTokenLen = stopToken.Count();
while(!me().Empty() && counter!=0)
{
if(openingBracketLen!=0 && me().StartsWith(openingBracket))
{
counter++;
me().PopFrontExactly(openingBracketLen);
index += openingBracketLen;
continue;
}
if(closingBracketLen!=0 && me().StartsWith(closingBracket))
{
counter--;
me().PopFrontExactly(closingBracketLen);
index += closingBracketLen;
continue;
}
if(stopTokenLen!=0 && me().StartsWith(stopToken))
{
me().PopFrontExactly(stopTokenLen);
index += stopTokenLen;
break;
}
bool commentFound = false;
for(auto& commentBlock: commentBlocks)
{
commentFound = me().StartsWith(commentBlock.Get<0>());
if(!commentFound) continue;
const size_t commentBlockOpeningLen = commentBlock.Get<0>().Count();
const size_t commentBlockClosingLen = commentBlock.Get<1>().Count();
me().PopFrontN(commentBlockOpeningLen);
index += commentBlockOpeningLen;
me().FindAdvance(commentBlock.Get<1>(), &index);
me().PopFrontN(commentBlockClosingLen);
index += commentBlockClosingLen;
break;
}
if(commentFound) continue;
for(auto& commentBlock: recursiveCommentBlocks)
{
commentFound = me().StartsWith(commentBlock.Get<0>());
if(!commentFound) continue;
int commentCounter = 1;
ReadRecursiveBlock(commentCounter, &index, commentBlock.Get<0>(), commentBlock.Get<1>(), null, null);
break;
}
if(commentFound) continue;
me().PopFront();
}
if(ioIndex!=null) (*ioIndex) += index;
return start.Take(index);
}
Это мои последние достижения в написании сверх универсального обобщённого кода.
Начиналось всё с функции, которая парсила блок кода до закрывающей фигурной скобки, учитывая встречающиеся открывающие скобки. Затем появилась поддержка комментариев и строк. Позже я решил, что нечего привязываться к какому-то конкретному языку, ведь можно же таким же образом парсить другой язык, где вместо скобок begin end и комментарии по-другому оформляются.
А потом я подумал, зачем вообще привязывать типы параметров к строкам и массивам строк? И почему код, который парсится, вообще должен быть строкой, хранящейся в памяти непрерывно? В итоге мои размышления привели к такой реализации, которая способна парсить всё подряд, в том числе и связные списки, причём необязательно состоящие из символов. При этом открывающуюся скобку можно передать связным списком, закрывающуюся - массивом, а блоки комментариев передавать как массивом кортежей, так и хеш-таблицей.
При этом эта функция относится к классу примеси и наследованием её можно подмешать к любому классу, имеющему нужные методы.
gammaker,
15 Августа 2016
+9
template<typename T> struct OBB
{
vector3<T> position;
matrix3<T> transform;
vector3<T> GetPoint(bool positiveX, bool positiveY, bool positiveZ) const
{
const vector3<T> localUnitPoint = {T(positiveX)-T(0.5), T(positiveY)-T(0.5), T(positiveZ)-T(0.5)};
return vector3<T>(GetFullTransform()*vector4<T>(localUnitPoint, 1));
}
AABB<T> BoundingAABB() const
{
AABB<T> result;
result.max = result.min = position;
for(bool b1: {false, true})
for(bool b2: {false, true})
for(bool b3: {false, true}) //Перебираем все точки параллелепипеда
result.AddPoint(GetPoint(b1, b2, b3));
return result;
}
};Что-то даже не могу вспомнить, когда я такое написал. Случайно наткнулся и решил, что это должно быть здесь.
gammaker,
05 Августа 2016
+10
#ifdef _MSC_VER
template<typename> using void_t = void;
__if_exists(void_t<int>) {}
#endif
Эти строчки превратят Visual Studio 2015 в блокнот с подсветкой синтаксиса.
Для максимального эффекта их следует поместить в stdafx.h или любой другой повсеместно используемый заголовок.
Предположительно, на более старых студиях будет тот же эффект, но я не проверял.
gammaker,
05 Августа 2016
Follow us!