Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
Всего: 246
−3
#define m_from(format) \
char buff[128]; \
sprintf(buff, format, value); \
data_ = std::string(buff);
inline void fromShort(short value)
{
m_from("%i");
}
inline void fromInt(int value)
{
m_from("%i");
}
inline void fromLong(long value)
{
m_from("%li");
}
inline void fromFloat(float value)
{
m_from("%f");
}
inline void fromDouble(double value)
{
m_from("%f");
}
https://github.com/FlightBlaze/Newtoo/blob/master/modules/misc/USVString.h
Собственно, занесения в аналы ГК достоин весь этот класс целиком.
gost,
01 Октября 2018
−7
/*
Newtoo — разработка полноценного браузерного движка с нуля в 2018?
Так уж получилось, что в мире есть всего 4 популярных браузерных движка,
которые настолько сложны, что сами разработчики не знают и половины их
кодовой базы, и настолько продвинутые по технологиям, что начать их догонять —
пустая трата времени.
А так ли это на самом деле? Мой проект создан, чтобы повторить подвиги
современных браузерных движков и проверить, насколько ли реально создать
достойную альтернативу крупным проектам, история которых начинается с
девяностых годов. Мой новый движок создается с нуля, а значит его история
начинается — сегодня.
...
Те ошибки, которые были допущены на начальных стадиях разработки
остаются в проекте до конца. Самый яркий пример этому — умные
указатели в C++ — это еще более сложный синтаксис, большой оверхед
при работе, создании и удалении умных указателей. Кроме того, есть
очень много типов умных указателей и нужно знать, какой когда использовать,
ведь у каждого есть свои сюрпризы ньюансы. Посмотрите на этот файл из
WebKit. Когда видишь такой код, синтаксис умных указателей, пытаешься
успокоится и дышать ровно, но такого рода код — это весь вебкит с ног до
головы. В моем движке нет таких недостатков.
*/
Node* NodeListControlled::insertAt(unsigned long index, Node* child)
{
// mControl == vector<Node*>
mControl.insert(mControl.begin() + index, child);
return child;
}
Дело Попова, Бабушкина и иже с ними живёт!
У умных указателей оверхед большой, а вот List со вставкой за O(n) — это не недостаток, это фича.
А ещё там NamedNodeMap с тем же линейным поиском и практически полное игнорирование
передачи по ссылке — компилятор умный, авось, заоптимизирует как-нибудь.
https://sohabr.net/habr/post/424881/
https://github.com/FlightBlaze/Newtoo
gost,
01 Октября 2018
−1
class MyBigClass
{
var $allocatedSize;
var $allMyOtherStuff;
}
function AllocateMyBigClass()
{
$before = memory_get_usage();
$ret = new MyBigClass;
$after = memory_get_usage();
$ret->allocatedSize = ($after - $before);
return $ret;
}
Зачем нам в языке адекватный sizeof, у нас нет времени, чтобы ебаться с ним!
Подробнее: https://stackoverflow.com/questions/1351855/getting-size-in-memory-of-an-object-in-php
gost,
25 Сентября 2018
+1
/**
* Cast an object into a different class.
*
* Currently this only supports casting DOWN the inheritance chain,
* that is, an object may only be cast into a class if that class
* is a descendant of the object's current class.
*
* This is mostly to avoid potentially losing data by casting across
* incompatable classes.
*
* @param object $object The object to cast.
* @param string $class The class to cast the object into.
* @return object
*/
function cast($object, $class) {
if( !is_object($object) )
throw new InvalidArgumentException('$object must be an object.');
if( !is_string($class) )
throw new InvalidArgumentException('$class must be a string.');
if( !class_exists($class) )
throw new InvalidArgumentException(sprintf('Unknown class: %s.', $class));
if( !is_subclass_of($class, get_class($object)) )
throw new InvalidArgumentException(sprintf(
'%s is not a descendant of $object class: %s.',
$class, get_class($object)
));
/**
* This is a beautifully ugly hack.
*
* First, we serialize our object, which turns it into a string, allowing
* us to muck about with it using standard string manipulation methods.
*
* Then, we use preg_replace to change it's defined type to the class
* we're casting it to, and then serialize the string back into an
* object.
*/
return unserialize(
preg_replace(
'/^O:\d+:"[^"]++"/',
'O:'.strlen($class).':"'.$class.'"',
serialize($object)
)
);
}Это прекрасно.
gost,
25 Сентября 2018
0
#include <iostream>
#include <algorithm>
#include <functional>
#include <map>
#include <string>
int main()
{
using namespace std::placeholders;
std::map<std::string, int> karta;
std::vector<std::string> goroda{ "foo", "bar", "foo" };
std::for_each(goroda.begin(), goroda.end(), std::bind(
static_cast<
std::pair<decltype(karta)::iterator, bool>
(decltype(karta)::*)(const decltype(karta)::key_type&, decltype(karta)::mapped_type&&)>
(&decltype(karta)::insert_or_assign),
std::ref(karta),
_1,
std::bind(
std::plus<decltype(karta)::mapped_type>(),
1,
std::bind(
static_cast<decltype(karta)::mapped_type&(decltype(karta)::*)(const decltype(karta)::key_type &)>
(&decltype(karta)::operator[]),
std::ref(karta),
_1))
));
std::cout << "foo: " << karta["foo"] << "\nbar: " << karta["bar"] << '\n';
return EXIT_SUCCESS;
}
#24802, переписанный в функциональном modern C++ стиле.
Переделать бы ещё это под итераторы, чтобы двух обращений к мапе не было…
gost,
24 Сентября 2018
0
// CVE-2012-5692
/* 4015. */ static public function get($name)
/* 4016. */ {
/* 4017. */ // Check internal data first
/* 4018. */ if ( isset( self::$_cookiesSet[ $name ] ) )
/* 4019. */ {
/* 4020. */ return self::$_cookiesSet[ $name ];
/* 4021. */ }
/* 4022. */ else if ( isset( $_COOKIE[ipsRegistry::$settings['cookie_id'].$name] ) )
/* 4023. */ {
/* 4024. */ $_value = $_COOKIE[ ipsRegistry::$settings['cookie_id'].$name ];
/* 4025. */
/* 4026. */ if ( substr( $_value, 0, 2 ) == 'a:' )
/* 4027. */ {
/* 4028. */ return unserialize( stripslashes( urldecode( $_value ) ) );
/* 4029. */ }
/*
The vulnerability is caused due to this method unserialize user input passed through cookies without a proper
sanitization. The only one check is done at line 4026, where is controlled that the serialized string starts
with 'a:', but this is not sufficient to prevent a "PHP Object Injection" because an attacker may send a
serialized string which represents an array of objects. This can be exploited to execute arbitrary PHP code
via the "__destruct()" method of the "dbMain" class, which calls the "writeDebugLog" method to write debug
info into a file. PHP code may be injected only through the $_SERVER['QUERY_STRING'] variable, for this
reason successful exploitation of this vulnerability requires short_open_tag to be enabled.
*/
Если вы думаете, что самое плохое, что ждёт ваш уютный сайт на «PHP» — это Роберт-брось-таблицу, то вы глубоко ошибаетесь.
CSRF verification passed.
gost,
23 Сентября 2018
−2
NTSTATUS resize(size_t new_capacity)
{
NT_ASSERT(new_capacity >= m_size);
if constexpr (std::is_pod_v<T>) {
T *new_array = static_cast<T*>(KReallocate(m_size, new_capacity, sizeof(T), m_array, POOL, TAG));
if (!new_array) {
return STATUS_NO_MEMORY;
}
m_capacity = new_capacity;
m_array = new_array;
} else {
T *new_array = static_cast<T*>(KAllocate(new_capacity, sizeof(T), POOL, TAG));
if (!new_array) {
return STATUS_NO_MEMORY;
}
for (size_t i = 0; i < m_size; i++) {
new (&new_array[i]) T(std::move(m_array[i]));
m_array[i].~T();
}
KmdfDeallocate(m_array, TAG);
m_capacity = new_capacity;
m_array = new_array;
}
return STATUS_SUCCESS;
}
gost,
17 Сентября 2018
+1
#include <iostream>
#include <type_traits>
#include <utility>
#include <array>
template<size_t Size, typename T, typename FunctorType, size_t... idx>
constexpr std::array<decltype(std::declval<FunctorType>().operator()(std::declval<T>())), Size>
map_impl(const std::array<T, Size> & arr, FunctorType && f, std::index_sequence<idx...>)
{
return std::array{ f(std::get<idx>(arr))... };
}
template<size_t Size, typename T, typename FunctorType>
constexpr std::array<decltype(std::declval<FunctorType>().operator()(std::declval<T>())), Size>
map(const std::array<T, Size> & arr, FunctorType && f)
{
return map_impl(arr, f, std::make_index_sequence<Size>{});
}
struct MyFunctor {
constexpr float operator()(int arg)
{
return static_cast<float>(arg * arg) / 2.0f;
}
};
int main()
{
constexpr std::array arr{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
auto arrMappedFunctor = map(arr, MyFunctor{});
auto arrMappedLambda = map(arr, [](int x) constexpr { return static_cast<float>(x * x) / 2.0f; });
for (auto && x : arrMappedFunctor) {
std::cout << x << ' ';
}
std::cout << std::endl;
for (auto && x : arrMappedLambda ) {
std::cout << x << ' ';
}
std::cout << std::endl;
return 0;
}
0.5 2 4.5 8 12.5 18 24.5 32 40.5 50
0.5 2 4.5 8 12.5 18 24.5 32 40.5 50
Метушня выходит на новый уровень: полноценный map в compile-time. Поддерживает как ручные функторы с перегруженным operator(), так и constexpr-лямбды. При помощи небольшой модификации возможно реализовать поддержку кортежей с произвольными типами.
gost,
18 Августа 2018
0
inline constexpr size_t hardware_destructive_interference_size = implementation-defined;
This number is the minimum recommended offset between two concurrently-accessed objects to avoid
additional performance degradation due to contention introduced by the implementation.
Бля, пиздец. Модулей нет, строк нет, а комитет мутит какую-то хуиту космической глупости.
gost,
12 Августа 2018
+2
#include <iostream>
#include <string>
int main()
{
std::string s1 = "";
const char s2[] = "";
std::cout << std::boolalpha
<< std::empty(s1) << std::endl
<< std::size(s1) << std::endl
<< std::empty(s2) << std::endl
<< std::size(s2) << std::endl;
s1.assign("", 1);
std::cout << std::empty(s1) << std::endl
<< std::size(s1) << std::endl;
system("pause");
return 0;
}
true
0
false
1
false
1
Ой-вэй, абстракции потекли!
gost,
11 Августа 2018
Follow us!