1. Куча / Говнокод #13344

    +124

    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
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    #pragma syntax(C++03) // было
    int i,j,*pi,&ri=...,ai[10],aai[10][20];
    const int ci = 100;
    T myFunction (TX x1,TX x2,TY y1,TY ywd=...);
    
    #pragma syntax(C++SD) // стало
    var(int) i,j;
    var(Ptr[int]) pi;
    var(Ref[int]) ri = ...;
    var(Array[int,10]) ai;
    var(Array[Array[i,20],10]) aai;
    var(Immutable[int]) ci = 100;
    // отличать от:
    const(int) cci = 100; // и cci с рантаймовой точки зрения будет чистой константой, а не "типа неизменяемой переменной"
    
    function(T) myFunction (var(TX) x1,x2; var(TY) y1,ywd=...);
    // ^смысл в том, чтобы список параметров имел ту же форму, что декларация переменных и членов структур
    
    // возможны и константные функции
    function const(int) constSum (const(int) x1,x2) { return x1+x2; }
    // теперь constSum (1,2) будет всё равно что 3
    
    // это теперь заменяет тайпдеф
    const(typename) Int32 = int;
    
    #pragma syntax(C++03) // было
    class C
    {
     int mi;
     static int si;
    
    private:
     float mf;
     void privateMethod1 () {...}
     void privateMethod2 ();
    
    protected:
     void staticMethod1 () {...}
     void staticMethod2 ();
    
    public:
     virtual void virtualMethod ();
    };
    
    int C::si;
    void C::privateMethod2 () {...}
    void C::staticMethod2 () {...}
    void C::virtualMethod () {...}
    
    #pragma syntax(C++SD) // стало
    class C
    {
     // эта секция называется "имплементацией класса"
     var(int) mi;
     // статические поля в имплементации класса не объявляются
    
    private:
     var(float) mf;
     function() privateMethod1 () {...}
     //void privateMethod2 (); // объявлять методы, который не имплементируются тут же, не обязательно
    
    protected:
     function() staticMethod1 (): Static
     {...}
     // Static - пометка для функции, декларируемой/имплементируемой в имплементации класса,
     // что это не метод, а просто функция
    
    public:
     virtual function() virtualMethod ();
     // в имплементации класса по-настоящему нужна декларация только переменных-полей,
     // виртуальных методов и деструктора, если он пишется юзером
    
     // также:
     var(int) inlinelyInitialized = 100;
     // да, инициализаторы тоже допускаются
    };
    
    using (C) var(int) si; // using(C) - пометка, что декларация касается неймспейса C
    using (C) private: function() privateMethod2 (): Method {...}
    // ^если метод объявляется/имплементируется вне имплементации класса, его
    // нужно пометить как Method, чтобы отличить от обычной функции
    
    // using можно юзать и целым блоком...
    using (C)
    {
    protected:
     // для функции-неметода вне имплементации класса уточнение Static не требуется
     function() staticMethod2 {...}
    public:
     function() virtualMethod (): Method {...}
    }
    
    // глобальный скоп - тоже типа класс, для его явного указания, если вдруг понадобится,
    // используется конструкция using (.)

    Тот момент, когда понимаешь: "Какая радость, что в создатели стандарта крестов не берут кого попало."
    http://www.gamedev.ru/flame/forum/?id=178107

    Запостил: LispGovno, 09 Июля 2013

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

    • На самом деле если заглянуть в тему, то станет ясно, что там все намного страшнее когда пойдут шаблоны и классы нью, чем кажется на первый взгляд.
      Ответить
    • Кто-то обкурился похапе?
      Ответить
    • Это щедевр - кастаните тараса. Упоротой паскалист решил переделать плюсы под себя - где бегины/енды?

      Я не увидил ни единого семантического профита от этого говна - мои alias, true_const, bind() вносят реальный профит, а это говно только хуже делает код.

      И такие же житное запилили 99% языков.
      Ответить
    • На фоне всеобщего ракования, копипаст с гейдева выглядит вполне безобидно.
      Ответить
    • Я просто не мог не запостить предлагаемую перегрузку new\delete:
      // где-то в глубинах стандартной библиотеки...
      template [(typename) T]
      class new: Namespace;
      
      template[(typename) T]
      using (new[T])
      template[(typename) Sig]
      function(Ptr[T]) operator this(?) param (Sig)
      {
       Ptr[Raw[T]] ptr = reinterpret_cast[Ptr[Raw[T]]
        (malloc (sizeof (T)); // using (.) function(Ptr[void]) malloc (var(size_t) ?): Cdecl;
       // тут ещё нужно учесть bad_alloc-и и ексепшоны
       // в конструкторе, но для простоты примера не будем
       ptr->T param (param); // вызов конструктора
       return reinterpret_cast[Ptr[T]] (ptr);
      }
      
      template[(typename) T]
      function() delete (var(Ptr[T]) object)
      {
       Ptr[void] cell;
       
       // вычислить адрес участка памяти
       const_if (T<Polymorphic)
        cell = Polymorphic.GetObjectBase (object);
       else
        cell = object;
        
       // позвать деструктор, если он уместен
       const_if (!(T<Pod))
        reinterpret_cast[Ptr[Raw[T]]] (object)->~T ();
       
       // ну и этого... того
       free (cell); // using (.) function() free (var(Ptr[void]) ?): Cdecl;
      }
      
      // потом - var(Ptr[T]) v = new[T] (параметры); delete (v); или delete[T] (v);
      // естественно, поциенту никто не запрещает определять свои собственные
      // вариации на эту же тему, кому как удобно
      Ответить
    • Мне интересно, зачем аффтар назвал это с++? Этот язык заслуживает собственного имени ;)
      Ответить
      • Кстати, идея выражать указатели в виде ptr<T> не выходит у меня из головы со времени знакомства с Foreign.Ptr.
        Всё остальное - какой-то шлак.
        Ответить
      • > Этот язык заслуживает собственного имени ;)
        Его убийцу С++ где-то в теме назвали LSD и дальше так и пошло. Тема до сих пор растет как на дрожях.
        Ответить

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