Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+1
QSqlQuery& SQLConnect::get()
{
if ( makeConnection() ) {
query = QSqlQuery(mDb);
return query;
}
QSqlQuery empty;
return empty;
}
bool SQLConnect::makeConnection()
{
mDb = SQLConnectPool::Instance().get();
return true;
}Раньше компилилось и не замечал, а тут на новом компиляторе начал кидать ошибки и решил посмотреть, что же там напроектировали
avk17,
14 Августа 2021
+1
class Solution {
public:
std::vector<std::vector<int>> diagonalSort(std::vector<std::vector<int>> & mat) {
if (!mat.size()) return mat;
const size_t rl = mat[0].size();
const size_t cl = mat.size();
sort(mat, rl, cl, 0, 0);
for (size_t i = 1; i < rl; ++i) {
sort(mat, rl, cl, 0, i);
}
for (size_t i = 1; i < cl; ++i) {
sort(mat, rl, cl, i, 0);
}
return mat;
}
private:
void sort(std::vector<std::vector<int>> & mat, size_t rl, size_t cl, size_t i, size_t j) {
const size_t len = std::min(rl - j, cl - i);
const size_t endj = j + len;
const size_t endi = i + len;
std::sort(diag_iter<false>{&mat, i, j}, diag_iter<false>{&mat, endi, endj});
}
template <bool isConst>
class diag_iter {
std::vector<std::vector<int>> *base;
size_t i, j;
using T = int;
public:
using iterator_category = std::forward_iterator_tag;
using difference_type = std::ptrdiff_t;
using value_type = T;
using pointer = T*;
using reference = typename std::conditional<isConst, const T&, T&>::type;
diag_iter(std::vector<std::vector<int>> *base, size_t i, size_t j) : base(base), i(i), j(j) { }
diag_iter(const diag_iter&) = default;
diag_iter& operator=(const diag_iter&) = default;
~diag_iter() = default;
reference operator*() const { return (*base)[i][j]; }
diag_iter& operator++() { i++; j++; return *this; }
friend bool operator== (const diag_iter& a, const diag_iter& b) { return a.i == b.i && a.j == b.j; };
friend bool operator!= (const diag_iter& a, const diag_iter& b) { return !(a == b); };
pointer operator->() const { return &(this->operator*()); }
diag_iter operator++(int) { diag_iter tmp = *this; ++(*this); return tmp; }
diag_iter() = default;
diag_iter& operator--() { i--; j--; return *this; }
diag_iter operator--(int) { diag_iter tmp = *this; --(*this); return tmp; }
diag_iter& operator+=(difference_type n) { i += n; j += n; return *this; }
friend diag_iter operator+(diag_iter it, difference_type n) { return it += n; }
diag_iter& operator-=(difference_type n) { i -= n; j -= n; return *this; }
diag_iter operator-(difference_type n) const { return diag_iter(*this) -= n; }
friend difference_type operator-(const diag_iter& a, const diag_iter& b) { return (b.j * b.base->size() + b.i) - (a.j * a.base->size() + a.i); }
reference operator[](difference_type n) const { return *(*this + n); }
friend bool operator<(const diag_iter& a, const diag_iter& b) { return b - a > 0; }
friend bool operator>(const diag_iter& a, const diag_iter& b) { return b < a; }
friend bool operator>=(const diag_iter& a, const diag_iter& b) { return !(a < b); }
friend bool operator<=(const diag_iter& a, const diag_iter& b) { return !(a > b); }
};
};
https://leetcode.com/problems/sort-the-matrix-diagonally/
Сортировка через итераторы оказалась примерно в три раза медленнее, чем через копирование в вектор, сортировку его и копирование обратно.
grillow1337,
25 Июля 2021
+1
#include <iostream>
#include <functional>
#define STD_FUNCTION(a, ...) typeof( a (*) __VA_ARGS__ )
template<typename T>
T do_op_t(T a, T b, STD_FUNCTION(T,(T,T)) op)
{
return op(a,b);
}
template
<
typename T,
STD_FUNCTION(
T,
(
T,T,
STD_FUNCTION(
T,
(T,T)
)
)
) F1,
STD_FUNCTION(
T,
(T,T)
) F2
>
T do_op_spec(T a, T b)
{
return F1(a, b, F2);
}
int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
std::function<int(int,int)> fnc = \
do_op_spec\
<
int,
do_op_t<int>,
add
>;
int main()
{
std::cout << do_op_t<int>(9, 9, add) << "\n";
std::cout << do_op_t<int>(9, 9, mul) << "\n";
std::cout << do_op_spec<int, do_op_t<int>,add>(9,9) << "\n";
std::cout << do_op_spec<int, do_op_t<int>,mul>(9,9) << "\n";
std::cout << fnc(9,9) << "\n";
}Какая крестопараша )))
j123123,
23 Июля 2021
+1
// https://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/global/qglobal.h?h=v5.13.1#n1017
#if __cplusplus >= 201703L
// Use C++17 if statement with initializer. User's code ends up in a else so
// scoping of different ifs is not broken
#define Q_FOREACH(variable, container) \
for (auto _container_ = QtPrivate::qMakeForeachContainer(container); \
_container_.i != _container_.e; ++_container_.i) \
if (variable = *_container_.i; false) {} else
#else
// Explanation of the control word:
// - it's initialized to 1
// - that means both the inner and outer loops start
// - if there were no breaks, at the end of the inner loop, it's set to 0, which
// causes it to exit (the inner loop is run exactly once)
// - at the end of the outer loop, it's inverted, so it becomes 1 again, allowing
// the outer loop to continue executing
// - if there was a break inside the inner loop, it will exit with control still
// set to 1; in that case, the outer loop will invert it to 0 and will exit too
#define Q_FOREACH(variable, container) \
for (auto _container_ = QtPrivate::qMakeForeachContainer(container); \
_container_.control && _container_.i != _container_.e; \
++_container_.i, _container_.control ^= 1) \
for (variable = *_container_.i; _container_.control; _container_.control = 0)
#endifА можно ли свой foreach сделать через какую-нибудь шаблонопарашу? Или тут, как обычно, нужна гомоиконность?
j123123,
28 Июня 2021
+5
#include <unistd.h>
#include <stdio.h>
#include <limits.h>
template<size_t Size> struct static_string {char data[Size];};
template<size_t ... Indexes>struct index_sequence {};
template<size_t Size, size_t ... Indexes>
constexpr static_string<sizeof ... (Indexes) + 1> make_static_string(const static_string<Size>& str,index_sequence<Indexes ...>) {return {str.data[Indexes] ..., '\0'};}
constexpr static_string<1> make_static_string() {return {'\0'};}
template<size_t Size, size_t ... Indexes>
struct make_index_sequence : make_index_sequence<Size - 1, Size - 1, Indexes ...> {};
template<size_t Size>
constexpr static_string<Size> make_static_string(const char (& str)[Size]) {return make_static_string(str, make_index_sequence<Size - 1>{});}
template<size_t ... Indexes>
struct make_index_sequence<0, Indexes ...> : index_sequence<Indexes ...> {};
template<size_t Size, size_t ... Indexes>
constexpr static_string<sizeof ... (Indexes) + 1> make_static_string(const char (& str)[Size],index_sequence<Indexes ...>) {return {str[Indexes] ..., '\0'};}
template<size_t Size>
constexpr size_t static_string_find(const static_string<Size>& str, char ch, size_t from, size_t nth) {return Size < 2 || from >= Size - 1 ? UINT_MAX :str.data[from] != ch ? static_string_find(str, ch, from + 1, nth) :nth > 0 ? static_string_find(str, ch, from + 1, nth - 1) : from;}
template<size_t Size>
constexpr size_t static_string_find_0(const static_string<Size>& str, char ch, size_t from, size_t nth) {return Size < 2 || from >= Size - 1 ? 0 : str.data[from] != ch ? static_string_find_0(str, ch, from + 1, nth) :nth > 0 ? static_string_find(str, ch, from + 1, nth - 1) : from;}
template<size_t Size1, size_t ... Indexes1, size_t Size2, size_t ... Indexes2>
constexpr static_string<Size1 + Size2 - 1> static_string_concat_2(const static_string<Size1>& str1, index_sequence<Indexes1 ...>,const static_string<Size2>& str2, index_sequence<Indexes2 ...>) {return {str1.data[Indexes1] ..., str2.data[Indexes2] ..., '\0'};}
template<size_t Size1, size_t Size2>
constexpr static_string<Size1 + Size2 - 1> static_string_concat_2(const static_string<Size1>& str1, const static_string<Size2>& str2) {return static_string_concat_2(str1, make_index_sequence<Size1 - 1>{},str2, make_index_sequence<Size2 - 1>{});}
template<size_t Begin, size_t End, size_t ... Indexes>
struct make_index_subsequence : make_index_subsequence<Begin, End - 1, End - 1, Indexes ...> {};
template<size_t Pos, size_t ... Indexes>
struct make_index_subsequence<Pos, Pos, Indexes ...> : index_sequence<Indexes ...> {};
template<size_t Begin, size_t End, size_t Size>
constexpr static_string<End - Begin + 1> static_string_substring(const static_string<Size>& str) {return make_static_string(str, make_index_subsequence<Begin, End>{});}
template<size_t Begin, size_t Size>
constexpr static_string<Size - Begin> static_string_suffix(const static_string<Size>& str) {return static_string_substring<Begin, Size - 1>(str);}
#define remove_underscore(arg) ([] () __attribute__((always_inline)) {constexpr auto a = static_string_find(make_static_string(arg),'_',0,0) == UINT_MAX? make_static_string(arg):static_string_concat_2(static_string_concat_2(static_string_substring<0,static_string_find_0(make_static_string(arg),'_',0,0)>(make_static_string(arg)),static_string_suffix<static_string_find_0(make_static_string(arg),'_',0,0)+1>(make_static_string(arg))),make_static_string("\0"));return a;}().data)
int main()
{
puts(remove_underscore("_testtest"));
puts(remove_underscore("test_test"));
puts(remove_underscore("testtest_"));
}Убогий constexpr в c++11
mittorn,
25 Июня 2021
0
Game::Game()
{
run = true;//флаг признак нажатия кнопки выхода F5
Matrix = new int* [8];//Поле 64 ячейки - значения 0 - для пустой ячейки, для игрока каждая пешка-шашка от 1 до 9, для компьютера значения в матрице от 10 до 18
for (int i = 0; i < 8; i++)
Matrix[i] = new int[8];
//Квадраты координат нужны чтобы программа знала какие ячейки над указателем мыши, 64 квадрата
QuadCoorXleft = new int* [8];//каждой ячейки матрицы Matrix соответстует квадрат координат для мыши xleft означает левую координату x
QuadCoorXright = new int* [8];//xright - правая x
QuadCoorYdown = new int* [8];//верхняя y координата
QuadCoorYup = new int* [8];//нижняя y координата
for (int i = 0; i < 8; i++)
{
QuadCoorXleft[i] = new int[8];
QuadCoorXright[i] = new int[8];
QuadCoorYdown[i] = new int[8];
QuadCoorYup[i] = new int[8];
}
//Координаты пешек для отрисовки
ChessX = new double[18];//X
ChessY = new double[18];//Y
//Выделяемая пешка ее координаты и значения
ActiveX = -1;//X
ActiveY = -1;//Y
Active = -1;//Value
firstplayer = true;//флаг того что можете игрок 1й ходить
secondplayer = false;//флаг того что можете игрок 2й ходить
ai = new bool[18];//ячейки флаги того что пешка на финишной позиции
chessai tmp;
for (int i = 0; i < 18; i++)
{
ai[i] = false;
if (i > 8)
{
tmp.ai = ai[i];
tmp.value = i+1;
Ai.push_back(tmp);//Вектор с флагами финиша каждой пешки для искуственного интеллекта
}
}
aicountfirstrow = 0;//счетчик кол-ва пешек ИИ(искуственного интеллекта) на верхней строчке(0-я)
aicountsecondrow = 0;//счетчик кол-ва пешек ИИ на предверхней строчке(1-я)
aicountthirdrow = 0;//счетчик кол-ва пешек ИИ на предпредверхней строчке(2-я)
}
https://github.com/Beginerok/DominiGames/blob/master/Domini/Chess/Chess/Game.cpp
https://habr.com/ru/post/563398/
Странные шахматы как тестовое задание
PolinaAksenova,
18 Июня 2021
+3
//! Set this value as an empty object.
/*! \post IsObject() == true */
GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; }
Парсер json'ок писали сверхлюди
https://github.com/Tencent/rapidjson/blob/master/include/rapidjson/document.h#L1188
mvngr,
16 Июня 2021
+1
#include <iostream>
#include <map>
int main()
{
std::string name;
std::map<int, int> m = { {1, 1}, {2, 2} };
m.erase(m.end());
std::cout << "Kokoko " << m[1] << std::endl;
}На моем проекте уходит в бесконечный цикл.
YpaHeLI_,
08 Июня 2021
0
// https://llvm.org/doxygen/AArch64AddressingModes_8h_source.html#l00051
/// getShiftName - Get the string encoding for the shift type.
static inline const char *getShiftExtendName(AArch64_AM::ShiftExtendType ST) {
switch (ST) {
default: llvm_unreachable("unhandled shift type!");
case AArch64_AM::LSL: return "lsl";
case AArch64_AM::LSR: return "lsr";
case AArch64_AM::ASR: return "asr";
case AArch64_AM::ROR: return "ror";
case AArch64_AM::MSL: return "msl";
case AArch64_AM::UXTB: return "uxtb";
case AArch64_AM::UXTH: return "uxth";
case AArch64_AM::UXTW: return "uxtw";
case AArch64_AM::UXTX: return "uxtx";
case AArch64_AM::SXTB: return "sxtb";
case AArch64_AM::SXTH: return "sxth";
case AArch64_AM::SXTW: return "sxtw";
case AArch64_AM::SXTX: return "sxtx";
}
return nullptr;
}
Хорош ли тот язык, в котором такую херню надо писать?
Именно поэтому я за гомоиконы.
j123123,
06 Июня 2021
+1
#include <iostream>
using namespace std;
int main() {
const char *kakoiBagor = R""""(
"Какой
багор )))"
)"""";
cout << kakoiBagor << endl;
return 0;
}
А вы знали, что в C++ есть ХЕРЕДОК?
https://ideone.com/5KdJJQ
3_dar,
04 Июня 2021
Follow us!