1. C++ / Говнокод #20272

    +3

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    void MyZKbMain::keyPressEvent(QKeyEvent* k)
    {
    	QPixmap pm; pm.load("ruleta_usr.png");
    	ZConfig Num(QString("numeros.cfg"), true);
    	ZConfig Hist(QString("historial.cfg"), true);
    
    	switch (k->key())
    	{
    	case 0x1046: //Boton Verde
    	break;
    
    	case 0x1030: //Boton Verde
    	calcular=0;
    	reboot = new ZMessageDlg("zRoulette", 
    		QString("Sistema Ubeda 0.5\nBasado en el Sistema de Cuadros\n\nwww.developermoto.com/es\nwww.modmymoto.com\n\n(C)2009 RacingLocura07, CepiPerez"), 
    		(ZMessageDlg::MessageDlgType)2, 0, this,"about", true, 0);
    	reboot->setTitleIcon(pm); reboot->show();
    	break;
    
    	case 0x1031: //Boton Rojo
    	calcular=0;
    	reboot = new ZMessageDlg("zRoulette", "Desea salir?", 
    			(ZMessageDlg::MessageDlgType)1, 0, this,"about", true, 0);
    	reboot->setTitleIcon(pm); reboot->show();
    	if(reboot->exec()==1) { exit(); }
    	else { update(); break; }
    	
    	case 0x1012: //Tecla de Navegacion De Izquierda
    	calcular=0;
    	if (current > 1 ) { --current; update(); break; } else { break; }
    
    	case 0x1013: //Tecla de Navegacion De Arriba
    	calcular=0;
    	if ( current > 3 ) { ------current; update(); break; } else { break; }
    
    	case 0x1014: //Tecla de Navegacion De Derecha
    	calcular=0;
    	if (current < 36 ) { ++current; update(); break; } else { break; }
    
    	case 0x1015: //Tecla de Navegacion De Abajo
    	calcular=0;
    	if (current < 34 ) { ++++++current; update(); break; } else { break; }
    
    	case 0x1038: //Softkey Izquierda
    	calcular=0;
    	reboot = new ZMessageDlg("zRoulette", "Desea reinciar la Ruleta?", (ZMessageDlg::MessageDlgType)1, 0, this,"about", true, 0);
    	reboot->setTitleIcon(pm); reboot->show();
    	if(reboot->exec()==1) { system("rm numeros.cfg"); system("rm historial.cfg"); current = 1; jugadas = 0; lista.clear(); update(); break; }
    	else { update(); break; }
    
    	case 0x103a: //Softkey Derecha
    	int temp = Hist.readNumEntry ( QString("HISTORIAL"), QString("18"), 0 );
    	if ( temp != 0 ) {
    		reboot = new ZMessageDlg("zRoulette", "Desea limpiar las jugadas dejando las ultimas 18 solamente?", 
    				(ZMessageDlg::MessageDlgType)1, 0, this,"about", true, 0); reboot->setTitleIcon(pm); reboot->show();
    		if(reboot->exec()==1) { 
    		  for ( int l=1; l<37; ++l) { Num.writeEntry ( QString("NUMEROS"), QString("%1").arg(l), QString("0") ); }
    		  for ( int j=1; j<19; ++j) {
    			int temp = Hist.readNumEntry ( QString("HISTORIAL"), QString("%1").arg(j), 0 );
    			if ( temp > 0 ) { Num.writeEntry ( QString("NUMEROS"), QString("%1").arg(temp), QString("1") ); }
    		  }	calcular=1; update(); break; 
    		} else { break; }
    	} else {
    		reboot = new ZMessageDlg("zRoulette", "Deben haber mas de 18 bolas jugadas para el reinicio parcial.", 
    			(ZMessageDlg::MessageDlgType)2, 0, this,"about", true, 0); reboot->setTitleIcon(pm); reboot->show(); break;
    	}
    
    	case 0x1004:  //Boton Central
    	valortemp = Num.readNumEntry(QString("NUMEROS"), QString("%1").arg(current), 0 );
    	if ( valortemp < 1 ) { valortemp=0; } ++valortemp;
    	Num.writeEntry(QString("NUMEROS"), QString("%1").arg(current), valortemp);
    
    	int lugar=0; for ( int j=18; j>0; --j)
    	{ int temp = Hist.readNumEntry ( QString("HISTORIAL"), QString("%1").arg(j), 0 ); if ( temp==0 ) { lugar=j; } }
    	
    	if ( lugar > 0 ) {
    	  Hist.writeEntry ( QString("HISTORIAL"), QString("%1").arg(lugar), QString("%1").arg(current) );
    	} else {
    	  for ( int j=1; j<18; ++j) {
    		int temp = Hist.readNumEntry ( QString("HISTORIAL"), QString("%1").arg(j+1), 0 ); 
    		Hist.writeEntry ( QString("HISTORIAL"), QString("%1").arg(j), QString("%1").arg(temp) ); 
    	  }
    	  Hist.writeEntry ( QString("HISTORIAL"), QString("18"), QString("%1").arg(current) ); 
    	}
    	calcular=1;
    	update();
    	}
    }

    Разработчики из солнечной Аргентины. Кусочек кода из кастомного "лаунчера" для телефонов Motorola на платформе MotoMAGX (Linux 2.6.10, Qt 2.3.8, gcc 3.4.3). АДИЩЕ С ЦАРСКИМИ АНРОЛЛАМИ: https://github.com/crutchwalkfactory/motocakerteam/blob/master/Projects/MotoDesk/MyZKbMain.cpp

    Что интересно, это всё как-то работало и даже довольно мило выглядело: http://exlmoto.ru/wp-content/Images/AOne/1.gif

    Запостил: Tsiklonyashka, 26 Июня 2016

    Комментарии (63) RSS

    • ++++++++++++++++++current;
      На данной платформе 3 инкремента быстрее, чем сложение с 3?
      Ответить
      • А может быть, они избавлялись от магических констант, как могли?
        Ответить
      • Это брейнфак
        Ответить
        • Мы кстати хотели сделать брейнфак на крестах. Но подходящих операторов маловато ;(
          Ответить
          • > подходящих операторов маловато
            А чего не хватило?

            > Мы
            С женой?
            Ответить
            • > С женой?
              С подушкой же :3 Под "мы" участники ГК имелись в виду.

              Ну для красоты нужно же чтобы операторы были по одну сторону, или все слева или все справа. Круглые и квадратные скобки сразу отлетают, внутри них придётся писать что-то помимо операторов. Бинарные операторы тоже отлетают. Постфиксных операторов очень мало. Вот и остаются префиксные ~ ! + - ++ -- * и &. Но из-за ++ приходится добавлять пробелы, некрасиво...
              Ответить
              • >Постфиксных операторов очень мало.
                Прохладная стори
                a.op1().op2().op(3);
                Ответить
                • Ну это ж уже не брейнфак... Так можно и тупо буквами нахуярить:
                  bf->p->p->m->d->p->l->m->r->u->o; // ++-[+<->].
                  Ответить
                  • Пример реализации в студию!
                    Ответить
                    • Как-то так:
                      class BrainFuckPtr {
                      public:
                          BrainFuckPtr(BrainFuck *bf, char op) : m_bf(bf), m_op(op) {}
                          BrainFuck *operator ->() const { m_bf->do(m_op); return m_bf; }
                      private:
                          BrainFuck *m_bf;
                          char m_op;
                      };
                      
                      class BrainFuck {
                      public:
                          BrainFuckPtr p;
                          // ...
                          BrainFuckPtr o;
                          BrainFuck() : p(this, '+'), /* ... */ o(this, '.') { }
                          void do(char c) { /* ... */ };
                      };
                      
                      BrainFuck *bf = new BrainFuck();
                      Ответить
                      • нуже доделай это!)
                        Ответить
                        • Зачем? Главная часть концепта же описана... Дальше всё тривиально.
                          Ответить
                        • Да очевидно же. Такое везде можно сделать.

                          Возвращаем себя, и только меняем внутренний стейт в зависимости от аргумента.

                          Своеобразный флюентно-монадический конечный автомат.
                          Ответить
                      • operator ->()

                        В крестах ещё и стрелка перегружается? Осталось только ввести перегрузку точки с запятой и фигурных скобок.
                        Ответить
                        • google://Agda
                          Пример: https://gist.github.com/bishboria/8568581
                          Ответить
                        • А как, по-твоему, реализован синтаксический сахар для auto_ptr<> и иже с ними, позволяющий писать
                          auto_ptr<some_struct> P;
                          P->some_struct_member
                          вместо
                          auto_ptr<some_struct> P;
                          P.get()->some_struct_member
                          Ответить
                          • да даже итераторы это перегружают, тоже мне, открытие года инканус-грея
                            Ответить
                          • Спасибо. Теперь я понял, почему в одном и том же коде используют и конструкцию вида (*p).field, и конструкцию вида p->field: а вдруг -> перегружен.
                            Ответить
                            • 1) -> для примитивных типов (указателей) не перегружается.
                              2) Для пользовательских типов перегрузить можно и *

                              Так что это просто отсутствие единого стиля в команде
                              Ответить
                              • (*p).field - это не отсутствие стиля. Это дно какое-то.
                                Ответить
                              • Ну вдруг * и -> по-разному перегружены?
                                Ответить
                                • 1. operator * должен возвращать T&
                                  2. operator -> должен возвращать T*
                                  3. возвращаемые значения должны указывать на один и тот же объект

                                  И да спасет тебя бог от программиста, который найдет в твоём коде несоответствие одному из этих трех правил.
                                  Ответить
                                  • > operator * должен возвращать T&
                                    > 2. operator -> должен возвращать T*
                                    > И да спасет тебя бог от программиста

                                    Я нашёл несоответствие в STL, в std::vector<bool>. Кого должен спасти бог?
                                    Ответить
                                    • И какое несоответствие ты нашел? А то сдается мне кое-кто плохо вчитывался в стандарт
                                      Ответить
                                      • > И какое несоответствие ты нашел?

                                        Я нашёл несоответствие STL твоим "правилам".

                                        operator* у итератора vector<bool>, у которого value_type = bool, возвращает волшебный прокси-bit reference, а не T&, как ты написал.

                                        > А то сдается мне кое-кто плохо вчитывался в стандарт

                                        Я даже знаю, кто. К примеру, для итераторов r* обязан возвращать Iterator::reference, а не T&. r-> возвращает Iterator::pointer, что бы это ни было, а не T*.
                                        Ответить
                                        • причем тут value_type контейнера?

                                          речь лишь, что некий тип T со своими модификаторами (ссылка, указатель на) у operator * и operator -> должен быть одним и тем же T

                                          не стоит в operator * возвращать "foo *", а в operator -> возвращать "bar &", это расстроит маньяка, который почитает твой код после тебя
                                          (кстати, даже в гцц всё норм в этом плане, за исключением, что вместо T & референсом служит временный объект-враппер - https://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.2/structstd_1_1__Bit__iterator.html)
                                          Ответить
                                          • > причем тут value_type контейнера?

                                            Не контейнера, а итератора.

                                            > вместо T & референсом служит временный объект-враппер

                                            Так о том и речь. @Antervis утверждает, что в качестве возвращаемых значений всегда должны быть указатели и ссылки, а по стандарту могут быть произвольные прокси, лишь бы код компилировался.
                                            Ответить
                                            • так
                                              диалог ушёл куда-то не туда
                                              итератор вектора<бул> вообще operator -> не перегружает, что бы ему с ним делать
                                              Ответить
                                              • > итератор вектора<бул> вообще operator -> не перегружает

                                                Я нигде и не писал, что он его перегружает :)

                                                Но ничто не мешает возвращать из operator-> любую шнягу, у которой перегружена стрелка — компилятор раскрутит всю цепочку, пока не увидит указатель.


                                                An expression x->m is interpreted as (x.operator->())->m for a class object x of type T if T::operator->()
                                                exists and if the operator is selected as the best match function by the overload resolution mechanism
                                                Ответить
                                            • В стандарте, насколько помню, ostream_iterator при разыменовании возращает ссылку на себя же.

                                              По тому же стандарту, vector<bool> вообще не Container, кстати.
                                              Ответить
                                  • На самом деле, оператор -> может возвращать другой объект с переопределённым оператором ->. Мы так обёртки над указателями с поддержной умных указателей делали.
                                    Ответить
                                    • пожалуйста, скажи, что оператор * этих оберток возвращает *(this->get())
                                      Ответить
                                      • decltype(*wrapped) ЕМНИП оно возвращает. И внутри делает return *wrapped;. Иначе бы с сырыми указателями бы не работало.
                                        Ответить
                        • В следующем году можно точку будет перегружать.
                          Ответить
                          • И тогда можно будет сцеплять строки точкой, как в PHP?
                            Ответить
                            • Нет, там ограниченные возможности, как в ->. Можно расширять класс, прикручивать к нему декораторы и т.п.
                              Ответить
                              • А грабить корованы можно?
                                Ответить
                                • Класс Прапорщик, который крякает как корован, но всё хорошее оставляет себе, а остальное передаёт в подчинённый корован:

                                  class Korovan
                                  {
                                    public:
                                      void add_stuff(Goods g);
                                      /* other Korovan stuff */
                                    private:
                                      vector<Goods> stuff;
                                  };
                                  
                                  
                                  class Praporschik
                                  {
                                    private:
                                      Korovan& k;
                                      void steal(Goods g);
                                      bool is_good(const Goods& g);
                                    public:
                                      Korovan& operator.() { return k; }
                                      void add_stuff(Goods g) 
                                      { 
                                          if (is_good(g))
                                              steal(g);
                                          else
                                              k.add_stuff(g);
                                      };
                                  };
                                  Ответить
                                  • Какое-то наследование выходит
                                    Ответить
                                  • ты в реализации армейского делегирования забыл добавить утечку ресурсов
                                    Ответить
                          • Мне вот другое интересно. Напишет какой-нибудь мчудак суперохрененную обертку-перенаправлятор в жопу к другому инстансу, и как потом обращаться к методам этого класса?
                            Ответить
                            • std::bind конечно же
                              Ответить
                            • > суперохрененную обертку-перенаправлятор
                              > как потом обращаться к методам
                              Очередная гонка вооружений?
                              Ответить
                    • Эээ.
                      На js тоже так можно, монада с цепочками бесконечных свойств.

                      brainfuck.plus.minus.left.right
                      Или даже так
                      brainfuck.['+-.*']
                      Ответить
                  • Вроде можно ещё на шаблонах, как я тут уже постил числа прописью...[code]
                    bf::p::m::d::p::o::run();
                    [code]
                    Ответить
              • А препроцессором нельзя извернуться?

                >Ну для красоты нужно же чтобы операторы были по одну сторону, или все слева или все справа.
                Брейнфак же игнорирует неизвестные символы => можно сделать крестопрограмму, которая выполнится любым интерпретатором.

                Вот думаю, может ли препроцессор подобавлять нули в выражение чтоб оно было корректно с точки зрения С++?

                Какой-нить emojii-brainfuck
                Ответить
                • > Брейнфак же игнорирует неизвестные символы
                  Предлагаешь скрыть код на брейнфаке в коде на крестах? Сурово.
                  Ответить
                  • Да. Но немного лучше
                    http://govnokod.ru/20272#comment336648

                    Если кресты полное днище, то думаю переменную _ можно заменить на невидимый символ.

                    #include <brainfuck>
                    
                    int main(){ auto _=new Brainfuck();// invisible header (by define)
                    _+_+... //brainfuck code
                    } //invisible closing brace
                    Ответить
                • >> Так можно и тупо буквами нахуярить:
                  >> bf->p->p->m->d->p->l->m->r->u->o; // ++-[+<->].
                  >> А вот как сделать bf.p.m.d.o.run() - ума не приложу...
                  > А препроцессором нельзя извернуться?
                  #define p p()
                  #define m m()
                  Ответить
                  • >>> А вот как сделать bf.p.m.d.o.run() - ума не приложу...
                    >> А препроцессором нельзя извернуться?
                    > #define p p()
                    И правда, работает.
                    https://ideone.com/CVOyS7
                    Ответить
                • > А препроцессором нельзя извернуться?
                  Кстати, а есть ли интерпретаторы bf на чистом препроцессоре, без си?
                  Ответить
                  • > Кстати, а есть ли интерпретаторы bf на чистом препроцессоре, без си?
                    Вряд-ли. Препроцессор-то, ЕМНИП, не Тьюринг-полный, в отличие от.
                    Ответить
            • Наручники и веревки надоели просто
              Ответить
          • [">++>+++>+++>+<<<<-"] //скобки можно использовать
            
            //">++>+++>+++>+<<<<-" - главное сконвертировать DSL в такую вот строку
            
            auto _=1;
            
            [_+_+_-_>>_<<_*_/_]
            //осталось только реализовать вложенные квадратные скобки
            
            
            [ _ + _ + _ - _ >> _[_+_+_+_>>_-_+] << _ * _ / _ ]
            
            
            >> 	++ptr;
            << 	--ptr;
            + 	++*ptr;
            - 	--*ptr;
            * 	putchar(*ptr);
            / 	*ptr=getchar();
            Ответить
            • Ну вот эти _ как мусор смотрятся. С ними, конечно, можно почти все операторы заюзать.
              Ответить
              • См. выше:
                >Если кресты полное днище, то думаю переменную _ можно заменить на невидимый символ.

                А &nbsp нельзя использовать в качестве переменной?
                Да и вообще, разве в уникоде символов мало?


                >Ну вот эти _ как мусор смотрятся.
                Зато на выходе идентично работающая в С++ и bf программа.
                Ответить
                • http://ideone.com/ZcBq41
                  Ответить
                  • Ох лол. Кресты можно приспособить к HTML.

                    А мы можем как-нить сделать
                    #define + _+
                    #define - _-
                    Ответить
                    • Можно только валидные идентификаторы дефайнить.
                      Ответить
                    • Джва раза уже пытались:
                      http://govnokod.ru/11549
                      http://govnokod.ru/18440

                      Только бы создателям крестостандартов на глаза не попался заброшенный E4X...
                      Ответить
    • вот сидишь такой, читаешь пост и думаешь "я вот не понимаю, это ГК по причине которую я не могу понять, или это ГК потому что я ничерта не понимаю?"
      Ответить

    Добавить комментарий