Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+6
#define SET_VTYPE_AND_VARREF(type, val) \
this->vt = VT_ ## type | VT_BYREF; \
V_ ## type ## REF (this) = val;
TVariantT& operator=(System::Currency* src)
{
Clear();
if(src)
SET_VTYPE_AND_VARREF(CY,
reinterpret_cast<tagCY*>(&(src->Val)));
return* this;
}
Быдлер такой быдлер
стырено отсюда http://habrahabr.ru/company/pvs-studio/blog/179615/
govnomonad,
14 Мая 2013
+12
#include <iostream>
namespace dynamic {
template <class T> class scope;
template <class T> class variable {
public:
variable() : initial(0), current(&initial) {}
variable(const T &val) : initial(val, 0), current(&initial) {}
operator T() { return current->val; }
const T & operator = (const T & new_val) {
return current->val = new_val;
}
private:
struct node {
node(node *prev) : val(), prev(prev) {}
node(const T &val, node *prev) : val(val), prev(prev) {}
T val;
node *prev;
};
node initial;
node *current;
friend class scope<T>;
};
template <class T> class scope {
public:
scope(variable<T> &var) : var(var), node(var.current) {
var.current = &node;
}
scope(variable<T> &var, const T &val) : var(var), node(val, var.current) {
var.current = &node;
}
~scope() {
var.current = node.prev;
}
private:
variable<T> &var;
typename variable<T>::node node;
};
}
dynamic::variable<int> x(100500);
void foo() {
std::cout << x << std::endl;
}
void bar() {
dynamic::scope<int> x_(x, 42);
foo();
x = 265;
foo();
}
int main() {
foo();
bar();
foo();
return 0;
}
Навеяно http://govnokod.ru/12993.
https://ideone.com/7AA33Q
bormand,
14 Мая 2013
+20
#include <iostream>
#include <cstring>
const char tag[] = "Secret tag!";
const size_t tagSize = sizeof(tag);
const size_t nameSize = 32;
template<class T>
struct Value
{
Value(const char* name, const T& data) :
data(data)
{
std::strncpy(this->tag, ::tag, tagSize);
std::strncpy(this->name, name, nameSize);
}
char tag[tagSize];
char name[nameSize];
T data;
};
int getStackDir()
{
char a;
char b;
return &b > &a ? 1 : -1;
}
template<class T>
T getValue(const char* name)
{
static const size_t stackSize = 1024 * 1024;
const int stackDir = getStackDir();
char begin;
for(char* p = &begin, *end = &begin - stackSize * stackDir; p != end; p -= stackDir)
{
Value<T>* value = (Value<T>*)p;
if(std::strcmp(value->tag, tag) != 0) continue;
if(std::strcmp(value->name, name) != 0) continue;
return value->data;
}
return T();
}
#define SET(type, name, value) Value<type> name(#name, value)
#define GET(type, name) getValue<type>(#name)
//-----------------------------------------------------------
void test()
{
std::cout << GET(int, x) << std::endl;
}
int main()
{
SET(int, x, 13);
test();
}Отсюда http://www.rsdn.ru/forum/cpp/5163916.flat#5163916
Artur,
13 Мая 2013
+22
// поверка наличия указазанного флага в набора флагов
bool __fastcall TfrmFieldsEditor::HasFlag(int nAFlag, int nAFlagsCollection)
{
bool bRetVal = false;
std::bitset<8> bsFlagBits;
bsFlagBits.reset();
bsFlagBits = nAFlagsCollection;
int nBitsCount = bsFlagBits.size();
for(int i= 0 ; i < nBitsCount; ++i)
{
if(bsFlagBits[i]==1)
{
bsFlagBits.reset();
bsFlagBits[i] = 1;
if (bsFlagBits.to_ulong() == nAFlag)
{
bRetVal = true;
break;
}
else
bsFlagBits = nAFlagsCollection;
}
}
return bRetVal;
}
Ulysses,
13 Мая 2013
+16
try
{
Application->Initialize();
}
catch (...)
{
try
{
throw Exception("");
}
catch (Exception &exception)
{
Application->ShowException(&exception);
}
}Найдено в проекте написанном на Borland C++Builder :)
_Ru55_,
08 Мая 2013
+13
bool[] Inmask;
....
private void discreteOIForm_Load(object sender, EventArgs e)
{
if (icpI_measure.Connect() && icpO_measure.Connect())
{
Inmask = new bool[1];
Inmask[Convert.ToInt32(0)] = true;
}
}Новоприбывший сотрудник откладывает вот такое. Это он сделал после совета использовать маски. Вы когда-нибудь видели массив из одного элемента? Я тоже нет.
phys-tech,
07 Мая 2013
+10
static int
_S_compare(size_type __n1, size_type __n2)
{
const difference_type __d = difference_type(__n1 - __n2);
if (__d > __gnu_cxx::__numeric_traits<int>::__max)
return __gnu_cxx::__numeric_traits<int>::__max;
else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
return __gnu_cxx::__numeric_traits<int>::__min;
else
return int(__d);
}
LispGovno,
01 Мая 2013
+13
struct read_access_tag {};
struct write_access_tag {};
struct read_write_access_tag : read_access_tag, write_access_tag {};
template <
typename ByteOrder,
typename ValueType
>
std::size_t get_from(const uint8_t *src, ValueType &dst, const read_access_tag&) {
ByteOrder::decode(src, dst);
return sizeof(dst);
}
template <
typename ByteOrder,
typename ValueType
>
std::size_t put_into(ValueType src, uint8_t *dst, const write_access_tag&) {
ByteOrder::encode(src, dst);
return sizeof(src);
}
// ...
template <
typename ByteOrder = default_byte_order,
typename AccessTag = read_write_access_tag
>
class basic_buffer {
public:
typedef ByteOrder byte_order;
typedef AccessTag access_tag;
typedef typename access_traits<access_tag>::value_type value_type;
typedef typename access_traits<access_tag>::strict_type strict_type;
typedef typename access_traits<access_tag>::iterator iterator;
typedef typename access_traits<access_tag>::const_iterator const_iterator;
basic_buffer(iterator begin, iterator end)
: begin_(begin)
, end_(end)
, pos_(begin)
{}
// ...
template <typename T>
basic_buffer & put(T value) {
if (bytes_left() < sizeof(value)) throw Overflow;
pos_ += put_into<byte_order>(value, pos_, access_tag());
return *this;
}
template <typename T>
basic_buffer & get(T &value) {
if (bytes_left() < sizeof(value)) throw Overflow;
pos_ += get_from<byte_order>(pos_, value, access_tag());
return *this;
}
}Развитие идей из
http://govnokod.ru/12465https://github.com/roman-kashitsyn/encoding-binary
roman-kashitsyn,
28 Апреля 2013
+17
#include<iostream>
using namespace std;
int main(){
int n,a[100100],d[100100],ans=d[0]=1,i,j;
cin>>n>>a[0];
for(i = 1;i<n;++i)
for(j =i-1,cin>>a[i],d[i]=1;j>=0;--j)
if(a[i]>a[j]) ans = max(ans, d[i]=max(d[i],d[j]+1));
cout<<ans;
}Решение задачи нахождения НВП (наибольшей возр. подпосл-ти)
AvadaKedavra,
26 Апреля 2013
+12
namespace predicate {
using ...;
typedef boost::function<bool (const object &obj)> bool_func;
typedef boost::function<int (const object &obj)> int_func;
// ... скучные реализации операторов ...
template <class I, class S> struct predicate_grammar :
qi::grammar<I, bool_func(), S>
{
predicate_grammar() : predicate_grammar::base_type(bool_expr)
{
identifier = char_("a-z") >> *(char_("a-z_0-9"));
bool_prop = identifier [ _val = bind(&make_bool_prop_reader, _1, _pass) ];
bool_expr = (bool_expr2 >> "||" >> bool_expr) [ _val = bind(&make_logic_op, &op_or, _1, _2) ]
| bool_expr2 [ _val = _1 ];
bool_expr2 = (bool_expr3 >> "&&" >> bool_expr2) [ _val = bind(&make_logic_op, &op_and, _1, _2) ]
| bool_expr3 [ _val = _1 ];
bool_expr3 = ('(' >> bool_expr >> ')') [ _val = _1 ]
| ('!' >> bool_expr3) [ _val = bind(&make_not, _1) ]
| int_comp [ _val = _1 ]
| bool_prop [ _val = _1];
int_comp = (int_expr >> "<" >> int_expr) [ _val = bind(&make_cmp_op, &op_less, _1, _2) ]
| (int_expr >> "<=" >> int_expr) [ _val = bind(&make_cmp_op, &op_less_eq, _1, _2) ]
| (int_expr >> ">" >> int_expr) [ _val = bind(&make_cmp_op, &op_greater, _1, _2) ]
| (int_expr >> ">=" >> int_expr) [ _val = bind(&make_cmp_op, &op_greater_eq, _1, _2) ]
| (int_expr >> "==" >> int_expr) [ _val = bind(&make_cmp_op, &op_eq, _1, _2) ]
| (int_expr >> "!=" >> int_expr) [ _val = bind(&make_cmp_op, &op_not_eq, _1, _2) ];
int_expr = int_prop [ _val = _1 ]
| int_const [ _val = bind(&make_int_const, _1) ];
int_const = int_ [ _val = _1 ];
int_prop = identifier [ _val = bind(&make_int_prop_reader, _1, _pass) ];
}
qi::rule<I, std::string(), S> identifier;
qi::rule<I, int(), S> int_const;
qi::rule<I, int_func(), S> int_expr, int_prop;
qi::rule<I, bool_func(), S> bool_expr, bool_expr2, bool_expr3, int_comp, bool_prop;
};
boost::function<bool (const object &)> parse(const std::string &src) {
if (src.empty())
return make_bool_const(true);
bool_func p;
std::string::const_iterator b = src.begin(), e = src.end();
predicate_grammar<std::string::const_iterator, boost::spirit::ascii::space_type> grammar;
if (!phrase_parse(b, e, grammar, boost::spirit::ascii::space, p) || b != e) {
std::stringstream s;
s << "Predicate parsing failed at " << (b - src.begin()) << " in \"" << src << "\"";
throw std::runtime_error(s.str());
}
return p;
}Обещанный в http://govnokod.ru/12936#comment175980 говнокодец с использованием бусто-духа.
bormand,
26 Апреля 2013
Follow us!