Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
Всего: 338
0
https://www.reddit.com/r/cpp/comments/75gohf/i_just_found_a_use_for_the_poop_emoji_in_c/
запостить этот говнокод непосредственно сюда не представляется возможным из-за юникодного символа говна:
Application was halted by an exception.
Debug-mode is off.
I just found a use for the poop emoji in C++
This actually detects whether the Visual Studio project has the proper UTF-8 flags set to compile it correctly.
j123123,
16 Января 2018
0
http://shitcode.net/У говнокода появился конкурент
j123123,
15 Декабря 2017
+1
#include <experimental/coroutine>
#include <iostream>
#include <optional>
#include <utility>
template<typename T>
class Maybe
{
std::shared_ptr<std::optional<T>> m_maybe = std::make_shared<std::optional<T>>();
public:
Maybe() = default;
Maybe(const T& t)
: m_maybe { std::make_shared<std::optional<T>>(t) }
{
}
explicit operator bool() const { return static_cast<bool>(*m_maybe); }
T& operator* () { return **m_maybe; }
const T& operator*() const { return **m_maybe; }
void reset() { m_maybe->reset(); }
template<typename U>
void emplace(U&& u) { m_maybe->emplace(std::forward<U>(u)); }
};
template<typename T>
void printMaybe(const Maybe<T>& opt)
{
if (opt)
std::cout << *opt << std::endl;
else
std::cout << "<empty>" << std::endl;
}
template<typename T, typename... Args>
struct std::experimental::coroutine_traits<Maybe<T>, Args...>
{
struct promise_type
{
Maybe<T> m_maybe;
auto get_return_object() { return m_maybe; }
std::experimental::suspend_never initial_suspend() { return {}; }
std::experimental::suspend_never final_suspend() { return {}; }
void unhandled_exception() { m_maybe.reset(); }
template<typename U>
void return_value(U&& u) { m_maybe.emplace(std::forward<U>(u)); }
};
};
template<typename T>
auto operator co_await(const Maybe<T>& maybe)
{
struct Awaiter
{
const Maybe<T>& input;
bool await_ready() { return static_cast<bool>(input); }
auto await_resume() { return *input; }
void await_suspend(std::experimental::coroutine_handle<> coro) { coro.destroy(); }
};
return Awaiter { maybe };
}
Maybe<int> maybeAdd(const Maybe<int>& maybeA, const Maybe<int>& maybeB)
{
auto a = co_await maybeA;
auto b = co_await maybeB;
co_return a + b;
}
int main()
{
/*
printMaybe(maybeAdd({ 1 }, { 2 }));
printMaybe(maybeAdd({}, { 2 }));
printMaybe(maybeAdd({ 1 }, {}));
*/
const auto res = maybeAdd({ 1 }, { 2 });
return res ? *res : 0;
}do-нотация в плюсах
j123123,
07 Декабря 2017
−2
#define POLY 0x8408
/*
// 16 12 5
// this is the CCITT CRC 16 polynomial X + X + X + 1.
// This works out to be 0x1021, but the way the algorithm works
// lets us use 0x8408 (the reverse of the bit pattern). The high
// bit is always assumed to be set, thus we only use 16 bits to
// represent the 17 bit value.
*/
unsigned short crc16(unsigned char *data_p, size_t length)
{
unsigned char i;
unsigned int data;
if ( length == 0 ) return 0;
unsigned int crc = 0xFFFF;
do
{
data = *data_p++;
for ( i=0; i < 8; i++ )
{
if ( (crc ^ data) & 1 )
crc = (crc >> 1) ^ POLY;
else
crc >>= 1;
data >>= 1;
}
} while ( --length != 0 );
crc = ~crc;
data = crc;
crc = (crc << 8) | ((data >> 8) & 0xff);
return (unsigned short)(crc);
}Типичный пример непортабельной хуйни на Си.
j123123,
07 Декабря 2017
+2
https://shmat-razum.blogspot.com/2012/12/blog-post.html
Есть такое правило, к которому все привыкли: если в программе записано логическое выражение с and, и первое подвыражение оказалось равно false, то второе не вычисляется. Аналогично с or: если первое подвыражение равно true, второе не вычисляется. Это позволяет удобно записывать вещи вида
if (index < 0 || array[index] == NULL)
...if (index >= 0 && array[index] == ptr)
...
j123123,
15 Ноября 2017
0
https://webhamster.ru/mytetrashare/index/mtb0/1480776952mrczr7xk44Какие изменения предлагает инициативная группа стандарта C++!!, чтобы сделать язык C++ красивым, мощным и востребованным средством современной разработки?
j123123,
10 Ноября 2017
+1
// https://github.com/telegramdesktop/tdesktop/blob/5f5770dd46491133b135a71fc2d4f92d13107ade/Telegram/SourceFiles/history.cpp#L1455
int History::countUnread(MsgId upTo) {
int result = 0;
for (auto i = blocks.cend(), e = blocks.cbegin(); i != e;) {
--i;
for (auto j = (*i)->items.cend(), en = (*i)->items.cbegin(); j != en;) {
--j;
if ((*j)->id > 0 && (*j)->id <= upTo) {
break;
} else if (!(*j)->out() && (*j)->unread() && (*j)->id > upTo) {
++result;
}
}
}
return result;
}
void History::updateShowFrom() {
if (showFrom) return;
for (auto i = blocks.cend(); i != blocks.cbegin();) {
--i;
for (auto j = (*i)->items.cend(); j != (*i)->items.cbegin();) {
--j;
if ((*j)->id > 0 && (!(*j)->out() || !showFrom)) {
if ((*j)->id >= inboxReadBefore) {
showFrom = *j;
} else {
return;
}
}
}
}
}очередная порция говнеца из телесрамного клиента
j123123,
07 Ноября 2017
−7
Про убогость ООП подхода.
Итак, вот допустим наследование. Есть всякие там тупые примеры ООП, типа "котик и собачка наследуется от четырехногих" и проч., где подобный бред вполне работает. Но давайте попробуем рассмотреть более интересные ситуации.
Допустим что мы пишем некую игру. В игре есть некое оружие, например там есть огнестрел и дубинки. И мы делаем ружье, которое одновременно и огнестрел и дубинка, т.е. ружьем можно и как палкой уебать, и пальнуть как из револьвера. У родительского класса "огнестрел" есть свойства, типа дальности выстрела, точности, используемых боеприпасов, уровень прочности(износ), вес, наносимый урон при попадании. У дубинки есть свойства длины дубинки, уровень прочности(износ), вес, наносимый урон при ударе. Вес для ружья нам нужен только один, т.е. нет смысла делать два "веса" одному предмету. И огнестрел и дубинка наследуется от родительского класса "объект инвентаря", в общем тут ромбовидное наследование, которое в разных языках решается разными способами. Ну ок, допустим что мы там каким-то образом указали компилятору некоего языка X, что наследовать свойство "вес" надо лишь один единственный раз, как и прочие хрени, которые являются общими для родительского класса "объект инвентаря". Теперь надо решить с прочностью. Не все "объекты инвентаря" в этой игре имеют свойство прочности, есть например какие-то расходные материалы, типа патронов, для которых понятие прочности неприменимо. Использование ружья как дубинки изнашивает его не таким же самым образом, как использование ружья как огнестрела, но при этом слишком большой износ ружья-как-дубинки может настолько повредить его, что как огнестрел его уже и не поиспользовать из-за погнутого ствола. Но использование ружья как огнестрел никак на износ ружья-как-дубинки не влияет, типа это механический износ спускового механизма, износ ствола при стрельбе...
j123123,
02 Ноября 2017
+2
https://i.imgur.com/kMVofCA.png
ооооонейросетьоооотвечайрррооооооооооооооооооооооооооооооооооооооооооооооооввоооооооооооопо какому блядь принципу работает этот гугловский говнопереводчик?
j123123,
30 Октября 2017
0
https://github.com/TartanLlama/optional/blob/master/optional.hpp#L853
/// Constructs the stored value with `u`.
/// \synopsis template <class U=T> constexpr optional(U &&u);
template <
class U = T,
detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr,
detail::enable_forward_value<T, U> * = nullptr>
constexpr optional(U &&u) : base(in_place, std::forward<U>(u)) {}
/// \exclude
template <
class U = T,
detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr,
detail::enable_forward_value<T, U> * = nullptr>
constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u)) {}
/// Converting copy constructor.
/// \synopsis template <class U> optional(const optional<U> &rhs);
template <
class U, detail::enable_from_other<T, U, const U &> * = nullptr,
detail::enable_if_t<std::is_convertible<const U &, T>::value> * = nullptr>
optional(const optional<U> &rhs) {
this->m_has_value = true;
new (std::addressof(this->m_value)) T(*rhs);
}
/// \exclude
template <class U, detail::enable_from_other<T, U, const U &> * = nullptr,
detail::enable_if_t<!std::is_convertible<const U &, T>::value> * =
nullptr>
explicit optional(const optional<U> &rhs) {
this->m_has_value = true;
new (std::addressof(this->m_value)) T(*rhs);
}
/// Converting move constructor.
/// \synopsis template <class U> optional(optional<U> &&rhs);
template <
class U, detail::enable_from_other<T, U, U &&> * = nullptr,
detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr>
optional(optional<U> &&rhs) {
this->m_has_value = true;
new (std::addressof(this->m_value)) T(std::move(*rhs));
}
/// \exclude
template <
class U, detail::enable_from_other<T, U, U &&> * = nullptr,
detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr>
explicit optional(optional<U> &&rhs) {
this->m_has_value = true;
new (std::addressof(this->m_value)) T(std::move(*rhs));
}
Я даже не знаю, какой конкретно фрагмент этого творчества сюда выкладывать.
https://github.com/TartanLlama/optional C++11/14/17 std::optional with functional-style extensions https://optional.tartanllama.xyz
Вообще меня это забавляет, все эти костылепостроения поверх плюсов. Сделайте там уже возможность в компилтайме работать напрямую с исходным кодом самого себя, т.е. чтобы был некий код, который плюсокомпилятором в компилтайме обрабатывался, и чтобы он принимал исходник самого себя просто в виде тупо текста, и мог произвольно менять содержимое исходника на этапе компиляции (не меняя при этом сами файлы в файловой системе), и чтоб в качестве библиотек к этому компилтайм-метушению шел лексер-парсер плюсов.
Понятно что из плюсов никакого гомоиконного лиспа сделать не выйдет, ведь тогда надо выкинуть очень красивый и элегантный плюсосинтаксис вида std::kukarek(std:kudah<std:kokoko{kokoko ko[hui<govno>]}>:()[*huita]{}) и заменить его на бездуховные скобочки
j123123,
24 Октября 2017
Follow us!