Список говнокодов пользователя LispGovno

Всего: 223

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

+1

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

struct Vector2f{float x, y;};
struct Vector3f{float x, y, z;};
struct Tensor3f{float xx, xy, xz, yy, yz, zz;};
struct Matrix3x3f{float data[9];};
struct Space2
{
  typedef Vector2f Vector;
};
struct Space3
{
  typedef Vector3f Vector;
};


template<typename Space>
struct ParticleSystem
{
  template<typename T>
  struct ParticleData{};

  template<> 
  struct ParticleData<Space2>
  {
    float orientation;
    float invInertia;
  };

  template<> 
  struct ParticleData<Space3>
  {
    typename Matrix3x3f orientation;
    typename Tensor3f inertiaTensor;
  };

  struct Particle : public ParticleData<Space>
  {
    typename Space::Vector pos, velocity;
  };

  template<typename T>
  void DumpParticle(){}

  template<>
  void DumpParticle<Space2>()
  {
    printf("%f %f", particles[0].orientation, particles[0].invInertia);
  }

  template<>
  void DumpParticle<Space3>()
  {
    printf("%f %f", particles[0].orientation.data[0], particles[0].inertia.xx);
  }
  
  void DumpParticles()
  {
    DumpParticle<Space>();
  }
  std::vector<Particle> particles;
};

Хочу объединить трехмерный и двухмерный движок.

LispGovno, 26 Января 2014

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

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

+4

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

#include <iostream>
using namespace std;

    void enable_misalignment_access_check(){
      cout<<"begin "<<__FUNCTION__<<endl;
      __asm__(
        "pushf\n"
        "orl $(1<<18),(%esp)\n"
        "popf\n"
      );
      cout<<"end "<<__FUNCTION__<<endl;
    }

void alignedAccess(volatile unsigned char foo[])
{
  cout<<"begin "<<__FUNCTION__<<endl;
  volatile int t = *(int *)(foo);
  cout<<"end "<<__FUNCTION__<<endl;
}

void unalignedAccess(volatile unsigned char foo[])
{
  cout<<"begin "<<__FUNCTION__<<endl;
  volatile int t = *(int *)(foo+1);
  cout<<"end "<<__FUNCTION__<<endl;
}

unsigned char foo[] = { 1, 2, 3, 4, 5, 6 };

int main(void)
{
    alignedAccess(foo);
    unalignedAccess(foo);
    enable_misalignment_access_check();
    alignedAccess(foo);
    unalignedAccess(foo);
    return 0;
}

http://codepad.org/D6b5asES

begin alignedAccess end alignedAccess 

begin unalignedAccess end unalignedAccess 

begin enable_misalignment_access_check end enable_misalignment_access_check 

begin alignedAccess end alignedAccess 

begin unalignedAccess 

Bus error

LispGovno, 26 Января 2014

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

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

+19

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

template<class T>
class smartest_ptr
{
std::unique_ptr<T> m_p;
std::array<char, sizeof(T)> m_data; // массив размером с объект
public:
void New() {m_p = new(&m_data) T();}
operator ->() {return m_p;}
};

// никакого выделения памяти из кучи!
smartest_ptr<CFoo> pFoo; // типа nullptr
// pFoo->Method(); - нельзя, nullptr
pFoo.New();
pFoo->FooMethod();
pFoo->AnotherMeth();

-- Чип и ДейлКрестовики спешат на помощь тем у кого медленная куча.
-- Откуда спешат?
-- Оттуда.

LispGovno, 26 Января 2014

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

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

+9

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

#include <iostream>
#include <iterator>
#include <algorithm>
#include <array>
#include <memory>
using namespace std;

template<size_t N1, size_t N2, class T1, class T2,
class T = typename common_type<T1, T2>::type>
T (*concatCArray(const T1(&arr1)[N1], const T2(&arr2)[N2]))[N1+N2]{
  const auto result = (T(*)[N1+N2]) new T[N1+N2];
  copy(arr2, end(arr2), copy(arr1, end(arr1), *result));
  return result;
}
template<std::size_t N, class T>
void viewCArrayPtr(T (*arr)[N]){
  copy(*arr, end(*arr), ostream_iterator<T>(cout, " "));
}
template<size_t N1, size_t N2, class T1, class T2,
class T = typename remove_const<typename common_type<T1, T2>::type>::type>
array<T, N1+N2> concatArray(const array<T1, N1> &arr1, const array<T2, N2> &arr2){
  array<T, N1+N2> result;
  copy(begin(arr2), end(arr2), copy(begin(arr1), end(arr1), result.begin()));
  return result;
}
template<std::size_t N, class T>
void viewArray(const array<T, N> arr){
  copy(begin(arr), end(arr), ostream_iterator<T>(cout, " "));
}

int main() {
  int arr1[]{0,1,2,3}, arr2[]{4,5,6};
  auto ca = concatCArray(arr1, arr2);
  unique_ptr<int[]> safe(*ca);
  viewCArrayPtr(ca);
  cout<<endl;
  array<float, 2> a {1,2.5};
  array<int, 3> b{3, 4, 5};
  viewArray(concatArray(a, b));
  return 0;
}

От туда.
http://ideone.com/3KjycI

LispGovno, 22 Января 2014

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

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

+4

1
2
3

namespace std
{
  template<class T, class T2> class common_type<::std::shared_ptr<T>, ::std::shared_ptr<T2> >: public ::std::common_type<T, T2>{};

LispGovno, 22 Января 2014

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

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

+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

class Base
{
  void fooo() { ... }
};
class Derived
{
  void fooo() { ... }
};
void DoSmth (Base& b)
{
  b.fooo();
};
Derived d; 
DoSmth(d); // полная статика, так что там внутри вызовется метод базы
void DoSmth (polymorth<Base>& b) // это структура, которая хранит ссылку на объект и ссылку на таблицу методов
{
  b.fooo();
};
polymorth<Base>b = Derived(); 
// инициализация при объявлении, чтобы было понятно, сколько памяти выделить
// в структуре записалась таблица методов Derived
DoSmth(b);  // вызовется метод наследника
...
// в конце вызывается деструктор наследника

Творчество оттуда.
"Основная идея - избавить от вопроса "делать ли деструктор виртуальным"

LispGovno, 22 Января 2014

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

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

+10

1

typedef boost::shared_ptr<LPDIRECT3D9> Direct3dShared;

Те кто знают, что такое в гейдеве LPDIRECT3D9 и IDirect3D9 - поймут.
Думаю сегодня даже не нужно писать с какого это сайта.

LispGovno, 22 Января 2014

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

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

+13

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
83
84
85

#include <iostream>
using namespace std;

// -- robot`s internal closed implementation --
int  data1[] = { 0, 1, 2 }; char data2[] = { 42 };

// -- robot`s API 
const int *GetMechaData1() { return data1; }
size_t GetMechaData1Size() { return 3; }
const char *GetMechaData2(){ return data2; }
size_t GetMechaData2Size() { return 1; }

// -- pentagon`s internal closed implementation --
//--------------------если T равно U, то результат будет D, а иначе - G------------//
template<class T, class U, class D, class G> struct SelectIF     { typedef G type; };
template<class T, class D, class G>  struct SelectIF<T, T, D, G> { typedef D type; };

// -- pentagon`s API 
enum { eMAXBUFER = 200 * sizeof(int) };
template<class T, size_t N>void AcceptData(const T(&src)[N])
{
    typedef typename SelectIF<T, char, int, T>::type Cast;
    enum { is_char = std::is_same<T,char>::value };

    cout << "received data:\n";
    const size_t num = (N<eMAXBUFER) ? N : eMAXBUFER;

    if (is_char)
        for (size_t n = 0; n < num; ++n)
            cout << "char code = " << (Cast)src[n] << " : char = '" << src[n] << "'\n";
    else
        for (size_t n = 0; n<num; ++n)
            cout << "item = " << src[n] << endl;
}

// client code
template<class T, size_t N> struct Adapter
{
    typedef Adapter<T, N + 1> Next;
    void Pass(const T* data, const size_t num)
    {
        if (N < num)
        {
            Next().Pass(data, num);
            return;
        }

        T(&arr)[N] = reinterpret_cast<  T(&)[N] > (mBuf);
        for (size_t n = 0; n< N; ++n) arr[n] = data[n];
        AcceptData(arr);
    }

    size_t mLen;
    T mBuf[eMAXBUFER];
};

template<class T> struct Adapter<T, eMAXBUFER>
{
    void Pass(const T* data, const size_t)
    {
        for (size_t n = 0; n< eMAXBUFER; ++n)  mBuf[n] = data[n];
        AcceptData(mBuf);
    }

    size_t mLen;
    T mBuf[eMAXBUFER];
};


Adapter<int,  1> adapter1;
Adapter<char, 1> adapter2;

int main()
{
    {
        const auto data = GetMechaData1();
        const auto num = GetMechaData1Size();
        adapter1.Pass(data, num);
    }
    {
        const auto data = GetMechaData2();
        const auto num = GetMechaData2Size();
        adapter2.Pass(data, num);
    }
}

Крестушки раскрестушились, а подраться не решились.
Под катом ещё несколько вариантов.

LispGovno, 19 Января 2014

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

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

+7

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

#include <iostream>
#include <alloca.h>
#include <stdlib.h>
#include <new>
using namespace std;

int main(void) {
  const size_t N = 5+rand()%4;
  char* arr = ::new (alloca(N)) char[N]{1,2,3,4};
  for(size_t i=0; i<N; ++i)
    cout<<(int)arr[i]<<endl;
  cout<<"ok";
  return 0;
}

http://ideone.com/pax1TF

LispGovno, 18 Января 2014

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

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

+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

#include <vector>
#include <iostream>
using namespace std;

// -- tools

// макет времени компиляции определяет количество элементов массива указанного в аргументе
template<class T, size_t N> char (&Size(  T (&arr)[N] ) )[N];


// -- internal closed implementation --
int data1[] = {0, 1, 2};
char data2[] = {42};

const int (  &GetMechaData1()  ) [ sizeof( Size(data1) )  ] { return data1; }
const char(  &GetMechaData2()  ) [ sizeof( Size(data2) )  ] { return data2; }
          
// -- API

//--- функции возвращают ссылки на массивы: например такого: const int[ sizeof( Size(data1) ]
const int (  &GetMechaData1()  ) [ sizeof( Size(data1) )  ];
const char(  &GetMechaData2()  ) [ sizeof( Size(data2) )  ];


// client code
template<class T, size_t N> void ViewArray(const T (&arr)[N])
{
    cout<<"data stored: \n";
    for( auto& item: arr )
        cout<< "item : "<<item<<endl;
}

int main()
{
    ViewArray( GetMechaData1() );
    ViewArray( GetMechaData2() );
    
   return 0;
}

http://rextester.com/AEINWM88529

LispGovno, 18 Января 2014

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

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