Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
0
int main(void)
{
std::string data = "HELLO WORLD!\n";
std::transform(
data.begin(), data.end(),
std::ostream_iterator<char>(std::cout, ""),
std::bind(std::plus<char>(), std::placeholders::_1, 1));
return 0;
}А как сделать это ещё короче?
digitalEugene,
02 Июня 2021
+1
template<typename ReturnType, typename... Arguments>
std::enable_if_t<!std::is_same_v<ReturnType, void>, std::deque<ReturnType>>
emit(Event<ReturnType, Arguments...>& event, const std::tuple<Arguments...>& args)
{
std::deque<ReturnType> toReturn;
for (auto&& c : event.subscribers | std::views::values)
toReturn.push_back(std::apply(c, args));
return toReturn;
}
template<typename ReturnType, typename... Arguments>
void emit(Event<ReturnType, Arguments...>& event, const std::tuple<Arguments...>& args)
{
for (auto&& c : event.subscribers | std::views::values)
std::apply(c, args);
}кодить всё же надо трезвым.
digitalEugene,
30 Мая 2021
0
// https://habr.com/ru/post/550442/
// Как компилятор C++ находит правильную функцию
// Вот так компилятор точно определяет, какую функцию следует вызвать:
// https://hsto.org/webt/mp/tb/5k/mptb5kheibrreqspserc4sfdfrs.png
// Эти шаги закреплены в стандарте C++. Каждый компилятор C++ должен следовать им,
// и все это происходит во время компиляции для каждого вызова функции. Оглядываясь
// назад, это очевидно, что должен быть такой алгоритм. Это единственный способ, которым
// C++ может поддерживать все вышеупомянутые возможности одновременно. Это то, что вы
// получите, если необходимо объединить их вместе.
// Я предполагаю, что общая цель алгоритма — «делать то, что ожидает программист»,
// и до некоторой степени он в этом преуспевает. Вы можете довольно далеко зайти,
// полностью игнорируя этот алгоритм. Но когда вы начинаете использовать все возможности
// C++, как при разработке библиотеки, то лучше знать эти правила.
Да, это конечно очень круто, только вот существует примерно 0 компиляторов, которые полностью корректно (т.е. в полном соответствии с Говностандартом) реализуют эту срань с вызовом правильной функции/метода с учетом всей хуйни.
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51577 - этот баг висит еще 2011-12-16 и его так никто нихуя не пофиксил
И в Clang такого рода баги тоже есть.
j123123,
29 Мая 2021
+1
_Return_type_success_(return != false) bool CEnumerateSerial::UsingCreateFile(_Inout_ CPortsArray& ports)
{
//Reset the output parameter
ports.clear();
//Up to 255 COM ports are supported so we iterate through all of them seeing
//if we can open them or if we fail to open them, get an access denied or general error error.
//Both of these cases indicate that there is a COM port at that number.
for (UINT i=1; i<256; i++)
{
//Form the Raw device name
ATL::CAtlString sPort;
sPort.Format(_T("\\\\.\\COM%u"), i);
//Try to open the port
bool bSuccess = false;
ATL::CHandle port(CreateFile(sPort, GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr));
if (port == INVALID_HANDLE_VALUE)
{
const DWORD dwError = GetLastError();
//Check to see if the error was because some other app had the port open or a general failure
if ((dwError == ERROR_ACCESS_DENIED) || (dwError == ERROR_GEN_FAILURE) || (dwError == ERROR_SHARING_VIOLATION) || (dwError == ERROR_SEM_TIMEOUT))
bSuccess = true;
}
else
{
//The port was opened successfully
bSuccess = true;
}
//Add the port number to the array which will be returned
if (bSuccess)
#pragma warning(suppress: 26489)
ports.push_back(i);
}
//Return the success indicator
return true;
}
некоторые джавамэны вот таким гордятся
> Internally the code provides 10 different ways (yes you read that right: Ten)
еще и выложено под ни с чем не совместимой лицензией
gologub,
23 Мая 2021
0
(((UU)M[(((UU)c&255)<<16)+(UU)((U)(a+2))])<<8)+\
((UU)M[(((UU)c&255)<<16)+(UU)((U)(a+3))])\
)
#define write_byte(v,d)M[d]=v;
#define write_2bytes(v,d) M[d]= (v)>>8;\
M[((d)+1)&0xFFffFF]= (v)&255;
#define write_4bytes(v,d) M[((d))&0xFFffFF]= (v)>>24;\
M[((d)+1)&0xFFffFF]= (v)>>16;\
M[((d)+2)&0xFFffFF]= (v)>>8;\
M[((d)+3)&0xFFffFF]= (v)&255;
#define D ;switch(CONSUME_BYTE){k 0:goto G_HALT;k 1:goto G_LDA;k 2:goto G_LA;k 3:goto G_LDB;k 4:goto G_LB;k 5:goto G_SC;k 6:goto G_STA;k 7:goto G_STB;\
k 8:goto G_ADD;k 9:goto G_SUB;k 10:goto G_MUL;k 11:goto G_DIV;k 12:goto G_MOD;k 13:goto G_CMP;k 14:goto G_JMPIFEQ;k 15:goto G_JMPIFNEQ;\
k 16:goto G_GETCHAR;k 17:goto G_PUTCHAR;k 18:goto G_AND;k 19:goto G_OR;k 20:goto G_XOR;k 21:goto G_LSHIFT;k 22:goto G_RSHIFT;k 23:goto G_ILDA;\
k 24:goto G_ILDB;k 25:goto G_CAB;k 26:goto G_AB;k 27:goto G_BA;k 28:goto G_ALC;k 29:goto G_AHC;k 30:goto G_NOP;k 31:goto G_CBA;\
k 32:goto G_LLA;k 33:goto G_ILLDA;k 34:goto G_LLB;k 35:goto G_ILLDB;k 36:goto G_ILLDAA;k 37:goto G_ILLDBB;k 38:goto G_ILLDAB;k 39:goto G_ILLDBA;\
k 40:goto G_CA;k 41:goto G_CB;k 42:goto G_AC;k 43:goto G_BC;k 44:goto G_ISTA;k 45:goto G_ISTB;k 46:goto G_ISTLA;k 47:goto G_ISTLB;\
k 48:goto G_JMP;k 49:goto G_STLA;k 50:goto G_STLB;k 51:goto G_STC;k 52:goto G_PUSH;k 53:goto G_POP;k 54:goto G_PUSHA;k 55:goto G_POPA;\
k 56:goto G_ASTP;k 57:goto G_BSTP;k 58:goto G_COMPL;k 59:goto G_CPC;k 60:goto G_CALL;k 61:goto G_RET;k 62:goto G_FARILLDA;k 63:goto G_FARISTLA;\
k 64:goto G_FARILLDB;k 65:goto G_FARISTLB;k 66:goto G_FARPAGEL;k 67:goto G_FARPAGEST;k 68:goto G_LFARPC;k 69:goto G_FARCALL;k 70:goto G_FARRET;k 71:goto G_FARILDA;\
k 72:goto G_FARISTA;k 73:goto G_FARILDB;k 74:goto G_FARISTB;\
k 75:goto TB;k 76:goto TC;k 77:goto TD;k 78:goto TE;k 79:goto TF;\
k 80:goto U0;k 81:goto U1;k 82:goto U2;k 83:goto U3;k 84:goto U4;k 85:goto U5;k 86:goto U6;k 87:goto U7;\
k 88:goto U8;k 89:goto U9;k 90:goto UA;k 91:\
goto G_ALPUSH;k 92:goto G_BLPUSH;k 93:goto G_CPUSH;k 94:goto G_APUSH;k 95:goto G_BPUSH;\
k 96:goto G_ALPOP;k 97:goto G_BLPOP;k 98:goto G_CPOP;k 99:goto G_APOP;k 100:goto G_BPOP;\
k 101:goto G_INTERRUPT;k 102:goto G_CLOCK;\
k 103:goto G_ARX0;\
k 104:goto G_BRX0;k 105:goto V9;k 106:goto VA;k 107:goto VB;k 108:goto VC;k 109:goto VD;k 110:goto VE;k 111:goto VF;\
k 112:goto W0;k 113:goto W1;k 114:goto W2;k 115:goto W3;k 116:goto W4;k 117:goto W5;k 118:goto W6;k 119:goto W7;\
k 120:goto W8;k 121:goto W9;k 122:goto WA;k 123:goto WB;k 124:goto WC;k 125:goto WD;k 126:goto WE;\
k 127:goto WF;\
k 128:goto X0;k 129:goto X1;k 130:goto X2;k 131:goto X3;k 132:goto X4;\
k 133:goto X5;k 134:goto X6;k 135:goto X7;k 136:goto X8;k 137:goto X9;\
k 138:goto XA;k 139:goto XB;k 140:goto XC;k 141:goto XD;k 142:goto XE;k 143:goto XF;\
k 144:goto Y0;k 145:goto Y1;k 146:goto Y2;k 147:goto Y3;\
k 148:goto Y4;k 149:goto Y5;k 150:goto Y6;k 151:goto Y7;k 152:goto Y8;k 153:goto Y9;\
k 154:goto YA;k 155:goto YB;k 156:goto YC;k 157:goto YD;\
k 158:goto YE;k 159:goto YF;\
k 160:goto Z0;k 161:goto Z1;k 162:goto Z2;k 163:goto Z3;\
k 164:goto Z4;k 165:goto Z5;k 166:goto Z6;k 167:goto Z7;\
k 168:goto Z8;k 169:goto Z9;k 170:goto ZA;\
k 171:k 172:k 173:k 174:k 175:k 176:k 177:\
k 178:k 179:k 180:k 181:k 182:k 183:k 184:k 185:k 186:k 187:\
k 188:k 189:k 190:k 191:k 192:k 193:k 194:k 195:k 196:k 197:\
k 198:k 199:k 200:k 201:k 202:k 203:k 204:k 205:k 206:k 207:\
k 208:k 209:k 210:k 211:k 212:k 213:k 214:k 215:k 216:k 217:\
k 218:k 219:k 220:k 221:k 222:k 223:k 224:k 225:k 226:k 227:\
k 228:k 229:k 230:k 231:k 232:k 233:k 234:k 235:k 236:k 237:\
k 238:k 239:k 240:k 241:k 242:k 243:k 244:k 245:k 246:k 247:\
k 248:k 249:k 250:k 251:k 252:k 253:k 254:k 255:goto G_NOP;}
int e(){
register u program_counter_region=0;register U a=0,b=0,c=0,program_counter=0,stack_pointer=0;
register UU RX0=0,RX1=0,RX2=0,RX3=0;R=0;di();
G_NOP:D
G_HALT:dcl();return 0;
G_AND:a&=b;D
G_OR:a|=b;D
G_XOR:a^=b;D
G_GETCHAR:a=gch()D
G_PUTCHAR:pch(a)D
G_LSHIFT:a<<=b&15;D
G_RSHIFT:a>>=b&15;D
G_ILDA:a=r(c)D
G_ILDB:b=r(c)D
G_CAB:c=((a&255)<<8)+(b&255)D
G_AB:a=b;D
G_BA:b=a;D
G_ALC:a=c&0xff;D
G_AHC:a=(c>>8)&255;D
G_CBA:c=((b&255)<<8)+(a&255)D
G_LLA:a=CONSUME_TWO_BYTES;D
G_ILLDA:a=Z_READ_TWO_BYTES_THROUGH_C;DI'm back with more ogvnokod!
jangolare,
19 Мая 2021
0
struct X {
int x;
int y;
X(int y_) :
y(y_),
x(y + 10)
{
}
};
int main()
{
X foo = X(16);
std::cout << "foo == (" << foo.x << ", " << foo.y << ")" << std::endl;
}
PolinaAksenova,
12 Мая 2021
0
// Приведение численного типа к структуре с битовыми полями
template <class STRUCT_T, typename T>
STRUCT_T struct_cast(const T n)
{
static_assert(std::is_integral<T>::value, "Integral type required as T");
static_assert(std::is_class<STRUCT_T>::value, "class or struct type required as STRUCT_T");
static_assert(sizeof(T) == sizeof(STRUCT_T), "Incompatible types passed");
return *(reinterpret_cast<const STRUCT_T*>(&n));
}
// Приведение структур с битовыми полями к численному типу
template <typename T, class STRUCT_T>
T integral_cast(const STRUCT_T& s)
{
static_assert(std::is_integral<T>::value, "Integral type required as T");
static_assert(std::is_class<STRUCT_T>::value, "class or struct type required as STRUCT_T");
static_assert(sizeof(T) == sizeof(STRUCT_T), "Incompatible types passed");
return *(reinterpret_cast<const T*>(&s));
}Почему это UB?
YpaHeLI_,
12 Мая 2021
0
Нужно реализовать thread-safe set.
На сколько нормально разбить сет на N бакетов (по хешу, условно, 10000 штук),
тогда при добавлении или удалении элемента делать лок соответствующего бакета
Но будет хуево, когда пойдут запросы по одному ключу в нескольких тредах.
Есть решение лучше?
3_dar,
12 Мая 2021
+2
template<typename F, typename... CurryArgs>
struct curry {
F func;
std::tuple<CurryArgs...> tup{};
curry(F f) : func(std::move(f)) {}
template<typename... CtorArgs>
curry(F f, CtorArgs &&... args) : func(std::move(f)), tup(std::forward<CtorArgs>(args)...) {}
template<typename Tup1, typename Tup2>
curry(F f, Tup1 && tup1, Tup2 && tup2) : func(std::move(f)), tup(std::tuple_cat(tup1, tup2)) {}
template<typename... Args>
auto operator()(Args &&... args)
{
constexpr size_t have_args = sizeof...(Args) + sizeof...(CurryArgs);
constexpr size_t need_args = detail::functor_traits<F>::args_count;
if constexpr (have_args > need_args) {
static_assert(!sizeof(std::tuple_element_t<0, std::tuple<Args...>>*),
"Too many arguments.");
} else if constexpr (have_args == need_args) {
return std::apply(func, std::tuple_cat(tup, std::tuple(std::forward<Args>(args)...)));
} else {
return curry<decltype(func), CurryArgs..., Args...>(func, tup, std::tuple(std::forward<Args>(args)...));
}
}
};
int main()
{
auto f = [](int a, float b, const std::string & c) -> int {
std::cout << "Functor! a = " << a << ", b = " << b << ", c = " << c << std::endl;
return a + static_cast<int>(b);
};
std::cout << f(16, 42.1f, "Hello") << std::endl;
auto c0 = curry(f);
auto c1 = c0(16);
auto c2 = c1(42.1f);
c0(16)(42.1f)("Hello");
c1(42.1f)("Hello");
c2("Hello");
c0(16, 42.1f)("Hello");
c0(16, 42.1f, "Hello");
c1(42.1f, "Hello");
}
Каррировали-каррировали, да выкаррировали.
https://wandbox.org/permlink/LPXFUNpWOREcB3wH
PolinaAksenova,
10 Мая 2021
+1
if constexpr (BusMode::BLOCKING == mode) {
derived()->send_block(arr, num);
} else if (BusMode::IT == mode){
derived()->send_it(arr, num);
} else if (BusMode::DMA == mode){
derived()->send_dma(arr, num);
}
https://habr.com/ru/post/556144/
> Отладочный вывод на микроконтроллерах: как Concepts и Ranges отправили мой printf на покой
Стреляем себе в ногу при помощи if constexpr.
PolinaAksenova,
10 Мая 2021
Follow us!