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

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

+56

01
02
03
04
05
06
07
08
09
10
11

#include <iostream>
using namespace std;

int main() {
	int i = 5;
	int* p1 = &i;
	volatile int* p2 = &i;
	cout << p1 << endl;
	cout << p2 << endl;
	return 0;
}

http://ideone.com/hpw4CB

LispGovno, 08 Февраля 2014

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

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

+51

1
2
3
4
5
6
7
8
9

#include <iostream>
using namespace std;

int main() {
    const int ci = 42;
    auto f = [ci]() mutable { std::cout << ++ci << '\n'; };
    f();
    return 0;
}

http://ideone.com/0P72sN
А слона то я и не приметил.

LispGovno, 07 Февраля 2014

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

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

+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
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
86
87
88
89
90
91
92
93
94

#include <time.h>
#include <string>
#include <iostream>
#include <functional>

using namespace std::placeholders;

class F
{
        int inc;

public:

        F( int inc_v ): inc( inc_v ) {};

        int calc( int x )
        {
                return x + inc;
        };
};

F a1( -10 );
F a2( 11 );

int f1( int x )
{
        return x - 10;
};

int f2( int x )
{
        return x + 11;
};

        struct my_ftor
        {
                F *obj;
                int (F::*meth)(int);
                int operator()(int x)
                {
                        return (obj->*meth)( x );
                };
                my_ftor() {};
                my_ftor( F *x, int(F::*y)(int) ) : obj(x), meth(y) {};
        };

template<typename functor_type>
void test( std::function<functor_type(int)> filler, char *name )
{
        const int size = 1000;
        const int iters = 10000;

        int beg_time, end_time;

        functor_type funcs[ size ];

        beg_time = clock();
        for ( int i = 0; i < iters; i++ )
        {
                for ( int j = 0; j < size; j++ )
                {
                        funcs[ j ] = filler(j);
                }
        };
        end_time = clock();
        float creation = ((float)(end_time - beg_time) / CLOCKS_PER_SEC);

        beg_time = clock();
        int res = 0;
        for ( int i = 0; i < iters; i++ )
        {
                for ( int j = 0; j < size; j++ )
                {
                        res = funcs[ j ]( res );
                };
        };
        end_time = clock();
        float execution = ((float)(end_time - beg_time) / CLOCKS_PER_SEC);
        std::cout << name << " creation time: " << creation << " execution time: " << execution << " result: " << res << "\n";
}

int main(int c, char * * v) 
{
        test<int(*)(int)>( [](int i) {return i % 2 ? f1 : f2; }, "simple &function test" );

        test<std::function<int(int)>>( [](int i) {return i % 2 ? f1 : f2; }, "functor &function test" );

        test<std::function<int(int)>>( [](int i) {return i % 2 ? std::bind( &F::calc, &a1, _1 ) : std::bind( &F::calc, &a2, _1 ); }, "functor &object test" );

        test<my_ftor>( [](int i) {return i % 2 ? my_ftor( &a1, &F::calc ) : my_ftor( &a2, &F::calc ); }, "obj->*meth struct test" );

        std::cout << "END\n";
        return 0;
}

http://ideone.com/1iNzR
Чем код так долго занимается?
simple &function test creation time: 0.05 execution time: 0.09 result: 5000000
functor &function test creation time: 0.51 execution time: 0.14 result: 5000000
functor &object test creation time: 1.25 execution time: 0.14 result: 5000000
obj->*meth struct test creation time: 0.12 execution time: 0.05 result: 5000000
END

LispGovno, 05 Февраля 2014

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

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

+39

01
02
03
04
05
06
07
08
09
10
11

#include <iostream>
#include <memory>

struct Test {
    ~Test() { std::cout << "~Test\n"; }
};

int main() {
  std::shared_ptr<void> ptr( new Test );
  return 0;
}

http://ideone.com/xXPWhE

Но:

#include <iostream>

#include <memory>



struct Test

{

    ~Test() { std::cout << "~Test\n"; }

};



int main() {

	std::shared_ptr<void> ptr( (void*) new Test );

	return 0;

}

http://ideone.com/jhNvpJ

LispGovno, 05 Февраля 2014

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

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

+46

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

//Сом ненужный щит

#include <iostream>
using namespace std;

#include <string>
#include <iostream>

struct Tracer {
   Tracer(void)
      :m_name("(none)")
   {
      std::cout << "[" << m_name << "]    " << __PRETTY_FUNCTION__ << std::endl;
   }
   Tracer(const std::string & name)
      :m_name(name)
   {
      std::cout << "[" << m_name << "]    " << __PRETTY_FUNCTION__ << std::endl;
   }
   Tracer(const Tracer & other)
      :m_name(other.m_name)
   {
      std::cout << "[" << m_name << "]    " << __PRETTY_FUNCTION__ << std::endl;
   }
   Tracer(const Tracer && other)
      :m_name(other.m_name)
   {
      std::cout << "[" << m_name << "]    " << __PRETTY_FUNCTION__ << std::endl;
   }
   Tracer & operator=(const Tracer & other) {
      m_name = other.m_name;
      std::cout << "[" << m_name << "]    " << __PRETTY_FUNCTION__ << std::endl;
      return *this;
   }
   Tracer & operator=(const Tracer && other) {
      m_name = other.m_name;
      std::cout << "[" << m_name << "]    " << __PRETTY_FUNCTION__ << std::endl;
      return *this;
   }
   ~Tracer() {
      std::cout << "[" << m_name << "]    " << __PRETTY_FUNCTION__ << std::endl;
      m_name="You looser!";
   }

   std::string m_name;
};

//Тот щит, ради чего всё затевалось

template<class T> const T&  Min(const T &x, const T &y) { return (x.m_name < y.m_name) ? x : y; }

int main() {
  const Tracer& mr = Min(Tracer("a"), Tracer("b"));
  cout<<"Some work with mr: "<<mr.m_name<<endl;
  return 0;
}

[b] Tracer::Tracer(const string&)
[a] Tracer::Tracer(const string&)
[a] Tracer::~Tracer()
[b] Tracer::~Tracer()
Some work with mr:
Этож сколько я коммитов сделал с возвратом константной ссылки на константный параметр.

LispGovno, 04 Февраля 2014

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

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

+36

1
2
3

t = Min(::std::cref(x), ::std::cref(y));
//или в зависимости от ситуации 
t = Min(::std::move(x), ::std::move(y));

Абстракционизм или Кубизм?

LispGovno, 04 Февраля 2014

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

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

+31

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

#include <string>
#include <iostream>
#include <functional>
 
using namespace std;

template<class L, class... Ls>
struct OL: L, OL<Ls...>{
   OL(const L& l, const Ls&... ls): L(l), OL<Ls...>(ls...){}
   using L::operator();
   using OL<Ls...>::operator();
};

template<class L1, class L2>
struct OL<L1, L2>: L1, L2{
   OL(const L1& l1, const L2& l2): L1(l1), L2(l2){}
   using L1::operator();
   using L2::operator();
};


template<class... Ls>
OL<Ls...> OverloadLambda(const Ls&... l){
   return OL<Ls...>(l...);
}

template<class L>
L OverloadLambda(const L& l){
   return l;
}

void OverloadLambda(void) = delete;

int main() {
   int i=5;
   auto lambda=OverloadLambda(  [=](int v){cout<<__func__<<" "<<i<<" "<<v<<" int"<<endl;},
                                [=](string v){cout<<__func__<<" "<<i<<" "<<v<<" string"<<endl;},
                                [=](float v){cout<<__func__<<" "<<i<<" "<<v<<" float"<<endl;});
   lambda(0);
   lambda("Hello");
   lambda(1.0f);
   i=600;
   auto lambda1=OverloadLambda( [=](int v){cout<<__func__<<" "<<i<<" "<<v<<" int"<<endl;});
   lambda1(4);
   ///*auto lambda0 =*/ OverloadLambda();
   return 0;
}

Специальная олимпиада объявляется открытой!
http://ideone.com/y14z5Y
Там много другого кода и какой-то из старых тем, а мне лень весь облазить.

LispGovno, 03 Февраля 2014

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

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

+33

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

template<typename F, typename... Fns>
struct Overloaded
{
  std::tuple<F,Fns...> fns;
  
  // эта и следующая за ней функция нужны для рекурсивного
  // накопления кортежа из всех входящих функций
  template<typename First, typename... Others>
  std::tuple<First,Others...> collect(First f, Others... others) {
    auto t = std::make_tuple(f);
    return std::tuple_cat(t, collect(others...));
  }
  template<typename Single>
  std::tuple<Single> collect(Single f) {
    return std::make_tuple(f);
  }
  
  Overloaded(F f, Fns... others) {
    // сохраняем кортеж функций
    fns = collect(f, others...);
  }
};

template<typename F, typename... Fns>
Overloaded<F,Fns...> make_overloaded(F f, Fns... fns) {
  return Overloaded<F,Fns...>(f,fns...);
}

//...

void F1(int) {}
void F2(int, float) {}
// ...
auto f = make_overloaded(F1, F2);

Не хочется связываться с бустом ввиду его убогости громоздкости. Поэтому пытаюсь сделать сам на чистом C++11 без макросов.
Не понятно теперь как перегрузить оператор ()?
Задействовать enable_if? Ни чего в голову не приходит.
Есть у кого идеи?
Оттуда

LispGovno, 03 Февраля 2014

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

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

+24

1

int f(int = 7, int * = nullptr, int (*(*)(double))[3] = nullptr){

http://ideone.com/BcZ7Ja

LispGovno, 02 Февраля 2014

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

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

+15

1
2
3
4
5
6
7
8
9

#define TEST_MODE ON

...

#ifdef TEST_MODE
#    include "fake_singelton.h"
#else
#    include "work_singelton.h"
#endif

оттуда

LispGovno, 01 Февраля 2014

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

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