- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
int getFilesize(char* fname) {
int f=open(fname, O_RDONLY);
int size=0;
if (f<0) {/*не важно*/}
size=lseek(f, 0, SEEK_END);
close(f);
return size;
}
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+17
int getFilesize(char* fname) {
int f=open(fname, O_RDONLY);
int size=0;
if (f<0) {/*не важно*/}
size=lseek(f, 0, SEEK_END);
close(f);
return size;
}
Писал прогу под линукс впервые. К концу написания уже знал что такое stat(), но как глянул в начало...)))))
+12
// precondition: you already have a boost::shared_ptr<> to this or a derived object
template<typename T>
inline boost::shared_ptr<T> get_shared_ptr()
{
// this cast lets the compiler verify the type compatibility
assert( dynamic_cast<typename boost::shared_ptr<T>::element_type*>( &(*shared_from_this()) ) != 0);
return *(boost::shared_ptr<T>*) &shared_from_this();
}
-
+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/
+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
+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
+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;
}
+16
try
{
Application->Initialize();
}
catch (...)
{
try
{
throw Exception("");
}
catch (Exception &exception)
{
Application->ShowException(&exception);
}
}
Найдено в проекте написанном на Borland C++Builder :)
+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;
}
}
Новоприбывший сотрудник откладывает вот такое. Это он сделал после совета использовать маски. Вы когда-нибудь видели массив из одного элемента? Я тоже нет.
+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);
}
+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/12465 Изобретаем права доступа в compile time, чтобы можно было запретить писать в readonly-буфер и читать из writeonly-буфера без дупликации кода. put_into по сути не нужен (запись в readonly_buffer у меня и без этого не скомпилится), существует из соображений симметрии. Полный код здесь https://github.com/roman-kashitsyn/encoding-binary