Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
Всего: 338
+2
// https://habr.com/ru/company/jugru/blog/469465/
// Инициализация в современном C++
// ...
//Есть примеры ещё более странного поведения этого синтаксиса:
std::string s(48, 'a'); // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
std::string s{48, 'a'}; // "0a"
> В первой строке создаётся строка из 48 символов «а», а во второй строка «0а». Это происходит потому, что конструктор string принимает на вход initializer_list из символов. 48 является целочисленным значением, поэтому оно преобразуется в символ. В ASCII число 48 — код символа «0». Это очень странно, потому что есть конструктор, принимающий именно такие аргументы, int и char. Но вместо вызова этого конструктора происходит совершенно неочевидное преобразование. В итоге получается код, который чаще всего ведёт себя не так, как мы ожидаем.
КАК? Как можно было столько хуйни наворотить для такой простой вещи, как инициализация переменной? Чем они вообще думают?
Не перестаю удивляться долбоебизму крестостандартизаторов
j123123,
05 Октября 2019
0
#include <ncurses.h>
#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#define msleep(msec) Sleep(msec)
#else
#include <unistd.h>
#define msleep(msec) usleep(msec*1000)
#endif
int main()
{
initscr();
char str[100];
addstr("Enter string: ");
getstr(str); //Считваем строку
curs_set(0); //"Убиваем" курсор, чтобы не мешался
while ( true )
{
//Перемещаем х-координату как можно дальше вправо, и будем уменьшать её, пока она != 0
for ( unsigned x = getmaxx(stdscr); x; x-- )
{
clear();
mvaddstr(getmaxy(stdscr) / 2, x, str);
refresh();
msleep(200);
}
}
endwin();
return 0;
}
https://code-live.ru/post/ncurses-input-output/#getstr-
Сколько хуйни вы можете найти в этом примере?
j123123,
04 Октября 2019
+1
#include <stdbool.h>
bool impl(bool a, bool b) // ->
{
return (!a || b);
}
bool always_true(bool a, bool b)
{
return (impl(a,b) == impl(b,a)) == (a == b); // ( (a -> b) = (b -> a) ) = (a = b) tautology
}
/*
GCC не хочет мне тавтологию оптимизировать!
https://godbolt.org/z/kgFMpR
always_true:
movl %esi, %eax
xorl %edi, %eax
cmpb %dil, %sil
sete %dl
xorl %edx, %eax
ret
Но Clang может
https://godbolt.org/z/YcOat-
always_true: # @always_true
movb $1, %al
retq
*/ГОВНО!
j123123,
24 Сентября 2019
0
// https://www.opennet.ru/opennews/art.shtml?num=51508
// Microsoft открыл код стандартной библиотеки С++, поставляемой в Visual Studio
// https://github.com/microsoft/STL/blob/7f65140761947af4ed7f9dfc11adee8c86c9e4c2/stl/inc/unordered_map#L712
#if _HAS_CXX17
template <class _Iter, class _Hasher = hash<_Guide_key_t<_Iter>>, class _Keyeq = equal_to<_Guide_key_t<_Iter>>,
class _Alloc = allocator<_Guide_pair_t<_Iter>>,
enable_if_t<
conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
int> = 0>
unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(), _Alloc = _Alloc())
->unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
class _Alloc = allocator<pair<const _Kty, _Ty>>,
enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
_Alloc = _Alloc())
->unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>;
template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(_Iter, _Iter, _Alloc)
->unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>,
_Alloc>;
template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc)
->unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>,
_Alloc>;
template <class _Iter, class _Hasher, class _Alloc,
enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
->unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
unordered_map(initializer_list<pair<_Kty, _Ty>>, _Alloc)->unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Alloc)
->unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
template <class _Kty, class _Ty, class _Hasher, class _Alloc,
enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
->unordered_map<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
#endif // _HAS_CXX17Ну и хуйня! Впрочем, разве могло быть иначе?
j123123,
18 Сентября 2019
+2
// https://habr.com/ru/post/466985/
// о каррировании в крестоговне
// По сути это каррирующее говно просто складывает куда-то хуйню, а потом целиком ее в функцию призывает.
// Ну т.е. на Си можно написать дрисню вида
int shit(int a, int b, int c, int d)
{
return a*(b+c*d);
}
// И вот каррирование такой дрисни это как если б я сделал структуру
struct shit_arguments
{
int a;
int b;
int c;
int d;
};
// И потом бы с конца заполнял это говно
struct shit_arguments;
shit_arguments.d = 13;
shit_arguments.c = 666;
shit_arguments.b = 1488;
shit_arguments.a = 42;
// и при полном заполнении этого говна просто б вызвал функцию
// подставив туда накопившееся говно
int somecrap = shit(shit_arguments.a, shit_arguments.b, shit_arguments.c, shit_arguments.d);
// именно так эта крестовая дрисня и работает, она не может произвести частичное вычисление
// не может сделать функцию с частично вычисленной дрисней в ней на основе частично переданной хуйни
// если я например в функцию shit захочу частично подставить аргументы b,c,d как 1,2,3 то у меня не получится функции вида
int shit_b1_c2_d3(int a)
{
return a*(7); // 1+2*3 = 7
}
// Нихуя подобного не будет. А если нихуя подобного нет, нахуй это бесполезное дерьмо вообще надо?
// В крестах никак нельзя на основе каких-то готовых функций сгенерить
// видоизмененные функции с частично сделанными вычислениями
// Никакой нормальной рефлексии нет, просто какие-то тупые кривые костыли к сишечке налепили
// И это программисты?
j123123,
15 Сентября 2019
0
(set-logic LIA)
;(set-option :produce-proofs true)
(define-fun-rec add_via_add1 ((a Int) (b Int)) Int
(ite (= b 0) a ; if (b == 0) return a
(ite (< b 0) (- (add_via_add1 (- a) (- b))) ; if (b < 0) return add_via_add(-a,-b)
(+ (add_via_add1 a (- b 1)) 1) ; return add_via_add(a, b-1) + 1;
)
)
)
(assert
(not (forall ((a Int) (b Int))
(= (add_via_add1 a b) (+ a b))
))
)
(check-sat)
(get-model)
(exit)Хуйня, которую SMT солверы Z3 и CVC4 доказать не могут. Надо переходить на Coq, Metamath, LEAN, Mizar или еще какую-то такую хуйню
j123123,
15 Сентября 2019
−1
// вообще, есть одна говнистая особенность сишки:
// нельзя вернуть из функции массив хуйпойми какой длины, выделив память чисто на стеке
// Вот например:
char *a_ret (size_t len)
{
char *ret = alloca(len);
memset(ret, 'a', len);
return ret; // так нельзя
}
// т.е. надо делать как-нибудь вот так
char *a_ret (size_t len)
{
char *ret = malloc(len);
if (ret == NULL)
{
exit(ENOMEM);
}
memset(ret, 'a', len);
return ret;
}
Но это ж на самом-то деле говно какое-то. Дергать аллокаторы какие-то, ради каких-то мелких кусков байтиков.
Почему не сделать хуйни, чтоб вызываемая функция как бы приосталавливалась и просила ту функцию, которая ее вызывает, чтоб она вот такой-то alloca() сделала нужного размера в своем стекфрейме, а потом туда вот та вызванная функция байтики уже вхерачивала? Ну т.е. можно сделать отдельный свой стек для локальных переменных тех функций, которые должны уметь такую хуйню делать (т.е. просить вызвавшую их функцию "а сделай ка там себе alloca(123) и дай мне указатель, а я в него насру")
Вообще хуйня какая-то, сишка слишком сильно сковывает всякой своей хуйней, соглашениями вызовов, всякими ABI там. То ли дело ассемблер!
j123123,
15 Мая 2019
+1
https://tass.ru/nacionalnye-proekty/6391295
Томские ученые разработали первое в России программное обеспечение, независимое от WindowsШОК! Томские ученые открыли способ создавать программное обеспечение, независимое от Windows. Нужно всего лишь…
j123123,
30 Апреля 2019
0
// https://github.com/QWalk/mainline/blob/b12ea3652226caef23c2f5fc7b168746c89096f2/src/system/Pseudopotential_so.cpp#L36
doublevar legendre_so(doublevar x, int n)
{
switch(n)
{
case 0:
return 1;
case 1:
return x;
case 2:
return .5*(3*x*x-1);
case 3:
return .5*(5*x*x*x - 3*x);
case 4:
return 0.125*(35*x*x*x*x -30*x*x +3);
case 5:
return 0.125*(63*x*x*x*x*x - 70*x*x*x + 15*x);
default:
error("Do not have legendre polynomial of order ", n);
return 0; //shouldn't get here, but gets rid of a compiler message
}
}
Вот нет чтоб через шаблоноговно нагенерировать эти свои многочлены Лагранжа.
https://en.wikipedia.org/wiki/Legendre_polynomials#Rodrigues'_formula_and_other_explicit_formulas
Интересно, сколько строк шаблоноговна на это придется потратить?
И вообще, надо чтоб гомоиконность!
j123123,
29 Апреля 2019
+4
#include <iostream>
#include <string>
#include <string_view>
int main() {
std::string s = "Hellooooooooooooooo ";
std::string_view sv = s + "World\n";
std::cout << sv;
}
https://alexgaynor.net/2019/apr/21/modern-c++-wont-save-us/
What's happening here is that s + "World\n" allocates a new std::string, and then is converted to a std::string_view. At this point the temporary std::string is freed, but sv still points at the memory that used to be owned by it. Any future use of sv is a use-after-free vulnerability. Oops! C++ lacks the facilities for the compiler to be aware that sv captures a reference to something where the reference lives longer than the referent. The same issue impacts std::span, also an extremely modern C++ type.
j123123,
24 Апреля 2019
Follow us!