C++ — Говнокод.ру

C++ / Говнокод #16543

+42

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

int complexFunction(int flag)
{
    QMutexLocker locker(&mutex);

    int retVal = 0;

    switch (flag) {
    case 0:
    case 1:
        return moreComplexFunction(flag);
    case 2:
        {
            int status = anotherFunction();
            if (status < 0)
                return -2;
            retVal = status + flag;
        }
        break;
    default:
        if (flag > 10)
            return -1;
        break;
    }

    return retVal;
}

Пора добавлять отдельную ветку для фрейворка Qt. Это просто клад, так извратить все принципы програмирования :-). Этот код из справки к этому чуду. QMutexLocker - целый класс для того чтобы не нужно было разблокировать мьютекс при выходе из функции! Так они скоро и до сборщика мусора с неявной типизацией дойдут!
P.S. У кого есть Qq попробуйте в "коде" сборки qmake вызвать include внутри функции.

rst256, 15 Августа 2014

Комментарии (18)

C++ / Говнокод #16542

+55

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

//--------------------------------------------------------------------------

	#define DEF_P(X, Y, N) X##N
	#define DEF_D(X, Y, N) X##N Y##N
	#define DP1(DT, X, Y) DT(X, Y, 0)

	//--------------------------------------------------------------------------

	#define DP2(DT, X, Y) DP1(DT, X, Y), DT(X, Y, 1)
	#define DP3(DT, X, Y) DP2(DT, X, Y), DT(X, Y, 2)
	#define DP4(DT, X, Y) DP3(DT, X, Y), DT(X, Y, 3)
	#define DP5(DT, X, Y) DP4(DT, X, Y), DT(X, Y, 4)
	#define DP6(DT, X, Y) DP5(DT, X, Y), DT(X, Y, 5)
	#define DP7(DT, X, Y) DP6(DT, X, Y), DT(X, Y, 6)
	#define DP8(DT, X, Y) DP7(DT, X, Y), DT(X, Y, 7)
	#define DP9(DT, X, Y) DP8(DT, X, Y), DT(X, Y, 8)
	#define DP10(DT, X, Y) DP9(DT, X, Y), DT(X, Y, 9)
	#define DP11(DT, X, Y) DP10(DT, X, Y), DT(X, Y, 10)
	#define DP12(DT, X, Y) DP11(DT, X, Y), DT(X, Y, 11)
	#define DP13(DT, X, Y) DP12(DT, X, Y), DT(X, Y, 12)
	#define DP14(DT, X, Y) DP13(DT, X, Y), DT(X, Y, 13)
	#define DP15(DT, X, Y) DP14(DT, X, Y), DT(X, Y, 14)

	//--------------------------------------------------------------------------
	// define functor for params count 0
	//--------------------------------------------------------------------------

	#define TEMP_DEF_PARAM(N)
	#define TEMP_SPC_PARAM(N)
	#define FUNC_PTR_PARAM(N)
	#define FUNC_INV_PARAM(N)
	#define FUNC_DEF_PARAM(N)
	DEFINE_FUNCTOR(0);

	#undef TEMP_DEF_PARAM
	#undef TEMP_SPC_PARAM
	#undef FUNC_PTR_PARAM
	#undef FUNC_INV_PARAM
	#undef FUNC_DEF_PARAM

	//--------------------------------------------------------------------------
	// define functor for other params counts
	//--------------------------------------------------------------------------

	#define TEMP_DEF_PARAM(N) 	,DP##N(DEF_P, typename T,)
	#define TEMP_SPC_PARAM(N)	,DP##N(DEF_P, T,)
	#define FUNC_PTR_PARAM(N)	DP##N(DEF_P, T,)
	#define FUNC_INV_PARAM(N)	DP##N(DEF_P, p,)
	#define FUNC_DEF_PARAM(N)	DP##N(DEF_D, T, p)

	DEFINE_FUNCTOR(1);
	DEFINE_FUNCTOR(2);
	DEFINE_FUNCTOR(3);
	DEFINE_FUNCTOR(4);
	DEFINE_FUNCTOR(5);
	DEFINE_FUNCTOR(6);
	DEFINE_FUNCTOR(7);
	DEFINE_FUNCTOR(8);
	DEFINE_FUNCTOR(9);
	DEFINE_FUNCTOR(10);
	DEFINE_FUNCTOR(11);
	DEFINE_FUNCTOR(12);
	DEFINE_FUNCTOR(13);
	DEFINE_FUNCTOR(14);
	DEFINE_FUNCTOR(15);

Весь пиздец https://github.com/Evil-Spirit/Nutmeg/blob/master/CoreSrc/Common/Functor.h
Дети, не программируйте на C++

FadeToBlack, 15 Августа 2014

Комментарии (1)

C++ / Говнокод #16522

+57

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

bool Processor::check_holes(int x, int y){
    int scale = 1000000;
    if((x > (die_size-mem_size)/2*scale && x < (die_size-mem_size)*scale) && (y > (die_size-mem_size)/2*scale && y < (die_size-mem_size)*scale)){
        return false;
    }
    if((x > (die_size-mem_size)*scale) && (y > (die_size-mem_size)/2*scale && y < (die_size-mem_size)*scale)){
        if(((int)(x - (die_size-mem_size)*scale) % 400) > 340 && ((int)(y - (die_size-mem_size)/2*scale) % 400) > 340){
            if((x - (die_size-mem_size)*scale) < 2400){
                return true;
            }
        }
    }
    if((x < (die_size-mem_size)/2*scale) && (y > (die_size-mem_size)/2*scale && y < (die_size-mem_size)*scale)){
        if(((int)((die_size-mem_size)/2*scale - x) % 400) > 340 && ((int)(y - (die_size-mem_size)/2*scale) % 400) > 340){
            if(((die_size-mem_size)/2*scale - x) < 2400){
                return true;
            }
        }
    }
    if((y > (die_size-mem_size)*scale) && (x > (die_size-mem_size)/2*scale && x < (die_size-mem_size)*scale)){
        if(((int)(y - (die_size-mem_size)*scale) % 400) > 340 && ((int)(x - (die_size-mem_size)/2*scale) % 400) > 340){
            if((y - (die_size-mem_size)*scale) < 2400){
                return true;
            }   
        }
    }
    if((y < (die_size-mem_size)/2*scale) && (x > (die_size-mem_size)/2*scale && x < (die_size-mem_size)*scale)){
        if(((int)((die_size-mem_size)/2*scale - y) % 400) > 340 && ((int)(x - (die_size-mem_size)/2*scale) % 400) > 340){
            if(((die_size-mem_size)/2*scale - y) < 2400){
                return true;
            }
        }
    }
    return false;
}

Проверяем дырки

Abbath, 13 Августа 2014

Комментарии (7)

C++ / Говнокод #16520

+62

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

Grid Processor::build_grid()
{
    Grid res;
    double top = 340+60;
    double left = 0, right = 60;
    Point a,b,c,d;
    for(int i = 0; i < 6; ++i){
        for(int j = 0; j < 13; ++j){
            a = {left*1e-6, top*1e-6, 2.1e-3};
            b = {right*1e-6, top*1e-6, 2.1e-3};
            c = {(left-3.25)*1e-6, (top+3.25)*1e-6, 2e-3};
            d = {(right+3.25)*1e-6, (top+3.25)*1e-6, 2e-3};  
            auto t = std::make_tuple(a,b,c,d);
            res.push_back(t);
            left += (340+60);
            right += (340+60);
        }
        top += (340+60);
        left = 0;
        right = 60;
    }
    
    top = (int)(-mem_size*1e6)+60;
    left = (int)(mem_size*1e6)+340;
    right = (int)(mem_size*1e6)+400;
    for(int i = 0; i < 13; ++i){
        for(int j = 0; j < 6; ++j){
            a = {left*1e-6, top*1e-6, 2.1e-3};
            b = {right*1e-6, top*1e-6, 2.1e-3};
            c = {(left-3.25)*1e-6, (top+3.25)*1e-6, 2e-3};
            d = {(right+3.25)*1e-6, (top+3.25)*1e-6, 2e-3};  
            auto t = std::make_tuple(a,b,c,d);
            res.push_back(t);
            left += (340+60);
            right += (340+60);
        }
        top += (340+60);
        left = (int)(mem_size*1e6)+340;
        right = (int)(mem_size*1e6)+(340+60);
    }
    
    top = (int)(-(mem_size+2.4e-3)*1e6)+60;
    left = 0, right = 60;
    for(int i = 0; i < 6; ++i){
        for(int j = 0; j < 13; ++j){
            a = {left*1e-6, top*1e-6, 2.1e-3};
            b = {right*1e-6, top*1e-6, 2.1e-3};
            c = {(left-3.25)*1e-6, (top+3.25)*1e-6, 2e-3};
            d = {(right+3.25)*1e-6, (top+3.25)*1e-6, 2e-3};  
            auto t = std::make_tuple(a,b,c,d);
            res.push_back(t);
            left += (340+60);
            right += (340+60);
        }
        top += (340+60);
        left = 0;
        right = 60;
    }
    
    top = (int)(-mem_size*1e6)+60;
    left = -2400;
    right = -2400+60;
    for(int i = 0; i < 13; ++i){
        for(int j = 0; j < 6; ++j){
            a = {left*1e-6, top*1e-6, 2.1e-3};
            b = {right*1e-6, top*1e-6, 2.1e-3};
            c = {(left-3.25)*1e-6, (top+3.25)*1e-6, 2e-3};
            d = {(right+3.25)*1e-6, (top+3.25)*1e-6, 2e-3};  
            auto t = std::make_tuple(a,b,c,d);
            res.push_back(t);
            left += (340+60);
            right += (340+60);
        }
        top += (340+60);
        left = -2400;
        right = -2400+60;
    }
    
    return res;
}

Magic numbers, Voodoo numbers!

Abbath, 12 Августа 2014

Комментарии (20)

C++ / Говнокод #16507

+58

1

#define CHK( x ) {do{if (x == MBRES_ERR){goto __gotoFAIL;}} while (FALSE);}

Из SDK корейского сканера

snw, 08 Августа 2014

Комментарии (47)

C++ / Говнокод #16473

+57

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

struct ShaderBuilder
{
	Shader ToShader() const;

	ShaderParts::VertexDataSrc VertexDataSource;
	ShaderParts::Transform Transformation;
	ShaderParts::LightControl LightControl;
	ShaderParts::ColorSrc DiffuseSource;
	ShaderParts::EmissionSrc EmissionSource;
	ShaderParts::SpecularSrc SpecularSource;
	ShaderParts::HeightSrc HeightSource;
	ShaderParts::NormalSrc NormalSource;
	ShaderParts::Parallax Parallax;
	ShaderParts::LightModel LightModel;

	...
};

#define with(x) for(auto &_=(x), *firstIter=&_; firstIter; firstIter=nullptr)

...

using namespace ShaderParts;
ShaderBuilder floorShaderBuilder;
with(floorShaderBuilder)
{
	_.Transformation=Transform::Default();
	_.LightControl=ShaderParts::LightControl::DefaultLighting({ {DirectionalLight::Type, 1} });
	_.DiffuseSource=ColorSrc::FromTexture();
	_.SpecularSource=SpecularSrc::FromConstants("0.25", "16.0");
	_.HeightSource=HeightSrc::FromHeightMap();
	_.NormalSource=NormalSrc::FromNormalMap("rg");
	_.Parallax=Parallax::SimpleParallax();
	_.LightModel=LightModel::Phong();
}
floorSh=floorShaderBuilder.ToShader();

Вот такой оператор with на C++.

gammaker, 04 Августа 2014

Комментарии (20)

C++ / Говнокод #16465

+51

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

void __fastcall TForm3::Button1Click(TObject *Sender)
{
AnsiString a1,b1,c1,d1,a2,b2,c2,d2,a3,b3,c3,d3,a4,b4,c4,d4,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10;
a1=Edit1->Text;
b1=Edit5->Text;
if (a1==b1) a1>>r1;
else "n">>r1;
a2=Edit2->Text;
b2=Edit6->Text;
if (a2==b2) a2>>r2;
else "n">>r2;
a3=Edit3->Text;
b3=Edit7->Text;
if (a3==b3) a3>>r3;
else "n">>r3;
a4=Edit4->Text;
b4=Edit8->Text;
if (a4==b4) a4>>r4;
else "n">>r4;
c1=Edit9->Text;
d1=Edit13->Text;
if (c1==d1) c1>>r5;
else "n">>r5;
c2=Edit10->Text;
d2=Edit14->Text;
if (c2==d2) c2>>r6;
else "n">>r6;
c3=Edit11->Text;
d3=Edit15->Text;
if (c3==d3) c3>>r7;
else "n">>r7;
c4=Edit12->Text;
d4=Edit15->Text;
if (c4==d4) c4>>r8;
else "n">>r8;
 }
//---------------------------------------------------------------------------
 
void __fastcall TForm3::Label6Click(TObject *Sender)
{
int r1,r2,r3,r4,r5,r6,r7,r8;
Label6->Caption=r1;
Label7->Caption=r2;
Label8->Caption=r3;
Label9->Caption=r4;
Label10->Caption=r5;
Label11->Caption=r6;
Label12->Caption=r7;
Label13->Caption=r8;
 }

По словам "очевидца", код сравнивает посимвольно две строки и пропускает не совпавшие символы

aNNiMON, 03 Августа 2014

Комментарии (15)

C++ / Говнокод #16430

+56

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

#	define S_1(X,...)				\
	template<class T, int N>		\
	T X(const V<T, N>& v)			\
	{								\
		return v.X;					\
	}
#	define S_2(X,Y,...)				\
	template<class T, int N>		\
	V<T, 2> X##Y(const V<T, N>& v)	\
	{								\
		return V<T, 2>(v.X, v.Y);	\
	}
#	define S_3(X,Y,Z,...)				\
	template<class T, int N>			\
	V<T, 3> X##Y##Z(const V<T, N>& v)	\
	{									\
		return V<T, 3>(v.X, v.Y, v.Z);	\
	}
#	define S_4(X,Y,Z,W,...)					\
	template<class T, int N>				\
	V<T, 4> X##Y##Z##W(const V<T, N>& v)	\
	{										\
		return V<T, 4>(v.X, v.Y, v.Z, v.W);	\
	}

#	define S_E(S, X, Y, Z)	\
	S(x, X, Y, Z);S(y, X, Y, Z);S(z, X, Y, Z);S(w, X, Y, Z);S(O, X, Y, Z);S(I, X, Y, Z);
#	define S_E1(E, S, Z, W)	\
	E(S, x, Z, W);			\
	E(S, y, Z, W);			\
	E(S, z, Z, W);			\
	E(S, w, Z, W);			\
	E(S, O, Z, W);			\
	E(S, I, Z, W);

#	define S_E2(E, S, W)	\
	S_E1(E, S, x, W);		\
	S_E1(E, S, y, W);		\
	S_E1(E, S, z, W);		\
	S_E1(E, S, w, W);		\
	S_E1(E, S, O, W);		\
	S_E1(E, S, I, W);

#	define S_E3(E, S)	\
	S_E2(E, S, x);		\
	S_E2(E, S, y);		\
	S_E2(E, S, z);		\
	S_E2(E, S, w);		\
	S_E2(E, S, O);		\
	S_E2(E, S, I);

	S_E1(S_E, S_2, void, void);
	S_E2(S_E, S_3, void);
	S_E3(S_E, S_4);

// Где-то выше
template<class T, int N>
struct V;
template<class T>
struct V<T, 2>
{
	V(T x, T y) : x(x), y(y) {}
	T x,y;
	T O = 0;
	T I = 1;
};
template<class T>
struct V<T, 3>
{
	V(T x, T y, T z) : x(x), y(y), z(z) {}
	T x,y,z;
	T O = 0;
	T I = 1;
};
template<class T>
struct V<T, 4>
{
	V(T x, T y, T z, T w) : x(x), y(y), z(z), w(w) {}
	T x,y,z,w;
	T O = 0;
	T I = 1;
};

Этот код рабочий и используется во многих местах моего проекта.
Я его написал когда-то давно и уже забыл, как оно функционирует, но оно генерирует очень много (около 1.5k) функций.

-Eugene-, 27 Июля 2014

Комментарии (36)

C++ / Говнокод #16429

+50

1
2
3

[]() { std::function<int(int)> foo = 
           [&foo](int k) { return k == 1 ? 1 : k + foo(k-1); }; 
           return foo; }()(3)

Как написать рекурсивную лямбдру на крестах?

TarasB, 26 Июля 2014

Комментарии (100)

Говнокод: по колено в коде.

C++ / Говнокод #16552