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

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

+7

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

#include <iostream>
namespace detail
{
  class CRWO;
  class CRO;
  class CWO;
  class CO;
}
typedef detail::CRWO&  CRWO;
typedef detail::CRO&  CRO;
typedef detail::CWO&  CWO;
typedef detail::CO&  CO;
class C
{
    friend class detail::CRWO; 
    friend class detail::CRO; 
    friend class detail::CWO; 
    friend class detail::CO; 
  public:
    C( int a ) : value(a) {}
    ~C() {};
    operator CRWO() { return *static_cast<detail::CRWO*>(static_cast<void*>(this)); }
    operator CRO() { return *static_cast<detail::CRO*>(static_cast<void*>(this)); }
    operator CWO() { return *static_cast<detail::CWO*>(static_cast<void*>(this)); }
    operator CO() { return *static_cast<detail::CO*>(static_cast<void*>(this)); }
  private:
    void set( int newValue ) { value = newValue; }
    int get() { return value; }
  private:
    int value;
};
class detail::CRWO
{
  public:
    void set( int newValue ) { static_cast<C*>(static_cast<void*>(this))->set( newValue ); }
    int get() { return static_cast<C*>(static_cast<void*>(this))->get( ); }
    operator ::CRO() { return *static_cast<detail::CRO*>(static_cast<void*>(this)); }
    operator ::CWO() { return *static_cast<detail::CWO*>(static_cast<void*>(this)); }
    operator ::CO() { return *static_cast<detail::CO*>(static_cast<void*>(this)); }    
  private:
    CRWO(); CRWO(const CRWO&);~CRWO();CRWO& operator=(const CRWO&);void operator&(); void operator*();
};
class detail::CWO
{
  public:
    void set( int newValue ) { static_cast<C*>(static_cast<void*>(this))->set( newValue ); }
     operator ::CO() { return *static_cast<detail::CO*>(static_cast<void*>(this)); }    
  private:
    CWO(); CWO(const CWO&);~CWO();CWO& operator=(const CWO&);void operator&(); void operator*();
};
class detail::CRO
{
  public:
    int get() { return static_cast<C*>(static_cast<void*>(this))->get( ); }
    operator ::CO() { return *static_cast<detail::CO*>(static_cast<void*>(this)); }    
  private:
    CRO(); CRO(const CRO&);~CRO();CRO& operator=(const CRO&);void operator&(); void operator*();
};
class detail::CO
{
  public:
  private:
    CO(); CO(const CO&);~CO();CO& operator=(const CO&);void operator&(); void operator*();
};int main(int argc, char *argv[])
{
C c(3);
CRWO rwo = c;
CRO ro = c;
CWO wo = c;
CO o = c;
  std::cout  << rwo.get() << std::endl;
  wo.set( 5);
  std::cout  << ro.get() << std::endl;
return 0;
}

Оттуда.

Автор требует указывать авторство при копировании.

LispGovno, 02 Февраля 2013

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

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

+14

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

#define MAX_MONSTER_ID			600
#define MAX_ITEM_FOR_MONSTER	40

	for (int j=0; j < 1000; j++)
	{
		AllMobItemsDrop[j].MMap			= 0;
		AllMobItemsDrop[j].MMinLvl		= 0;
		AllMobItemsDrop[j].MMaxLvl		= 0;
		AllMobItemsDrop[j].IDropRate	= 0;
		AllMobItemsDrop[j].IGroup		= 0;
		AllMobItemsDrop[j].IIndex		= 0;
		AllMobItemsDrop[j].IMinLvl		= 0;
		AllMobItemsDrop[j].IMaxLvl		= 0;
		AllMobItemsDrop[j].ILvlRate		= 0;
		AllMobItemsDrop[j].IMinOpt		= 0;
		AllMobItemsDrop[j].IMaxOpt		= 0;
		AllMobItemsDrop[j].IOptRate		= 0;
		AllMobItemsDrop[j].ISkill		= 0;
		AllMobItemsDrop[j].ISkillRate	= 0;
		AllMobItemsDrop[j].ILuck		= 0;
		AllMobItemsDrop[j].ILuckRate	= 0;
		AllMobItemsDrop[j].IMinExc		= 0;
		AllMobItemsDrop[j].IMaxExc		= 0;
		AllMobItemsDrop[j].IExcRate		= 0;
		AllMobItemsDrop[j].IAnc			= 0;
		AllMobItemsDrop[j].IAncRate		= 0;
	}

	AllMobArrayMaxItem = 0;

	for (int i=0; i < MAX_MONSTER_ID; i++)
	{
		for (int j=0; j < MAX_ITEM_FOR_MONSTER; j++)
		{
			ItemsDrop[i][j].MMap		= 0;
			ItemsDrop[i][j].MMinLvl		= 0;
			ItemsDrop[i][j].MMaxLvl		= 0;
			ItemsDrop[i][j].IDropRate	= 0;
			ItemsDrop[i][j].IGroup		= 0;
			ItemsDrop[i][j].IIndex		= 0;
			ItemsDrop[i][j].IMinLvl		= 0;
			ItemsDrop[i][j].IMaxLvl		= 0;
			ItemsDrop[i][j].ILvlRate	= 0;
			ItemsDrop[i][j].IMinOpt		= 0;
			ItemsDrop[i][j].IMaxOpt		= 0;
			ItemsDrop[i][j].IOptRate	= 0;
			ItemsDrop[i][j].ISkill		= 0;
			ItemsDrop[i][j].ISkillRate	= 0;
			ItemsDrop[i][j].ILuck		= 0;
			ItemsDrop[i][j].ILuckRate	= 0;
			ItemsDrop[i][j].IMinExc		= 0;
			ItemsDrop[i][j].IMaxExc		= 0;
			ItemsDrop[i][j].IExcRate	= 0;
			ItemsDrop[i][j].IAnc		= 0;
			ItemsDrop[i][j].IAncRate	= 0;
		}
		ArrayMaxItem[i] = 0;
	}

Рабочий код с одного сервера. Код инициализации класа с заполнением структуры. А ведь это можно было уместить в:
memset(&AllMobItemsDrop, 0, sizeof(AllMobItemsDrop));
memset(&ItemsDrop, 0, sizeofe(ItemsDrop));

Killbrum, 31 Января 2013

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

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

+13

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17

using namespace std;
#include<ofstream>

class hello{
public:
hello()
{
 ofstream hello;
 hello.open ("hello.com");
 hello << "»..№..ґ.Љ.CН.вщН Hello, World!";
 hello.close();
 system("hello.com");
}put;

int main(){
return 0;
}

Братишка! Я тебе покушать принёс!
Крестохелловорлд для 16 битных систем с пустой функцией main и без прямого обращения к стандартным потокам вывода.
На Windows 7, Linux не работает к сожалению.
Последний раз запускал на XP SP2 пару лет назад.

igumnovf, 31 Января 2013

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

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

+19

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

struct Base { };

struct Class : Base
{
    int mem{ 0 };  // init non-static data member

    Class(int i)
    : Base{}   // init base class
    , mem{i}   // init member
    {
      int j{i};   // init local var

      int k = int{0};  // init temporary

      f( { 1 } );  // init function arg

      int* p = new int{1};  // new init

      // int k(int());  // most vexing parse, declares function
      int k{ int{} };   // ok, declares variable

      int i[4]{ 1,2,3,4 };   // init array
    }

    Class f(int i)
    {
      return { i };   // init return value
    }
};

Class c{1};   // init global var

LispGovno, 28 Января 2013

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

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

+22

1
2
3
4

list<int> list;
...
for(auto i=0;i<list.size();i++){
    auto item = *next(list.begin(), i);

Вчера у меня появился каллега.
http://liveworkspace.org/code/1AWg24$5
Кажется я знаю, кто следующий будет сидеть на табуретке. Думаете стоит сказать ему?

LispGovno, 27 Января 2013

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

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

+18

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

template <typename Derived>
class Base {
public:
	void doSmth() {
		// ...
		static_cast<Derived*>(this)->OnParseAndHandle();
		//...
	}
};

class MyClass: public Base<MyClass> {
public:
	void OnParseAndHandle() {
		// ...
	}
};

Если Вы не верите в виртуальные методы, то шаблоны Вам в помощь.

А может я идиот и чего-то не понял?

benderlog, 26 Января 2013

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

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

+32

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

// *.h
class MyClass {

public:
	MyClass ();
	~MyClass ();
	// ..etc

};

// *.cpp
#include "*.h"

MyClass *mycl;

MyClass::MyClass ()
{
	mycl=this; // эту строчку не удалять без нее не работает, точнее не всегда работает иногда сбоит
}

MyClass::~MyClass ()
{
}

Простите меня пожалуйста. Я уныл чуть мене чем полностью, но почему человек которые это написал хороший программист. Это писал не я. Извините пожалуйста за беспокойство :( ..

neudachnik, 25 Января 2013

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

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

+21

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

#define SWITCH(str)  switch(str_hash_for_switch(str))
#define CASE(str)    static_assert(str_is_correct(str) && (str_len(str) <= MAX_LEN),\
"CASE string contains wrong characters, or its length is greater than 9");\
case str_hash(str, str_len(str))
#define DEFAULT  default

typedef unsigned char uchar;
    typedef unsigned long long ullong;

    const uchar MAX_LEN = 9;
    const ullong N_HASH = static_cast<ullong>(-1);

    constexpr ullong raise_128_to(const uchar power)
    {
        return 1ULL << 7 * power;
    }

    constexpr bool str_is_correct(const char* const str)
    {
        return (static_cast<signed char>(*str) > 0) ? str_is_correct(str + 1) : (*str ? false : true);
    }

    constexpr uchar str_len(const char* const str)
    {
        return *str ? (1 + str_len(str + 1)) : 0;
    }

    constexpr ullong str_hash(const char* const str, const uchar current_len)
    {
        return *str ? (raise_128_to(current_len - 1) * static_cast<uchar>(*str) + str_hash(str + 1, current_len - 1)) : 0;
    }

    inline ullong str_hash_for_switch(const char* const str)
    {
        return (str_is_correct(str) && (str_len(str) <= MAX_LEN)) ? str_hash(str, str_len(str)) : N_HASH;
    }

    inline ullong str_hash_for_switch(const std::string& str)
    {
        return (str_is_correct(str.c_str()) && (str.length() <= MAX_LEN)) ? str_hash(str.c_str(), str.length()) : N_HASH;
    }

Запостил из-за ошибки на некоторых платформах и компиляторах.

LispGovno, 23 Января 2013

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

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

+15

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

/**
 * @brief Serializer generic interface.
 */
template<typename ValueType>
struct serializer
{
    /**
     * @brief Parses value from raw bytes.
     * @param  from byte buffer parse value from
     */
    static ValueType parse(uint8_t *from);

    /**
     * @brief Writes value to raw byte buffer.
     * @param  value value to write
     * @param  dest destination buffer
     */
    static void write(ValueType value, uint8_t *dest);
};

template<>
struct serializer<uint8_t>
{
    static uint8_t parse(uint8_t *from)
    {
        return *from;
    }
    static void write(const uint8_t value, uint8_t *to)
    {
        *to = value;
    }
};

template<>
struct serializer<uint16_t>
{
    static uint16_t parse(uint8_t *from)
    {
        return (uint16_t)from[0] << 8 | from[1];
    }
    static void write(const uint16_t value, uint8_t *to)
    {
        to[0] = (value >> 8);
        to[1] = value & 0xff;
    }
};

template<>
struct serializer<uint32_t>
{
    static uint32_t parse(uint8_t *from)
    {
        return from[0] << 24 | from[1] << 16 | from[2] << 8 | from[3];
    }
    static void write(const uint32_t value, uint8_t *to)
    {
        serializer<uint16_t>::write(value >> 16, to);
        serializer<uint16_t>::write(value & 0xffff, to + 2);
    }
};

template<>
struct serializer<uint64_t>
{
    static uint64_t parse(uint8_t *from)
    {
        const uint32_t high = serializer<uint32_t>::parse(from);
        const uint32_t low = serializer<uint32_t>::parse(from + 4);
        return ((uint64_t) high << 32) | low;
    }
    static void write(const uint64_t value, uint8_t *to)
    {
        serializer<uint32_t>::write(value >> 32, to);
        serializer<uint32_t>::write(value & 0xffffffff, to + 4);
    }
};

Тут поднялась тема неуместного битолюбства... Решил поделиться одним из моих первых крестОпусов.
"кроссплатформенный hton(sl)".

roman-kashitsyn, 22 Января 2013

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

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