1. Си / Говнокод #14529

    +131

    1. 001
    2. 002
    3. 003
    4. 004
    5. 005
    6. 006
    7. 007
    8. 008
    9. 009
    10. 010
    11. 011
    12. 012
    13. 013
    14. 014
    15. 015
    16. 016
    17. 017
    18. 018
    19. 019
    20. 020
    21. 021
    22. 022
    23. 023
    24. 024
    25. 025
    26. 026
    27. 027
    28. 028
    29. 029
    30. 030
    31. 031
    32. 032
    33. 033
    34. 034
    35. 035
    36. 036
    37. 037
    38. 038
    39. 039
    40. 040
    41. 041
    42. 042
    43. 043
    44. 044
    45. 045
    46. 046
    47. 047
    48. 048
    49. 049
    50. 050
    51. 051
    52. 052
    53. 053
    54. 054
    55. 055
    56. 056
    57. 057
    58. 058
    59. 059
    60. 060
    61. 061
    62. 062
    63. 063
    64. 064
    65. 065
    66. 066
    67. 067
    68. 068
    69. 069
    70. 070
    71. 071
    72. 072
    73. 073
    74. 074
    75. 075
    76. 076
    77. 077
    78. 078
    79. 079
    80. 080
    81. 081
    82. 082
    83. 083
    84. 084
    85. 085
    86. 086
    87. 087
    88. 088
    89. 089
    90. 090
    91. 091
    92. 092
    93. 093
    94. 094
    95. 095
    96. 096
    97. 097
    98. 098
    99. 099
    100. 100
    #include <stdio.h>
    #include <stdlib.h>
    
    /*
    Declare array of functions that return array of functions with
    one parameter - function accepting array of functions returning
    a pointer to function void(void).  No typedefs.
    
    Decoded to the following:
    1) An array of E.
    2) E = a function that takes void and returns an array of D (returns an array taken to mean a pointer to D).
    3) D = a function that takes C and returns void.
    4) C = a function that takes an array of B and returns void.
    5) B = a function that takes void and returns A.
    6) A = a pointer to void(void).
    */
    
    /* Using typedefs */
    typedef void (*tA) (void);
    typedef tA (*tB) (void);
    typedef void (*tC) (tB b[]);
    typedef void (*tD) (tC c);
    typedef tD* (*tE) (void);
    tE tArray[2];
    
    /* Not using typedefs */
    void (*_A) (void);
    void (* (*_B) (void) ) (void);
    void (*_C) ( void (* (*_B[]) (void) ) (void) );
    void (*_D) ( void (*_C) ( void (* (*_B[]) (void) ) (void) ) );
    void (** (*_E) (void) ) ( void (*_C) ( void (* (*_B[]) (void) ) (void) ) );
    void (** (*_Array[2]) (void) ) ( void (*_C) ( void (* (*_B[]) (void) ) (void) ) );
    
    /* Some concrete functions for testing */
    void fA(void)
    {
        printf("fA\n");
    }
    
    tA fB(void)
    {
        printf("fB\n");
        return &fA;
    }
    
    void fC(tB b[])
    {
        tA _a;
        printf("fC\n");
        _a = (*b[0])();
        (*_a)();
    }
    
    void fD(tC c)
    {
        tB b[1];
        printf("fD\n");
        b[0] = &fB;
        (*c)(b);
    }
    
    tD* fE(void)
    {
        tD *d;
        printf("fE\n");
        d = malloc(sizeof(tD));
        d[0] = &fD;
        return d;
    }
    
    int main()
    {
        tA _a;
        tB _b;
        tC _c;
        tD _d;
        tE _e;
    
        tB b[1];
        tD *d;
    
        _a = &fA;
        _A = &fA;
        printf("_a\n");
        (*_a)();
        printf("_A\n");
        (*_A)();
    
        _b = &fB;
        _B = &fB;
        printf("_b\n");
        _a = (*_b)();
        (*_a)();
        printf("_B\n");
        _a = (*_B)();
        (*_a)();
    
        _c = &fC;
        _C = &fC;
        b[0] = _b;

    printf("_c\n");
    (*_c)(b);
    printf("_C\n");
    (*_C)(b);

    _d = &fD;
    _D = &fD;
    printf("_d\n");
    (*_d)(&fC);
    printf("_D\n");
    (*_D)(&fC);

    _e = &fE;
    _E = &fE;
    printf("_e\n");
    d = (*_e)();
    (*d[0])(&fC);
    free(d);
    printf("_E\n");
    d = (*_E)();
    (*d[0])(&fC);
    free(d);

    printf("tArray\n");
    tArray[0] = &fE;
    d = (*tArray[0])();
    (*d[0])(&fC);
    free(d);
    printf("_Array\n");
    _Array[0] = &fE;
    d = (*_Array[0])();
    (*d[0])(&fC);
    free(d);

    return 0;
    }

    Запостил: LispGovno, 08 Февраля 2014

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

    • http://ideone.com/hegPku

      По реквесту к картинке от defecate-plusplus:
      http://habrastorage.org/storage/habraeffect/7e/c6/7ec6526b2a6fa85a30736912c357c5b3.jpg

      Специальная олимпиада на гейдеве.
      Ответить
      • маскот специальной олимпиады - гном с мешочком?
        Ответить
        • Ага, с мешочком:
          http://www.gamedev.ru/files/images/gnomeall2.jpg
          А в мешочке очевидно настойка на грибках:
          http://www.gamedev.ru/files/images/gnomeallgird.jpg
          Ответить
    • @LispGovno, запости лучше генератор чем ты эти ГК генеришь. я догадываюсь что там каждая вторая строка рандом, потому что нарочно такие высеры не придумаешь.
      Ответить
      • Большинство моих генераторов на гейдеве. Достаточно зайти в раздел. \pr\
        Я не шучу. Там есть извращенцы, что пишут в таком стиле.
        Не спрашивай меня почему. Это научно не объяснимо.
        Ответить
    • Переписал на Delphi:
      {$APPTYPE CONSOLE}
      {$IFDEF FPC}
      {$MODE DELPHI}
      {$ENDIF}
      
      Type
        TProcedure = procedure;
        PProcedure = ^TProcedure;
        TFunctionReturningAPointerToFunction = function:PProcedure;
        TFunctionAcceptingArrayOfFunctionsReturningAPointerToFunction = procedure(parameter: array of TFunctionReturningAPointerToFunction);
        TArrayOfFunctionsWithOneParameter = array of procedure(parameter: TFunctionAcceptingArrayOfFunctionsReturningAPointerToFunction);
        TFunctionThatReturnArrayOfFunctionsWithOneParameter = function: TArrayOfFunctionsWithOneParameter;
      
      Const 
        X: array[1..3] of TFunctionThatReturnArrayOfFunctionsWithOneParameter = (nil, nil, nil);
      
      Begin
      End.
      Увы, совсем без тайпдефов не получается.
      Ответить
    • Правило улитки это ебанутый маразм сиштухов.
      Ответить
      • Правило улитки?
        Ответить
        • спирали идя с надо когда Это фразу читать середины, по
          Ответить
        • typedef x (*y) (z);
          В сишке можно, не напрягаясь, определить, какой из этих идентификаторов определяется, а какие считаются известными?
          Ответить
          • В крестах также если что.
            Ответить
            • Просто в крестах это реже требуется.
              Ответить
              • Ты так говоришь как-будто это в сишке требуется и дифайны отменили.
                Ответить
                • Да, покажи это на дефайнах, я поржу
                  Ответить
                  • Я не знаю что-там делал автор, так что повторять всякую говноноркаманию я не собираюсь. Но что по твоему там нельзя повторить на тайпдефах?

                    Ты просто не асилил тайпдефы
                    Ответить
                    • Гумно, не подменяй слова.
                      Я специально выделил жирным, чтобы ты, гумно, не подменяло слова, но ты всё равно подменило. Как это называется, а?
                      Ответить
                  • #define shittyshit(x,y,z) typedef x (*y) (z)


                    а где то в коде shittyshit
                    Ответить
                    • Хуйня какая-то :)

                      - некомпозабельно, для описания функций возвращающих функции интуитивно не применишь (надо возвращающей функции передавать пустой х, и вкладывать ее аргумент y возвращаемой);
                      - работает только для функций с 0 и 1 аргументами.
                      Ответить
            • Крестошаблон std::function хотя бы читается легче, чем эта улитка.
              Ответить
            • using y = std::function<x(z)>

              или http://dev.krzaq.cc/readable-function-pointers/ чтобы без оверхеда
              Ответить
              • Это реальне в стандарт нужно было добавить.
                Ответить
              • у меня тоже есть такой класс
                на самом деле я его завёл лишь потому, что отладчик гонит лажу при вызове по нулевому указателю, завёл я его ради ассерта в операторе ()
                Ответить
                • >при вызове по нулевому указателю
                  ((void (*)())0)()
                  ?
                  Ответить
                  • Да. Например, в структуре есть указатель на функцию, забыл его проинициализировать, вызвал, отладчик говорит, что ошибка и что никакого стека вызовов он предоставить не может.

                    Пришлось писать свой класс:
                    #pragma once
                    #include "assert.h"
                    
                    namespace tblib
                    {
                    	class empty {};
                    
                    	template <typename Sig> 
                    	struct sig_info
                    	{
                    		enum { arg_count=-1 };
                    		typedef empty R;
                    		typedef empty A1;
                    		typedef empty A2;
                    		typedef empty A3;
                    		typedef empty A4;
                    		typedef empty A5;
                    		typedef empty A6;
                    		typedef empty A7;
                    		typedef empty A8;
                    	};
                    	
                    	template <typename R> 
                    	struct sig_info<R()>
                    	{
                    		enum { arg_count=0 };
                    		typedef R     R;
                    		typedef empty A1;
                    		typedef empty A2;
                    		typedef empty A3;
                    		typedef empty A4;
                    		typedef empty A5;
                    		typedef empty A6;
                    		typedef empty A7;
                    		typedef empty A8;
                    	};
                    	
                    	template <typename R, typename A1> 
                    	struct sig_info<R(A1)>
                    	{
                    		enum { arg_count=1 };
                    		typedef R     R;
                    		typedef A1    A1;
                    		typedef empty A2;
                    		typedef empty A3;
                    		typedef empty A4;
                    		typedef empty A5;
                    		typedef empty A6;
                    		typedef empty A7;
                    		typedef empty A8;
                    	};	
                    	
                    	template <typename R, typename A1, typename A2> 
                    	struct sig_info<R(A1,A2)>
                    	{
                    		enum { arg_count=2 };
                    		typedef R     R;
                    		typedef A1    A1;
                    		typedef A2    A2;
                    		typedef empty A3;
                    		typedef empty A4;
                    		typedef empty A5;
                    		typedef empty A6;
                    		typedef empty A7;
                    		typedef empty A8;
                    	};	
                    	
                    	template <typename R, typename A1, typename A2, typename A3> 
                    	struct sig_info<R(A1,A2,A3)>
                    	{
                    		enum { arg_count=3 };
                    		typedef R     R;
                    		typedef A1    A1;
                    		typedef A2    A2;
                    		typedef A3    A3;
                    		typedef empty A4;
                    		typedef empty A5;
                    		typedef empty A6;
                    		typedef empty A7;
                    		typedef empty A8;
                    	};	
                    	
                    	template <typename R, typename A1, typename A2, typename A3, typename A4> 
                    	struct sig_info<R(A1,A2,A3,A4)>
                    	{
                    		enum { arg_count=4 };
                    		typedef R     R;
                    		typedef A1    A1;
                    		typedef A2    A2;
                    		typedef A3    A3;
                    		typedef A4    A4;
                    		typedef empty A5;
                    		typedef empty A6;
                    		typedef empty A7;
                    		typedef empty A8;
                    	};
                    Ответить
                    • template <typename R, typename A1, typename A2, typename A3, typename A4, typename A5> 
                      	struct sig_info<R(A1,A2,A3,A4,A5)>
                      	{
                      		enum { arg_count=5 };
                      		typedef R     R;
                      		typedef A1    A1;
                      		typedef A2    A2;
                      		typedef A3    A3;
                      		typedef A4    A4;
                      		typedef A5    A5;
                      		typedef empty A6;
                      		typedef empty A7;
                      		typedef empty A8;
                      	};
                      	
                      	template <typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> 
                      	struct sig_info<R(A1,A2,A3,A4,A5,A6)>
                      	{
                      		enum { arg_count=6 };
                      		typedef R     R;
                      		typedef A1    A1;
                      		typedef A2    A2;
                      		typedef A3    A3;
                      		typedef A4    A4;
                      		typedef A5    A5;
                      		typedef A6    A6;
                      		typedef empty A7;
                      		typedef empty A8;
                      	};
                      	
                      	template <typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> 
                      	struct sig_info<R(A1,A2,A3,A4,A5,A6,A7)>
                      	{
                      		enum { arg_count=7 };
                      		typedef R     R;
                      		typedef A1    A1;
                      		typedef A2    A2;
                      		typedef A3    A3;
                      		typedef A4    A4;
                      		typedef A5    A5;
                      		typedef A6    A6;
                      		typedef A7    A7;
                      		typedef empty A8;
                      	};	
                      	
                      	template <typename R, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> 
                      	struct sig_info<R(A1,A2,A3,A4,A5,A6,A7,A8)>
                      	{
                      		enum { arg_count=8 };
                      		typedef R     R;
                      		typedef A1    A1;
                      		typedef A2    A2;
                      		typedef A3    A3;
                      		typedef A4    A4;
                      		typedef A5    A5;
                      		typedef A6    A6;
                      		typedef A7    A7;
                      		typedef A8    A8;
                      	};
                      Ответить
                      • template <typename F>
                        	class fptr
                        	{
                        		F* ptr;
                        	public :
                        		fptr () : ptr(NULL) {}
                        		fptr (F* ptr) : ptr(ptr) {}
                        		fptr (const fptr& f) : ptr(f.ptr) {}
                        		fptr& operator=(F* ptr) { this->ptr=ptr; return *this; }
                        		fptr& operator=(const fptr& f) { this->ptr=f.ptr; return *this; }
                        
                        		typedef typename sig_info<F>::R  R;
                        		typedef typename sig_info<F>::A1 A1;
                        		typedef typename sig_info<F>::A2 A2;
                        		typedef typename sig_info<F>::A3 A3;
                        		typedef typename sig_info<F>::A4 A4;
                        		typedef typename sig_info<F>::A5 A5;
                        		typedef typename sig_info<F>::A6 A6;
                        		typedef typename sig_info<F>::A7 A7;
                        		typedef typename sig_info<F>::A8 A8;
                        
                        		R operator () () { assert (ptr); return ptr(); }		
                        		R operator () (A1 a1) { assert (ptr); return ptr(a1); }
                        		R operator () (A1 a1, A2 a2) { assert (ptr); return ptr(a1,a2); }
                        		R operator () (A1 a1, A2 a2, A3 a3) { assert (ptr); return ptr(a1,a2,a3); }
                        		R operator () (A1 a1, A2 a2, A3 a3, A4 a4) { assert (ptr); return ptr(a1,a2,a3,a4); }
                        		R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { assert (ptr); return ptr(a1,a2,a3,a4,a5); }
                        		R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { assert (ptr); return ptr(a1,a2,a3,a4,a5,a6); }
                        		R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { assert (ptr); return ptr(a1,a2,a3,a4,a5,a6,a7); }
                        		R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { assert (ptr); return ptr(a1,a2,a3,a4,a5,a6,a7,a8); }
                        	};
                        
                        };
                        Ответить
                      • Блин, нет возможности юзать с++11 с вариадик шаблонами - так освой BOOST_PP, этой либой такие портянки копипасты нагенерить - раз плюнуть.
                        Ответить
                        • так тут не простая копипаста как бы, а с небольшими изменениями в каждом пункте
                          Ответить
                          • Ну там циклы есть, условия есть. Даже операции над списками, последовательностями и туплами есть. Что еще надо то? :)

                            Генерация шаблонов, подобных твоему, как бы не в самом первом примере к этой либе рассматривалась...
                            Ответить
                            • это же тарас, как же он возьмет буст??
                              Ответить
                              • > как же он возьмет буст
                                С бустом он не сможет страдать херней, и ему придется писать игры?
                                Ответить
                                • нет, придется купить новый компьютер
                                  печальный предсказуемый финал
                                  Ответить
                                • В бусте есть завязки на исключения?
                                  Ответить
                                  • > В бусте есть завязки на исключения?
                                    В бустпрепроцессоре их точно нет. Там вообще нет кода на крестах как такового. Только макросы, только хардкор.

                                    А в целом - буст же большой, состоит из кучи библиотек. В каких-то кидают исключения, в каких-то - нет.
                                    Ответить
                                    • может у него такой старый компилятор, что буст препроцессор не скомпилируется? Они постепенно поддержку старых компилей выкидывают
                                      Ответить
                                  • > исключения
                                    если тебя интересует недоподдержка исключений в андроиде, то насколько я помню, либо вообще все проблемы уже решены, либо не будут работать только несколько библиотек

                                    но я не компилил под андроид, мопед не мой
                                    Ответить
                          • Как-то так в общем: http://coliru.stacked-crooked.com/a/a772ac1e4bff8862

                            Заодно пофиксил несовместимость твоей либы с gcc: typedef R R не компилировалось.
                            Ответить
                            • Да, на гццпроблемы я ещё код не тестировал...
                              Ответить
                              • Это, скорее всего, не гццпроблемы, а визуалкопохуизм.

                                Хотя надо почитать стандарт - только он знает, кто из них не прав.
                                Ответить
                              • In a given scope, a typedef specifier can be used to redefine the name of any type declared in that scope to refer to the type to which it already refers. [Example:
                                typedef struct s { /* ... */ } s;
                                typedef int I;
                                typedef int I;
                                typedef I I;
                                —end example]


                                Все-таки gccпроблема?
                                Ответить
                                • > Все-таки gccпроблема?
                                  Ан нет! Вижуалкопохуизм!

                                  A template-parameter shall not be redeclared within its scope (including nested scopes).
                                  template<class T, int i> class Y {
                                      int T; // error: template-parameter redeclared
                                      void f() {
                                          char T; // error: template-parameter redeclared
                                      }
                                  };
                                  Евангелие от Бьёрна, [temp.local/4]
                                  Ответить
              • Я джва года этого ждал! Наконец-то в C++ можно описывать массивы и процедурные типы способом, аналогичным тому, что уже давно применяется в других языках.
                Ответить

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