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

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

+6

1
2
3
4
5
6

void MultMatrix(const GLfloat m1[16], const GLfloat m2[16], GLfloat result[16])
{
  glLoadMatrixf(m1);
  glMultMatrixf(m2);
  glGetFloatv(GL_MODELVIEW_MATRIX, result);
}

LispGovno, 12 Марта 2016

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

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

+5

01
02
03
04
05
06
07
08
09
10
11
12
13

catch(...)
{
	static int i = 0;                     
	//if we enter this catch clause more than 1 time
	//it is very likely that the RestartSystem() command
	//did not succeed. If this is the case we just exit.
	if(i>0)
		exit(0);
	else
		MonitorT::GetInstance()->RestartSystem();
	i++;
	throw;
}

Навеяло...

blackhearted, 11 Марта 2016

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

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

+6

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

//		implicit_cast< >
// I believe this was originally going to be in the C++ standard but 
// was left out by accident. It's even milder than static_cast.
// I use it instead of static_cast<> to emphasize that I'm not doing
// anything nasty. 
// Usage is identical to static_cast<>
template <class OutputClass, class InputClass>
inline OutputClass implicit_cast(InputClass input){
	return input;
}

//		horrible_cast< >
// This is truly evil. It completely subverts C++'s type system, allowing you 
// to cast from any class to any other class. Technically, using a union 
// to perform the cast is undefined behaviour (even in C). But we can see if
// it is OK by checking that the union is the same size as each of its members.
// horrible_cast<> should only be used for compiler-specific workarounds. 
// Usage is identical to reinterpret_cast<>.

// This union is declared outside the horrible_cast because BCC 5.5.1
// can't inline a function with a nested class, and gives a warning.
template <class OutputClass, class InputClass>
union horrible_union{
	OutputClass out;
	InputClass in;
};

template <class OutputClass, class InputClass>
inline OutputClass horrible_cast(const InputClass input){
	horrible_union<OutputClass, InputClass> u;
	// Cause a compile-time error if in, out and u are not the same size.
	// If the compile fails here, it means the compiler has peculiar
	// unions which would prevent the cast from working.
	typedef int ERROR_CantUseHorrible_cast[sizeof(InputClass)==sizeof(u) 
		&& sizeof(InputClass)==sizeof(OutputClass) ? 1 : -1];
	u.in = input;
	return u.out;
}

Боль и страдание шаблонного программирования на С++98. Комменты и названия доставляют.

gorthauer87, 11 Марта 2016

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

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

0

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

void checklock(globalMemManager *c)
	{
		if (!c->isThread) return;
		_voidint idl=c->isThread();
#ifdef THREADDEBUG
		assert(idl!=0);
#endif
		while (idl==0 && c->lock());
		if (idl!=0) while (true) {
			while (c->lockId()!=idl) {
				c->canLeave()=idl;
			}
			if (c->lock()) break;
		}
		c->lock()=true;
	}

	void unlock(globalMemManager *c)
	{
		if (!c->isThread) return;
		c->lock()=false;
#ifdef THREADDEBUG
		assert(c->lockId()==c->isThread());
#endif
		c->canLeave()=0;
		c->lockId()=0;
	}


	void globalMemManager::manage()
	{
		if (!lock()) if (lockId()==0 && canLeave()!=0) {
			if (!lock()) lock()=true;
			lockId()=canLeave();
		}
	}

Лучшее

foxes, 10 Марта 2016

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

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

−2

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

namespace bt {
#define MEMNULL \
	_FORCEINLINE void* operator new(size_t) { return 0; } \
	_FORCEINLINE void operator delete(void* ) { }

#define MEMDEFAULT(classname) \
	_FORCEINLINE void* operator new(size_t size) { return extFunctions.CreateMem((unsigned int)size, 0); } \
	_FORCEINLINE void operator delete(void* val) { extFunctions.DeleteMem(val, 0); }

#define MEMMANAGER(classname) \
	_FORCEINLINE void* operator new(size_t size) { return bt::internalmemmanager.getNew((unsigned int)size); } \
	_FORCEINLINE void operator delete(void* val) {bt::internalmemmanager.freeThis(val,sizeof(classname));}

#define MEMMANAGERCLEAN(classname) \
	_FORCEINLINE void* operator new(size_t size) { return bt::internalmemmanager.getNewClean((unsigned int)size); } \
	_FORCEINLINE void operator delete(void* val) { bt::internalmemmanager.freeThis(val,sizeof(classname)); }

	class memManagerExport {
	public:
		MEMDEFAULT(memManagerExport)

		BT_API memManagerExport(unsigned int size);

		BT_API virtual ~memManagerExport();

		/// destroy all memory segments and free list of free pointers
		BT_API void _free();
		/// return pointer to new object and create new segment of objects if need.
		BT_API void *_addAlloc();
		/// return pointer to free object
		BT_API void *_getFree(unsigned int size);
		/// add pointer to list of free
		BT_API void _appendToFree(_voidint idat);
		/// mark pointer to free ???
		BT_API void _markFree(void* val);
		/// return number object in segment
		BT_API unsigned int _valid(unsigned int id);
		/// return segment number
		BT_API unsigned int _segid(unsigned int id);
		/// prepare calculation for object size
		BT_API void _calcsize(unsigned int size);

	private:
		enum States {
			VALIDED = 0x011F1C01,
			FREE = 0
		};

		unsigned int fisVal;
		struct p_smemManager *fargs;
	};

	class memManager: public memManagerExport {
	public:
		MEMDEFAULT(memManager)

		_FORCEINLINE memManager(unsigned int size):memManagerExport(size) {}

		_FORCEINLINE ~memManager() {}

		/// create memory for object
		_FORCEINLINE void *getNew(unsigned int size) {return (void*)_getFree(size);}
		/// delete memory for object
		_FORCEINLINE void freeThis(void * val) {_appendToFree((_voidint)val);}
		/// destroy all memory segments and free list of free
		_FORCEINLINE void free() {_free();};
	};

	class globalMemManager {
	public:
		MEMDEFAULT(globalMemManager)

}

Давайте ржать

foxes, 10 Марта 2016

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

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

−1

001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100

#ifndef H112
#define H112 201004L

#include<iostream>
#include<fstream>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<string>
#include<list>
#include<vector>
#include<algorithm>
#include<stdexcept>

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

#ifdef _MSC_VER
#include <hash_map>
using stdext::hash_map;
#else
#include <ext/hash_map>
using __gnu_cxx::hash_map;

namespace __gnu_cxx {

    template<> struct hash<std::string>
    {
        size_t operator()(const std::string& s) const
        {
            return hash<char*>()(s.c_str());
        }
    };

} // of namespace __gnu_cxx
#endif

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

#define unordered_map hash_map

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

typedef long Unicode;

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

using namespace std;

template<class T> string to_string(const T& t)
{
  ostringstream os;
  os << t;
  return os.str();
}

struct Range_error : out_of_range {  // enhanced vector range error reporting
  int index;
  Range_error(int i) :out_of_range("Range error: "+to_string(i)), index(i) { }
};


// trivially range-checked vector (no iterator checking):
template< class T> struct Vector : public std::vector<T> {
  typedef typename std::vector<T>::size_type size_type;

  Vector() { }
  explicit Vector(size_type n) :std::vector<T>(n) {}
  Vector(size_type n, const T& v) :std::vector<T>(n,v) {}
  template <class I>
  Vector(I first, I last) :std::vector<T>(first,last) {}

  T& operator[](unsigned int i) // rather than return at(i);
  {
    if (i<0||this->size()<=i) throw Range_error(i);
    return std::vector<T>::operator[](i);
  }
  const T& operator[](unsigned int i) const
  {
    if (i<0||this->size()<=i) throw Range_error(i);
    return std::vector<T>::operator[](i);
  }
};

// disgusting macro hack to get a range checked vector:
#define vector Vector

// trivially range-checked string (no iterator checking):
struct String : std::string {
  
  String() { }
  String(const char* p) :std::string(p) {}
  String(const string& s) :std::string(s) {}
  template<class S> String(S s) :std::string(s) {}
  String(int sz, char val) :std::string(sz,val) {}
  template<class Iter> String(Iter p1, Iter p2) : std::string(p1,p2) { }

  char& operator[](unsigned int i) // rather than return at(i);
  {
    if (i<0||size()<=i) throw Range_error(i);
    return std::string::operator[](i);

LispGovno, 10 Марта 2016

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

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

0

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

class SMemManager {
public:
 SMemManager() { std::cout<<"Singleton new: "<<this<<std::endl; init(); }
 
 void* operator new(size_t) { return (void*)p_body; }
 void operator delete(void* ) { }
 
private:
 void init() {
  if (p_init!=0xF3149A51) {
  	  p_countMemData=0;
  	  p_memData=0;
	  std::cout<<"Singleton init: "<<this<<std::endl;
  }
  p_init=0xF3149A51;
 }
 
 unsigned int p_init;
 unsigned int p_countMemData;
 void ** p_memData;
 static char p_body[];
 
};
char SMemManager::p_body[sizeof(SMemManager)];

Один из эпичных синглтонов от foxes.
Посмотреть эволюцию этого шедевра или окунуться в его обсуждение можно в теме по ссылке:
http://www.gamedev.ru/code/forum/?id=211629&page=6#m81

-Eugene-, 09 Марта 2016

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

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

+2

1
2
3
4
5
6
7

const int MOD = 1000000007;

int pow(int a, int b) {
	if (!b) return 1;
	if (b & 1) return (pow(a, b - 1) * 1LL * a) % MOD;
	return pow((a * 1LL * a) % MOD, b / 2);
}

http://ideone.com/JlfNxZ

Там ещё куча всякого говна есть
http://acm.math.spbu.ru/~kunyavskiy/cpp/

3_dar, 08 Марта 2016

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

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

+2

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

switch (a) {
	case 12345:
		return 0;
	case 14523:
		return 1;
	case 102543:
		return 2;
	case 104325:
		return 3;
	case 243051:
		return 4;
	case 245130:
		return 5;
	case 350214:
		return 6;
	case 351402:
		return 7;
	case 423150:
		return 8;
	case 425031:
		return 9;
	case 530412:
		return 10;
	case 531204:
		return 11;
	}
	return -1;

Ekke, 07 Марта 2016

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

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

−3

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

if (c & Expression::RefValue) {
      scontext += "|RefValue";
    }
    if (c & Expression::RefParameter) {
      scontext += "|RefParameter";
    }
    if (c & Expression::DeepReference) {
      scontext += "|DeepReference";
    }
    if (c & Expression::ObjectContext) {
      scontext += "|ObjectContext";
    }
    if (c & Expression::InParameterExpression) {
      scontext += "|InParameterExpression";
    }
    if (c & Expression::ExistContext) {
      scontext += "|ExistContext";
    }
    if (c & Expression::UnsetContext) {
      scontext += "|UnsetContext";
    }
    if (c & Expression::AssignmentLHS) {
      scontext += "|AssignmentLHS";
    }
    if (c & Expression::RefAssignmentLHS) {
      scontext += "|RefAssignmentLHS";
    }
    if (c & Expression::DeepAssignmentLHS) {
      scontext += "|DeepAssignmentLHS";
    }
    if (c & Expression::AssignmentRHS) {
      scontext += "|AssignmentRHS";
    }
    if (c & Expression::InvokeArgument) {
      scontext += "|InvokeArgument";
    }
    if (c & Expression::OprLValue) {
      scontext += "|OprLValue";
    }
    if (c & Expression::DeepOprLValue) {
      scontext += "|DeepOprLValue";
    }
    if (c & Expression::AccessContext) {
      scontext += "|AccessContext";
    }
    if (c & Expression::ReturnContext) {
      scontext += "|ReturnContext";
    }

Нашел тут:
https://github.com/facebook/hhvm/blob/master/hphp/compiler/construct.cpp#L226

kschingiz, 05 Марта 2016

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

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

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

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

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

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

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

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

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

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

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

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