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

    +1

    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
    #include "stdafx.h"
    #include <iostream>
    #include <stdio.h>
    using namespace std;
    class radian
    {protected:
        double x;
        public:
        radian();//конструктор без параметров, возвращает дежурное значение
        radian(double x1);//конструктор с параметрами
        radian sum_rad(radian a );
        radian unsum_rad(radian a);//разность 2-х радиан
        double get_r(){return x;}//нужный геттр
        void set_r(double x1);//бесполезный сеттрер
        double radian::quarter(radian a);//определение четверти угла заданного в радианах
        double operator *();//перегрузка операции. возводит во вторую степень
        double radian::rad_to_grad();//перевод из радиан в градусы
        ~radian();//деструкторуу
    };
    class namerad:public radian
    {
        private:
        string name;
        public:
        namerad::namerad(double corner,string name)
        {set_name(name);}
        void namerad::set_name(string newname)
        {name=newname;}
        void namerad::get_name(string currentname)
        {currentname=name;}
    };
    radian::radian()//конструктор по умолчанию
    {
        x=0;
    }
    radian::radian(double x1)//конструктор с 1 параметром
    {
        x=x1;
    }
    radian radian::sum_rad(radian a)//сумма 2-х радиан
    {radian n(x+a.x);
        return n;
    }
    void radian::set_r( double x1)//сеттер
    { x=x1;}
    radian::~radian() {x=0;}//деструктор
    radian radian::unsum_rad(radian a)//разность 2-х радиан
    {radian n(x-a.x);
        return n;
    }
    double radian::rad_to_grad() //перевод из радиан в градусы
    {
        return(x*(180/3.14));
    }
    double radian ::operator *()//перегрузка операции
    {
        return x*x;
    }
    double radian::quarter(radian a)//определение четверти угла заданного в радианах
    {while(a.x>6.28){a.x-=6.28;}
            if ((a.x >=0)&&(a.x<=1.57)) return 1;
            if ((a.x>=1.57)&&(a.x<=3.14)) return 2;
            if ((a.x>=3.14)&&(a.x<=4.71)) return 3;
            return 4;
        }
        int main()
        {
            radian a,b,c(5.0),d(6.20);
            cout<<"summa=";b=c.sum_rad(d);cout<<b.get_r() << endl;//сумма
            cout<<"raznost=";b=d.unsum_rad(c);cout<<b.get_r() << endl; //разность
            cout<<"chetvert: ";cout<< d.quarter(d) << endl;//четверть
            cout<<"iz radian v gradusi: ";cout<<d.rad_to_grad() << endl;//перевод из радиан в градусы
            cout<<"peregruz sqr "<<*c;//возведение в квадрат. перегруженная операция
            system ("PAUSE");
            return 0;
        }

    Запостил: vovkalamer, 03 Декабря 2012

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

    • вован креститель
      Ответить
      • Вован-Раб-Майкрософта.

        Во-первых классическое бессмысленное и беспощадное мсвизуалстудиеблядство system("PAUSE").
        Во-вторых тот же гцц докопается до double radian::quarter(radian a) в описании класса, и скажет что он не нужен.
        Ответить
    • double x;

      Целых четыре пробела. Какая расточительность!
      Ответить
    • > return(x*(180/3.14));
      Феноменальная точность, даже не снившаяся ученым!

      > a.x>=3.14
      Т.е. 3.141 находится в третьем квадранте... *facepalm.png*

      > radian::~radian() {x=0;}
      Я всегда зануляю POD'ы в деструкторе, POD'ы сами не занулятся... (Зануление полей в деструкторе имеет смысл разве что в криптографии).
      Ответить
      • Скорее в обфускации)
        Ответить
        • Да какая тут обфускация... а вот вероятность того, что какой-нибудь секретный ключ или пароль, хранящийся в объекте, попадет на глаза злоумышленнику уменьшается, если почистить его в деструкторе. Не обнуляется, конечно, ведь своп и дебаггеры никто не отменял...
          Ответить
    • Мне понравилась работа товарища, т.к. он интересно перегрузил оператор умножения, используется для возведения в квадрат. При этом выглядит это, как разыменование указателя. см строку 55,73. Ну и супердеструктор
      Ответить
      • > перегрузил оператор умножения
        Вы серьезно считаете, что этот унарный оператор - умножение? *facepalm.png*

        > супердеструкторэтот
        Да, этот момент радует. Товарищу можно писать криптографические средства. Чистить за собой память он уже научился.

        P.S. А пи округленное до 3.14 разве не радует? ;)
        Ответить
        • ".... используется для возведения в квадрат. При этом выглядит это, как разыменование указателя. ..." Читай выше, никакого *facepalm.png*
          Ответить
          • > При этом выглядит это, как разыменование указателя.
            Для имитации которого, собственно и служит данный оператор (при вменяемом применении для всяких там умных указателей и итераторов). Никакого отношения к умножению он не имеет, кроме, разве что, случайного совпадения символа.

            Так что *facepalm.png* остается в силе.
            Ответить
            • Спасибо, я в курсе, я это и написал в своём комментарии
              Ответить
        • >> супердеструкторэтот
          > Да, этот момент радует
          Согласитесь, штука то полезная. Никаких варнингов. Ничего. Без этого мегадеструктора мы бы и не заметели косяка:
          http://ideone.com/CMkxXu
          #include <iostream>
           
          struct Tod
          {
                  int a;
                  Tod():a(4){}
                  ~Tod(){a=0;}
          };
           
          using namespace std;
           
          const Tod& foo()
          {
                  return Tod();
          }
           
          int main() {
                  Tod a= foo();
                  cout<<a.a;
                  return 0;
          }
          Ответить
          • О_о. В опере уменьшенный код не копируется.

            P.S. gcc 4.6
            1.cpp:12: предупреждение: возврат ссылки на временную переменную
            Ответить
          • P.P.S. Так что не нужно. В нормальных компиляторах на подобный код, возвращающий ссылку\указатель на временный объект, выдается предупреждение.
            Ответить
      • А я вот перегрузил себе унарный * как операцию сопряжения.
        Ответить
        • Такого? http://chertim.com/wp-content/uploads/2012/08/vnutrennee-sopryazhenie-dug-okruzhnostey.gif

          Или такого? a+bi -> a-bi
          Ответить
          • Второе.
            Про сопряжение дуг - как ты себе это представляешь?
            Ответить
            • Arc a1, a2;
              Arc a3 = a1 * a2; // сопрягающая дуга

              Хотя... есть проблема - решение не одно.
              Ответить
              • Есть две проблемы:
                1. в общем случае решений нет.
                2. ты проебал слово "унарный"
                Ответить
                • > 1. в общем случае решений нет.
                  Кинуть исключение.

                  > ты проебал слово "унарный"
                  Да, правда, позор на мои седины.
                  Ответить
                  • Ебанулся?
                    "В общем случае" - это значит, что если мы возьмём две случайные дуги, то с вероятностью 100% их нельзя сопрячь. Это как для двух прямых в пространстве с вероятностью 100% не существует точки пересечения.
                    Кидание исключений при возникновени события, вероятность которого больше 50%, не говоря уже наш случай - это долбоебизм.
                    Ответить
                    • Если мы возьмем случайную строку символов, с вероятностью, близкой к 100% она не будет являться именем файла, который можно открыть.
                      Ответить
                    • > Ебанулся?
                      Ебанулся тут ты. Зачем я буду давать алгоритму 2 случайным образом выбранных дуги? Ему с вероятностью 99% на вход подадут две дуги, которые вполне сопрягутся, иначе нахуй бы я пытался это сделать? А оставшийся 1% это ошибки человека, или алгоритма генерившего дуги, на которые вполне можно выдать исключение.

                      P.S. Steve_brown правильно написал, по твоей логике открывать файл тоже не имеет смысла, т.к. если случайно генерить имя файла, то с вероятностью почти 100% он не будет существовать.
                      Ответить
                      • Нет, ебанулся ты.
                        1. Потому что если мы пишем алгоритм, который может принимать на вход не любые данные, то давать ему имя оператора - это долбоебизм.
                        2. Что это за алгоритм, в котором надо найти сопряжение двух дуг, причём известно, что сопряжение есть? Скорее всего, это означает, что эти две дуги были хитрым образом обрезаны и в процессе обрезания уже были получены все данные, нужные для построения сопрягающей дуги. Вызов функции (не оператора, а функции), принимающей голые дуги - не нужен.
                        3. Оператор, кидающий исключение с вероятностью 100% на случайных данных - это долбоебизм.
                        Ответить
                        • > 1. Потому что если мы пишем алгоритм, который может принимать на вход не любые данные, то давать ему имя оператора - это долбоебизм.
                          Тот, кто сделал деление оператором - долбоёб? Оно ведь принимает на вход далеко не любые значения.

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

                          > 3. Оператор, кидающий исключение с вероятностью 100% на случайных данных - это долбоебизм.
                          Унарный оператор *, разадресовывающий указатели смотрит на тебя с недоумением. P.S. Ах да, он же не кидает исключение, он падает к хуям почти на всех входных значениях, кроме жалкой горстки, но не бросая исключения не нарушает твою теорию.
                          Ответить
                          • > Тот, кто сделал деление оператором - долбоёб? Оно ведь принимает на вход далеко не любые значения.

                            Исключений очень мало.
                            Для сопряжения дуг всё наоборот - существование сопряжения - это исключение с исчезающе малой вероятностью.

                            > Унарный оператор *, разадресовывающий указатели смотрит на тебя с недоумением.

                            Хорошо, { оператор, мимикрирующий под { стандартный, допускающий любые входные данные } , для которого корректные входные данные являются исключением} - долбоебизм.

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

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

                                Говно

                                > комплексные сопряжения звездочкой

                                Говно. Надо на ~ переделать, мне кажется.

                                > длину вектора логическим отрицанием

                                Надо подумать... Сходу не скажу.

                                > вывод в поток через операторы сдвига,

                                Годнота! Не трогать!
                                Ответить
                                • > Говно. Надо на ~ переделать, мне кажется.
                                  d = c.conjugate();

                                  > Надо подумать... Сходу не скажу.
                                  Да говно конечно, v.length(), v.manhattanLength() всяко будут понятнее.

                                  > Годнота! Не трогать!
                                  У них приоритеты не совсем удачные.
                                  Ответить
                                  • > manhattanLength
                                    mahnattan
                                    Ответить
                                    • > mahnattan
                                      manHunt'an тогда уж.
                                      Ответить
                                    • побрей мохнатку, киса!
                                      можно еще ввести оператор || - норма. Только вот он может быть только инфиксным, но вторым аргументом можно передавать порядок.
                                      vec || 2 - обычная евклидова норма
                                      vec || 1 - сумма модулей
                                      vec || Inf - Манхеттен.
                                      Ответить
                    • > Это как для двух прямых в пространстве с вероятностью 100% не существует точки пересечения.
                      Ебанись!

                      Если я возьму две прямых, то они не пересекутся только в одном случае - если у них совпал угол наклона. А вероятность этого равна нулю (1 случай против бесконечного множества прямых, проходящих под другими углами).

                      Две прямые в пространстве пересекутся с вероятностью 100%, а параллельные прямые это вырожденный случай, которого не бывает.
                      Ответить
                      • Сам ебанись. Две прямые в пространстве с вероятностью 100% будут скрещивающимися, а никак не параллельными или пересекающимися. А у скрещивающихся прямых точки пересечения нету.
                        Ответить
                        • Бля, не внимательно читаю в который раз. Слился, подумав, что речь идет о плоскости. Минусуй меня полностью.
                          Ответить
    • >rad_to_grad
      Град (гон) — единица измерения плоских углов, 1/400 оборота - Gradian.
      Градус - degree.

      Ну а так что? Чей-то первый класс с признаками полезности. На ошибках учатся. Желаем дальнейших успехов в изучении программирования.
      Ответить
    • unsum - это, очевидно, противоположность sum, т.е. отнимание... вот это очень даже в духе Эсперанто. Или, говоря по-русски, "разбавление", т.как самое близкое, что можно подобрать к "отбавлению", вроде ж нет такого слова?
      Ответить

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