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

    +139

    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
    /* В комментариях то что хотел Автор от своей программы 	*/
    /* Радует однако, что она компилируется и во время		*/
    /* работы не выдает ни каких ошибок				*/
    /* Порядок операторов сохранен.					*/
    /* Тот же код только вырезанно "лишнее".			*/
    
    /* Эта ф-ия находится в другом cpp файле */
    float f(float x, float y)
    {
    	/* Тут что-то происходит с x и y */
    	return x, y;
    }
    
    void main(void)
    {
    	float **m;
    
    	/* ... */
    	float f(float x, float y);
    	/* ... */
    
    	/* Задается N					*/
    	float N;
    	/* ... */
    
    	/* Выделяется память под массив m[N][2] 	*/
    	m = (float **)malloc(sizeof(float*));
    	for(i = 0; i < N; i++)
    	{
    		m[i] = (float*)malloc(sizeof(float*) * 2);
    	}
    
    	/* ... */
    	for(i = 0; i < N; i++)
    	{
    		/* Массив заполняется числами						*/
    		/* В m[i][] должны быть записанны числа x, y измененый ф-ей f 		*/
    		/* т. е.	m[i][0] = xf						*/
    		/*		m[i][1] = yf						*/
    		for(j = 0; j < 2; j++)
    		{
    			m[i][j] = f(x, y);
    			/* ... */
    		}
    	}
    
    	/* ... */
    }

    Запостил: dreesto, 28 Ноября 2012

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

    • Во даёт парень! Циклом выделяет память динамическому массиву!
      Ответить
      • Не туда
        Ответить
      • Зато индексировать можно в стиле m[i][j] а не m[i * rowsize + j]
        Ответить
      • Двумерные массивы имеет смысл хранить не одним куском, а, скажем, массивом указателей на строке (т.н. jagged array), если общий размер может превысить 64К. Но это актуально только на 16-битных системах (грубо говоря).
        Ответить
        • Или если это массив массивов, а не двумерный массив.
          Ответить
        • Неужели нет никакого более лучшего способа выделить память дин. массиву?
          Ответить
          • В любом высокоуровневом языке есть. Но тут сишка.

            Можно написать функцию, принимающую размерность массива и размер элемента и возращающая указатель, тогда использование будет простое, например:

            float array[] = create_array(w*h, sizeof(float));
            Ответить
            • Ну а смысл этой твоей create_array? Чем это будет отличатся от того же malloc(w * h * sizeof(float))?
              Ответить
            • А можно сделать функцию, создающую "двумерный массив", на котором можно использовать вложенные квадратные скобки arr[i][j]. А потом освобождать весь массив одним free.
              float** create_2d_array(int w, int h){
                  int offset=w*sizeof(float*);
                  float **p=(float**)malloc(offset+w*h*sizeof(float));
                  for(int i=0;i<w;i++){
                      p[i]=(float*)(((char*)p)+offset+i*h*sizeof(float));
                  }
                  return p;
              }
              Ответить
            • > create_array(w*h, sizeof(float));
              Поздравляю, ты только что изобрел calloc().
              Ответить
              • КАЛлок ещё и обнуляет
                логики понять не могу, почему одно требует умножать самому и не обнуляет, а другое принимает множитель отдельно и обнуляет
                Ответить
                • Видимо, по той же причине, по которой gets не принимает ограничения на длину буфера, а fgets принимает.
                  Ответить
                  • > по той же причине

                    Чесание левой пятки?
                    Ответить
                • Исторически сложилось. Что еще сказать... Ну или массивы влом заполнять, это ж цикл писать, пускай они сразу зануленные будут.

                  P.S. За что минус?
                  Ответить
                  • За то, что то, что он изобрёл - это не каллок.
                    Ответить
                    • Резонно.

                      P.S. Код Fai не скомпилится, т.к. компилер скажет, что размер массива array неизвестен.
                      Ответить
    • return x, y;
      Я, наверное, отстал от жизни, но... КАК?
      Ответить
    • Я же правильно понял, идею, что строки 40-44 это
      m[i][0] = m[i][1] = f(x, y);

      ?
      Ответить
      • Автор хотел, чтоб ему return x, y; из ф-ии f, заполнил m[i], m[i][0] = x, m[i][1] = y.
        Но получилось так как ты сказал. :'(
        Ответить
    • > /* Выделяется память под массив m[N][2] */
      > m = (float **)malloc(sizeof(float*));
      А где здесь N ? ;)

      > float N
      > for(i = 0; i < N; i++)
      *facepalm.png*
      Ответить
      • И в результате при N=20 программа всё-таки падает.

        Да, повезло парню, что sizeof(float) == sizeof(float*). С даблами проблемы начались бы уже при N = 1.
        Ответить
    • > m[i] = (float*)malloc(sizeof(float*) * 2);

      Повезло ему, что флоат имеет тот же размер, что указатель, ох повезло.

      Вообще типичный ламокод. Блядство сишки в том, что она это позволяет, шлюшка такая...
      Нельзя подпускать ни к сишке, ни к крестам новичка, никак нельзя. Только при строгой самодисциплине человек может использовать эти языки во благо, а не во зло.
      Ответить
    • Начинать программировать надо на 'С' или не допускать к 'С' вообще.
      Ответить
      • Начинать программировать нужно с ассемблера или не допускать к языкам ниже уровня шарпика вообще.
        Ответить
        • Начинать программировать не нужно.
          Ответить
          • Combo breaker. Надо было сказать "Начинать компьютеры нужно с изучения схемотехники или не допускать к программированию вообще."
            Ответить
            • -> микроэлектроники -> электротехники -> материаловедения -> физики твердого тела
              Ответить
      • Если начинать с сишки, то получается вот такое говно.
        А половину крестоблядей я бы сразу отлучил от языка. Долбоёбам, которые используют сырые указатели в крестах, потому что они думают, что так быстрее / что они сами за всем уследят и им западло прибегать к помощи компилятора / что неявные вызовы чего-либо (даже деструктора) = зло, надо гвоздь в голову забить.
        Ответить
        • Начинать нужно с паскаля.
          Ответить
          • Зеленым оно бы выглядело лучше.
            Ответить
          • Это верно.
            Ответить
          • Начинать с паскаля нужно только тем кто на паскале и закончит.
            Ответить
          • А что в этом плохого?
            В паскале имхо меньше возможностей выстрелить себе в ногу, для обучения азам в самый раз. А как в голове хоть какое-то понимание устаканится, можно и дальше переходить.
            Ответить
          • Начинать нужно с http://tinyurl.com/cx57kc5
            Ответить
          • Взорву шаблон - начинать нужно с бейсика, что будущий программер на своей жопе ощутил, в чём разница a и a$
            Ответить
            • Начинать нужно с брейнфака - чтобы остальные языки казались удобными.
              Ответить
        • Меня больше бесит, когда крестоблядь заменяет
          x /= 2

          на
          x >>= 1

          И называет это крестооптимизацией.
          Ответить
          • > x >>= 1
            Ня. Сдвиги.
            Ответить
          • При этом для unsigned'а компилятор сделал бы это сам... А для signed'а они вообще не эквивалентны.
            Ответить
            • На самом деле все сложнее. Сдвигов очень много - арифметический, циклический, побитовый.
              Ответить
              • Для эмуляции интелоделения с округлением к нулю ни один из них не подойдет.

                А вот то, что циклических нету в си - жаль. Для криптографии было бы удобно. Писать a << 11 | a >> 21, и надеяться что компилятор превратит это в циклический сдвиг (а для unsigned'ов gcc и clang таки превращают в rol/ror), как-то неприятно.

                P.S. Сдвиг знакового инта естественно транслируется в арифметический сдвиг (sar/sal), а беззнакового в shr/shl.
                Ответить
                • А ходят слухи, что компиляторы путают sal и shl...
                  Ответить
                  • Никто не путает.
                    Сишка выбирает в зависимости от знаковости типа, дельфа всегда какого-то хуя берёт беззнаковый (правда при вычислении времени компиляции и при показе в отладчике берёт в зависимости от знаковости типа), ФПЦ выбирает в зависимости то ли от опций, то ли от фазы луны.
                    Ответить
                    • А чем они отличаются?
                      Ответить
                      • sal от shl - ничем. У них вроде даже опкод одинаковый.
                        Ответить
                        • А как процессор узнаёт, какой сдвиг нужен (знаковый или беззнаковый), если опкод одинаковый?

                          Про тему http://www.gamedev.ru/code/forum/?id=139163 я пока не забыл.
                          Ответить
                          • Так знаковость скажется только на сдвиге вправо. Кстати в той же яве есть >>> и >>, но нет <<<.

                            P.S. А ну да, зеленый коммент.
                            Ответить
        • Начинать нужно с Си. А трата времени на всякое не нужное говно это просто трата времени. И не надо говорить, что проще. Чем проще, чем блять? Подобное говно можно генерировать на любом языке. Если писать не понимая, что и как работает.
          Ответить
          • Подобное говно позволяет только один язык.
            Ответить
            • Однако:
              PHP (3112)
              C++ (1084)
              C# (927)
              JavaScript (773)
              Java (749)
              Куча (505)
              Си (386)
              Pascal (327)
              SQL (284)
              ActionScript (257)
              Python (211)
              1C (148)
              Perl (125)
              Objective C (104)
              bash (98)
              Ruby (95)
              VisualBasic (84)
              Assembler (46)
              Ответить
              • > bash (98)
                > Ruby (95)
                и всё только благодаря одному человеку
                Ответить
              • По твоей таблице выходит, что самые лучшие языки это Бейсик и Ассемблер.
                Ответить
              • Такое, как тут, с путаницей указателей на разные типы и с таким несоответствием ожидаемого - реальному результату, позволяет только сишка.
                Ответить
              • Все, что находится ниже, с большой вероятностью является хуйней. За любые суициды, совершенные в результате получения следующей информации, автор ответственности не несет.

                Возьмем метрику, учитывающую популярность языка и количество говнокода:
                (количество говнокода на языке / всего говнокода) / (процентная доля языка на рынке | в опенсорсе).

                В итоге получаем рейтинг языков, упорядоченных по говнотируемости (от слов говно и адаптированность):


                Язык       | Сложнейшие вычисления | Говнотируемость
                PHP        = (3112 / 10000) / 0.07 = ~445%
                C++        = (1084 / 10000) / 0.04 = ~271%
                Java       = (749 / 10000) / 0.08  = ~93%
                Си         = (386 / 10000) / 0.06  = ~64%
                JavaScript = (773 / 10000) / 0.21  = ~37%
                Ruby       = (95 / 10000) / 0.13   = ~7%


                В итоге, можно сказать, что сишка для говна совершенно не приспособлена! Такой популярный язык, а говна на нем совсем мало.

                Как рейтинг популярности использовал: https://github.com/languages
                Ответить
                • Жаба обогнала сишку только за счёт концентрации макак. Пых аналогично. Кресты - сами понимаете.
                  Ответить
                • Delphi всё равно вне конкуренции
                  Ответить
                  • У Delphi говнотируемость меньше жабы будет, я уверен.
                    Ответить
                    • дельфинариум не нужен - будь уверен
                      Ответить
                • Последний снимок:
                  http://web.archive.org/web/20130723065006/https://github.com/languages

                  JavaScript 21%
                  Ruby 12%
                  Java 8%
                  Shell 8%
                  Python 8%
                  PHP 7%
                  C 6%
                  C++ 5%
                  Perl 4%
                  CoffeeScript 3%

                  Потом эту табличку почему-то прикрыли.
                  Ответить
                • Обновим данные (для утопленных категорий возьмём данные из архива):
                  PHP:            5153/20079/0,07         = 367%
                  C++:            2146/20079/0,05         = 213%
                  Java:           1407/20079/0,08         = 87,6%
                  C:              835/20079/0,06          = 69,3%
                  JavaScript:     1594/20079/0,21         = 37,8%
                  Python:         531/20079/0,08          = 33,1%
                  Perl:           215/20079/0,04          = 26,8%
                  Bash:           max(8, 191)/20079/0,08  = 11,9%
                  Ruby:           max(7, 169)/20079/0,12  = 7,0%
                  Ответить
        • > Если начинать с сишки, то получается вот такое говно.
          > return x, y;

          Ага, http://stackoverflow.com/questions/423710/return-more-than-one-value-from-a-function-in-python
          Ответить
        • правильно.

          нужно начинать с PHP, тогда ты никакие языки больше не сможешь, и не будешь гадить в сишечке
          Ответить
          • Ойбля. Настоящий сишник может писать как на си на любом языке. Питон - это такая сишечка, где переменные объявлять не надо.
            Ответить
            • К сожалению это правда так. И это очень плохо. Потому что во круг столько крутых инструментов, а люди берут только то, что умеют
              Ответить

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