- 1
- 2
- 3
- 4
- 5
- 6
- 7
template<typename T>
static json_string _itoa(T val) json_nothrow {
/*...*/
long value = (long)val;
/*...*/
}
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+19
template<typename T>
static json_string _itoa(T val) json_nothrow {
/*...*/
long value = (long)val;
/*...*/
}
Продолжаю бороться с поддержкой 64-битных чисел в libjson :/
+23
#include <iostream>
using namespace std;
class Class {
public:
explicit Class(int a) : m_int(a) {}
int get() const { return m_int; }
void swapThis(int a) {
delete this;
Class **thisptr = reinterpret_cast<Class**>(&a);
thisptr--;
*thisptr = new Class(a);
cout << "this: " << this << endl
<< "that: " << *thisptr << endl;
}
private:
int m_int;
};
int main() {
Class *s = new Class(13);
s->swapThis(42);
cout << s->get() << endl;
delete s;
return 0;
}
Что творит хакингкостылинг + инлайн методы.
http://ideone.com/5Kyitw
+24
#include <iostream>
#define n 1
int main()
{
using namespace std;
cout << (n < 0 ? 1 : 0)+
((n << 1) < 0 ? 1 : 0)+
((n << 2) < 0 ? 1 : 0)+
((n << 3) < 0 ? 1 : 0)+
((n << 4) < 0 ? 1 : 0)+
((n << 5) < 0 ? 1 : 0)+
((n << 6) < 0 ? 1 : 0)+
((n << 7) < 0 ? 1 : 0)+
((n << 8) < 0 ? 1 : 0)+
((n << 9) < 0 ? 1 : 0)+
((n << 10) < 0 ? 1 : 0)+
((n << 11) < 0 ? 1 : 0)+
((n << 12) < 0 ? 1 : 0)+
((n << 13) < 0 ? 1 : 0)+
((n << 14) < 0 ? 1 : 0)+
((n << 15) < 0 ? 1 : 0)+
((n << 16) < 0 ? 1 : 0)+
((n << 17) < 0 ? 1 : 0)+
((n << 18) < 0 ? 1 : 0)+
((n << 19) < 0 ? 1 : 0)+
((n << 20) < 0 ? 1 : 0)+
((n << 21) < 0 ? 1 : 0)+
((n << 22) < 0 ? 1 : 0)+
((n << 23) < 0 ? 1 : 0)+
((n << 24) < 0 ? 1 : 0)+
((n << 25) < 0 ? 1 : 0)+
((n << 26) < 0 ? 1 : 0)+
((n << 27) < 0 ? 1 : 0)+
((n << 28) < 0 ? 1 : 0)+
((n << 29) < 0 ? 1 : 0)+
((n << 30) < 0 ? 1 : 0)+
((n << 31) < 0 ? 1 : 0)
<< endl;
return 0;
}
Для заданного пятизначного целого числа подсчитать количество его нулей.
Прямо с экзамена. Преподаватель катается по полу. Не шучу.
+24
#ifndef JSON_SPIRIT_READER_TEMPLATE
#define JSON_SPIRIT_READER_TEMPLATE
// Copyright ***
// Distributed under the MIT License, see accompanying file LICENSE.txt
// json spirit version 4.05
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
//some classes
#endif
Сначала проверим многократное включение через макросы, а потом # pragma once - чтобы наверняка!
+16
#include <iostream>
using namespace std;
struct T{int a;T(){cout<<"T"<<this<<endl;}~T(){cout<<"~T"<<this<<endl;}};
struct D:public T{int b;D(){cout<<"D"<<this<<endl;}~D(){cout<<"~D"<<this<<endl;}};
int main() {
T* a = new D[2];
cout<<"mission failure"<<endl;
delete[] a;
return 0;
}
Писал тест специально для Тараса:
Виртуальный деструктор в базовых классах нужен:
*Для вызова деструкторов всех потомков. Иногда это не нужно, тк поля структуры тривиальны. Согласен с Тарасом.
*Для правильного выбора перегруженного оператора delete. Создал одним менеджером памяти, а удалил в другой - это плохо. Но также бывает редко и только в специфичных проектах.
Но вот то, что демонстрируется в этом примере - думаю чего-нибудь такого создатели той библиотеки, что ковырял Тарас, и опасались.
Не просто было вызван деструктор только для предков, забыв о деструкторах потомков, но и:
*Деструктор предков был вызван для this не по тем адресам, где расположены объекты.
Не удивлюсь, если:
*В некоторых кулхацкерских реализациях менеджеров памяти будет удален буфер меньшего размера и куча попортится или оставшаяся не удаленная часть массива в куче просто утекет.
http://liveworkspace.org/code/2X3MR0$8
+10
virtual ~T() {}
нахуя?
у всех наследников то же самое и наличие чего-либо внутри не предполагается
Первая ссылка по гуглозапросу "c++ mersenne twister" выдаёт склад оопиозного говнокода:
http://www.bedaux.net/mtrand/
+13
#include <iostream>
using namespace std;
class Manager
{
private:
int *ar;
int _size;
public:
void CreateArray(int size);
void ResizeArray(int size);
void MakeIntArray(int iter, int number);
int GetIntArray(int iter);
~Manager()
{
delete [] ar;
}
};
void Manager::CreateArray(int size)
{
_size = size;
ar = new int[size];
}
void Manager::ResizeArray(int size)
{
int *nar = new int[size];
for(int i = 0; i < _size; i++)
{
*(nar+i) = *(ar+i);
}
_size = size;
delete [] ar;
*ar = *nar;
}
int Manager::GetIntArray(int iter)
{
return iter < _size ? *(ar+iter) : NULL;
}
void Manager::MakeIntArray(int iter, int number)
{
if(iter < _size)
*(ar+iter) = number;
}
int main()
{
Manager Man;
Man.CreateArray(10);
for(int i = 0; i < 10; i++)
Man.MakeIntArray(i, i);
for(int i = 0; i < 10; i++)
cout << Man.GetIntArray(i) << " ";
Man.ResizeArray(20);
cout << endl;
for(int i = 10; i < 20; i++)
Man.MakeIntArray(i, i);
for(int i = 0; i < 20; i++)
cout << Man.GetIntArray(i) << " ";
return 0;
}
> Собственно написал менеджер для массива, хочется узнать правильно ли все сделано, и нет ли утечек памяти?
Очередной шедевр с самизнаетеоткуда.
+79
//Unit1.h
const float RADIAN=0.01744444444;
TForm1 *Form1;
Graphics::TBitmap*ZadniyBuffer;
float ShipPosX,ShipPosY;
float ShipAngle;
float ShipSpeed;
bool LEFT,RIGHT,UP;
TList*Bullets;
TList*Asteroids;
class Bullet
{
public:
float x,y,dx,dy;
void CreateBullet()
{
x=ShipPosX;y=ShipPosY;
dx=10*cos(RADIAN*ShipAngle);
dy=10*sin(RADIAN*ShipAngle);
}
void Draw()
{
ZadniyBuffer->Canvas->Pen->Color=clRed;
ZadniyBuffer->Canvas->MoveTo(x,y);
ZadniyBuffer->Canvas->LineTo(x+dx,y+dy);
}
};
class CRock
{
public:
float x,y;
int Figure[50];
float Angle;
float Spin;
float XSpeed,YSpeed;
int Tip;
void CreateAsteroid(int t)
{
Tip=t;
XSpeed=random(4)+(random(9)/10.0)-2;
YSpeed=random(4)+(random(9)/10.0)-2;
Spin=random(10)-5;
for(int i=0;i<20;i++)
{
if(Tip==1)Figure[i]=random(10)+25;
if(Tip==2)Figure[i]=random(10)+10;
if(Tip==3)Figure[i]=random(5)+5;
}
}
void Move()
{
x+=XSpeed;y+=YSpeed;
Angle+=Spin;
if(x>440)x=-40;if(x<-40)x=440;
if(y>440)y=-40;if(y<-40)y=440;
}
void Draw()
{
ZadniyBuffer->Canvas->Pen->Color=clRed;
float tAng=0;
int tx=cos(RADIAN*(Angle+tAng))*Figure[0]+x;
int ty=sin(RADIAN*(Angle+tAng))*Figure[0]+y;
ZadniyBuffer->Canvas->MoveTo(tx,ty);
for(int i=0;i<20;i++,tAng+=19)
{
int tx=cos(RADIAN*(Angle+tAng))*Figure[i]+x;
int ty=sin(RADIAN*(Angle+tAng))*Figure[i]+y;
ZadniyBuffer->Canvas->LineTo(tx,ty);
}
}
};
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
randomize();
ZadniyBuffer=new Graphics::TBitmap();
ZadniyBuffer->Width =400;
ZadniyBuffer->Height=400;
ZadniyBuffer->Canvas->Pen->Color=clWhite;
Bullets =new TList();
Asteroids=new TList();
LEFT=false;RIGHT=false;
ShipPosX=200;ShipPosY=200;
ShipAngle=0;
ShipSpeed=0;
for(int i=0;i<4;i++)
{
CRock*a=new CRock();
a->x=random(400);
a->y=40;
a->CreateAsteroid(1);
Asteroids->Add((void*)a);
}
}
//---------------------------------------------------------------------------
void TForm1::CLS()
{
ZadniyBuffer->Canvas->Brush->Color=clBlack;
ZadniyBuffer->Canvas->FillRect(Rect(0,0,400,400));
Привет. Вот, украл, вернее, скачал с розришения автора код для курсача. На учебу билдера тупо времени нет, ибо есть много хвостов. Можете ли вы мне обьяснить весь код? Буду благодарен.
+15
LambdaVar<1> X;
LambdaVar<2> Y;
// The next line prints 10:
cout << lambda(X,Y)[ plus[ multiplies[3,X], Y ] ] (3,1) << endl;
cout << lambda(X,Y)[ (3 %multiplies% X) %plus% Y ] << endl;
//...
lambda(X)[ X %plus% getCurrentTime[_*_] ]
//...
let[ X == someLambdaExp,
Y == someOtherLambdaExpWhichMayInvolveX ]
.in[ someLambdaExpInvolvingXandY ]
//...
lambda(X)[
letrec[ F == lambda(Y)[ if1[ Y %equals% 0,
1,
Y %multiplies% F[Y %minus% 1] ] ] ]
.in[ F[X] ] ]
//...
Maybe<int> mx = just(2);
Maybe<int> my = just(3);
mx = lambda()[ compM<MaybeM>()[ plus[X,Y] | X<=mx, Y<=my, guard[false] ] ]();
cout << mx << endl; // Nothing
//...
compM<ListM>()[ makePair[X,Y] | X<=list_with(1,2), guard[true],
Y<=list_with(3,4), guard[ (Y %divides% X) %equal% 3 ] ] ]
Грибки отсюда:
http://people.cs.umass.edu/~yannis/fc++/
+18
/*
* The use of singletons for globals makes globals not
* actually be initialized until it is first needed, this
* makes the library faster to load, and have a smaller
* memory footprint
*/
#define json_global_decl(TYPE, NAME, VALUE) \
class jsonSingleton ## NAME { \
public: \
inline static TYPE & getValue() json_nothrow { \
static jsonSingleton ## NAME single; \
return single.val; \
} \
protected: \
inline jsonSingleton ## NAME() json_nothrow : val(VALUE) {} \
TYPE val; \
}
#define json_global(NAME) jsonSingleton ## NAME::getValue() \
json_global_decl(json_string, CONST_TRUE, JSON_TEXT("true"));
json_global_decl(json_string, CONST_FALSE, JSON_TEXT("false"));
json_global_decl(json_string, CONST_NULL, JSON_TEXT("null"));
/* Использование */
json_global(ERROR_NULL_IN_CHILDREN)
Наткнулся на утечку памяти, отловленную Valgrind'ом
А внутри вот это. И главное, совершенно непонятно, зачем воротить эту свистопляску, если линкеры умеют распознавать "true" по всюду (читаем про ROMability тут: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1396.pdf )
http://stackoverflow.com/questions/690176/c-c-optimization-of-pointers-to-string-constants
Сам код отсюда: http://code.google.com/p/wot-replay-parser/source/browse/libjson/Source/JSONGlobals.h