Тред синтаксического сахара над языком ассемблера, ака языка си. /clang/
C
09/02/24 Птн 19:47:31
№
1
Однако назрел вопрос с чем вы, аноны, склеиваете свои числодробилки, чтобы красивенько отображать информацию на экране монитора?
Из моих рассуждений я бы выбрал джаву. Да у нее есть проблемы с визуалом, графические библиотеки говно аляпистое и скорость вычсилений так себе. Однако графическую библу можно набросать и свою (помню как то делал уже подобие бустрапа под джаваформы, который тягал CSS листы и красивенько рисовал, но компик сгорел, надо заного набрасывать), а скорость вычислений мы как раз поручаем числодробилкам на языке си, запакованным в билбиотечки.
У вас какие мысли?
А что, консоль тебе недостаточно красивенькая?
Возможностей консоли недостаточно. Нужна именно пиксельная графика, то бишь мордорисование. Через какие костыли не так уж важно, я могу и с нуля накалякать какой нибудь визуальный конвеер для покраски кнопочек (прямоугольник в котором текст, это разве страшная задача для отрисовки кнопки), но хотелось бы не сильно заморачиваться именно с мордорисованием а все творческие силы пустить на алгоритмы числодробилок.
>ассемблера
>>3042192 (OP)
>си
>>3042192 (OP)
>джаву
>>3042192 (OP)
>CSS
Во-первых, тебе помирать уже скоро, а ты ui озаботился.
Во-вторых, бери винформс и не еби мозги.
qt если надо быстро
C Primer Plus - Стивен Прата
C Programming - A Modern Approach - Kn King
Есть на русском языке?
Нах C++. Можно в qt quick все сделать с минимумом плюсов, знаток.
Обеспечивается ли линейность памяти для массива массивов?
Можно какой нибудь простейший пример? Или обьясните почему пикрил валится с сегфолтом?
На вывод массиав не смотрите, судя по gdb он валится прямо на мемсете. "Сжатый" двумерный массив мемсетится легко, двумерный статический массив мемсетится легко, а вот массив массивов нихрена.
У тебя не двкхмерный массив. У тебя массив указателей на массивы.
Не уходи далеко. Через пару минут включу комп, проверю и покажу как правильно.
Короче, с динамической аллокацией двухмерных массивов не всё так радужно.
Легче моделировать самому через арифметику, как показано вот тут - https://www.geeksforgeeks.org/dynamically-allocate-2d-array-c/
Но если ты вот прям хочешь поебаться с массивами, то на картинке рабочий пример.
А можно и так извратиться. Чтобы не делать разименование указателя. Дело привычки и предпочтений.
Упадет с ошибкой.
Куча и стек находятся в разных концах виртуальной памяти. Например, в линуксе куча растет снизу вверх, а стек - сверху вниз. Есть специальный регистр stack pointer, который указывает на текущую вершину стека (или низ). Можно вычислить, находится ли твой адрес в куче или нет, и упасть по ассерту.
Возможно ли мою хуйню было сократить по кол-ву строк хоть сколько нибудь?
>а скорость вычислений мы как раз поручаем числодробилкам на языке си, запакованным в билбиотечки.
Если нормально писать то и джава неплохо дробит числа. Вот недавно был челлендж
https://github.com/gunnarmorling/1brc - джава обошла раст по скорости и почти догнала С++ (но тут неточно, потому что С++ запускался не на эталонном железе, которое само было производительнее)
>https://pastebin.com/n5fEZnW6
можешь задать свою хуйню одномерным массивом по типу
char huyn9[] = {,,,,,,'#',,'#' ... ,,,};
и потом вором вывести на экран где каждый n символ будет принтефатся \n
>>3068946
сомнительно, потеря скорости вычислений на трансляцию в джавамашине, это даже в теории не близко к числодроблению
>вором
фором
>будет принтефатся \n
но можно и не принтить перенос строки если ты фулл экран консоли заливаешь каким то своим рисунком в псевдографике
>char huyn9[] = {,,,,,,'#',,'#' ... ,,,};
или
char huyn9[] = " # # # ";
и выводить фором
или
char\* huyn9 = " твоя ебаная строка с рисунком хуйни ";
puts(huyn9);
лан похуй пойду посплю
все что я нашел нихуя не работает, хочу глянуть брекпоинты как рекурсия себя ведет, но пока нихуя не понимаю
> кодите что то на сях?
Полностью переехал на плюсы. Благо они уже для кофеварок научились компилировать.
Не помню уже когда писал что-то на чистом Си.
Я проштрудил книжку оч хорошую OOC, которая в шапке треда раньше висела. Потом ппц мотивация привалила, решил сделать свой евентлуп с асинхронными корутинами, ебался с этим парк недель, но забросил и уже полгода не притрагивался.
Да хз. Черт дернул пройти заного эту христоматию. Ковыряю задачки все подряд прямо с первой. Но так... не на энтузиазме, а лениво, час ютюба 2 строчки кода если грубо говорить.
Да и книга сложная, уже в первых главах где написан пример программы копирования файлов надо голову поломать как эта программа должна была работать по задумкам Ритчи (Керниган полюбасу там заложил тонну общения с консолью, а Ритчи повелся и кидает файлы в поток консоли а не в фопен).
Крч, вот так прям с наскока хуй кто осилит K&R Clang. Реально сложная книга со своими заковырками и неочевидными подводными камнями.
Я вот сидел и пытался в a.out скормить файлик чтобы проверить по заданию работу гетча, и нихуя у меня не вышло, но зато я нашел Heredoc о котором не знал, сижу вот читаю про эту волшебную штуку-дрюку.
upd
Если у кого то то же возникает затык в первых главах как программа Кернигана считает символы из файла без фопена, то задумка у них была пикрил.
>У вас какие мысли?
На дворе уже давно не 2000 год, пора из бункера вылезать
Вылезай из бункера, уже третий десяток пошел как jit запилили
>сомнительно, потеря скорости вычислений на трансляцию в джавамашине, это даже в теории не близко к числодроблению
Там есть специальные подсистемы в JIT (C1 и C2), которые по сути кэшируют трансляцию часто используемого кода. То есть ты будто в рантайме бинарник компилишь и с ним работаешь. Плюс т.к. джава может в рантайме менять код, в отличии от С++, она может оптимизировать в зависимости от того как код используется - разворачивать циклы, переставлять операции и т.д.
https://habr.com/ru/articles/305894/
хабр помойка, тем не менее, это потеря скорости
компил в рантайме/трансляция это потеря скорости исполнения кода, как вы этого понять то не можете? совсем обджавились уже
заместо пармы мувов по регистрам ты делаешь компил + пара мувов по регистрам
уже на пальцах вынужден объяснять джавистам как работает джавамашина пиздец до чего дошли
спора нет, жаба уже двадцать лет по производительности не хуже плюсов, и ебет в хвост и гриву всякие высокоскоростные всхрюки типа растов. и причину тебе уже озвучили - оптимизация кода в рантайме основанная на статистике исполнения кода, фича, которая в принципе недоступна компилируемым языкам.
>>3082318
>компил в рантайме/трансляция это потеря скорости исполнения кода, как вы этого понять то не можете?
книжки почитай прежде чем хуйню пороть
ты там на перфокартах код пишешь что у тебя программы штучными мувами по регистрам измеряются?
>заместо пармы мувов по регистрам ты делаешь компил + пара мувов по регистрам
правильно так - заместо пары миллиардов мувов по регистрам ты делаешь пару миллионов мувов, потом оптимизацию, и потом еще пару сотен миллионов мувов.
>по производительности не хуже плюсов, и ебет в хвост и гриву всякие высокоскоростные всхрюки типа растов
чел мы в ситреде, тут бенчи по асму меряются, а не по твоим тормозным джавам плюсам растам питонам джиэсам, проснись
>>3082329
оптимизировать и гцц умеет и будут теже мувы но зато без потери процессорного времени
джависты вам тут не рады
умоляю хватит тралить тупостью
>без потери процессорного времени
на компил в рантайме
так понятно стало?
>компил в рантайме/трансляция это потеря скорости исполнения кода, как вы этого понять то не можете? совсем обджавились уже
>заместо пармы мувов по регистрам ты делаешь компил + пара мувов по регистрам
Чел ну ты ебанат? Трансляция 1 раз происходит, потом ты из кэша достаешь свои мувы по регистрам
>тем не менее, это потеря скорости
манямирок затрещал, но выстоял, упорный!
>оптимизировать и гцц умеет и будут теже мувы но зато без потери процессорного времени
гцц не знает как ты будешь использовать программу каждый раз когда ты её запускаешь, а жит знает
>джависты вам тут не рады
не гори только от джавабогов
>чел мы в ситреде, тут бенчи по асму меряются, а не по твоим тормозным джавам плюсам растам питонам джиэсам, проснись
Спецом для тебя я скинул пруф https://github.com/gunnarmorling/1brc , тут как раз на джаве угорают по лоу левелу и постят результаты бенчмарков
А ты контролируешь свой си-компилятор-нейм? Может еще знаешь как каждый из них UB резолвит?
пруф чего ты мне скинул? это чисто джава бенчи насколько я вижу тк тут написано напишите программу на джаве
пруф того что жаба умеет складывать вычитать и компейрить числа? ахуенно
>>3082802
>гцц не знает как ты будешь использовать программу каждый раз когда ты её запускаешь, а жит знает
хз чо ты высрал, даже разбирать тобою написанное не хочу
>>3082798
а если проц без кешлиний? поешь говна лучше и не пиши сюда
Без каких либо ограничений на размер строки означает что нам недоступно хранение строки внутри char arr[size_t]. Удачи.
просто взять указатель на строку и отправлять байты на вывод пока не встретишь нулевой байт?
>пруф чего ты мне скинул? это чисто джава бенчи насколько я вижу тк тут написано напишите программу на джаве
>пруф того что жаба умеет складывать вычитать и компейрить числа? ахуенно
здесь сравнения с другими языками
https://github.com/gunnarmorling/1brc/discussions
>а если проц без кешлиний?
джавамашина кэширует, не процессор
так пруфы чего?
Пруфы того что ты не читаешь ридми. Там эталонный сервер на Хетцнере, иначе каждый бы мог просто на более мощной машине запустить и сказать что у него питон быстрее работает.
а если проц без кешлиний?
Не пойму как ты через сишку кажешь процу что ему кэшировать, а что - нет, может расскажешь? Просто хочу разобраться
ты принес какую то хуету, а я должен бегать по крупицам собирать инфу что это все значит и что ты хотел сказать своим высером?
да пошел ты нахуй анон, поебать мне на твои бенчи хуенчи сделанные ПАПРИКОЛУ, жаба медленне си, это аксиома, хочешь опровергнуть - неси бенчмарки
>>3084467
>а если проц без кешлиний?
тогда одинакого будет, холодный старт только медленее, нужно время на транслейт
> как ты через сишку кажешь процу что ему кэшировать, а что - нет
префетчинг, паттерны известны, однако это все равно неуправляемый напрямую процесс
Тебе надо - ты и прикрепляй
Ну раз в главе нет указателей, то и в языке нет, понимаю
>ты принес какую то хуету, а я должен бегать по крупицам собирать инфу что это все значит и что ты хотел сказать своим высером?
Ты ничего не должен, я дал тебе таблицу результатов, ты со сгровешей жопой побежал проверять на локалке, потому что не верил что джабба может быть такой быстрой. Тут уж не моя вина.
чо ты понимаешь то? систему уравнений то же через теорию игр решать будешь?
>>3084491
на какой локалке, даун? это твои две ссылки, делать мне нехуй проверять на своей машине какой то паприколубенч
пиздец двач наплодил даунов
>неси бенчмарки
И да, эта репа фактически и есть бенчмарк, так что бенчмарки я принёс. Просто ты сравнил не Си с джавой, а джаву на локале и джаву на хетцнере.
Вот сишное решение https://github.com/gunnarmorling/1brc/discussions/46
>на какой локалке, даун? это твои две ссылки, делать мне нехуй проверять на своей машине какой то паприколубенч
Не гори только, скуф
Что тогда за вторая картинка с замерами от тебя была? Мне мысли твои чтоли читать?
я вообще ничо не сравнивал, тут нечего сравнивать
ты принес ссылки я их открыл нашел сишный тредик и сфоткал результы
теперь ты говоришь что я принешь жабу на локалке, а вот ты то принес сишник на хетцентре, но по твоей ссылке как раз сишник на локале
покинь тредик, ты не в адеквате, чел
давайте раз и навсегда определимся почему си быстрее жабы
есть только одно пруфабельное определение - си быстрее жабы потому, что на совершение действия А ему не нужно совершать дейтсвие Б. о чем ручь? о строительстве объектов и вызове череды колбеков для записывания какого нибудь несчастного стринга в память. ооп это априори медленно.
в остальном можете играть в суррогатные гонки с миллиардом повтроений одной вычислительной инструкции и говорить что все одинакого. этот тест необъективен так как байткод исполняется фактически один и тот же на одной и той же машине, тут нет никакой гонки
к слову мне кажется этот странный челлендж из ссылки - посчитать много даблов в мультипотоке, звучит как задача для гпу
>есть только одно пруфабельное определение - си быстрее жабы потому, что на совершение действия А ему не нужно совершать дейтсвие Б. о чем ручь? о строительстве объектов и вызове череды колбеков для записывания какого нибудь несчастного стринга в память. ооп это априори медленно.
Это слишком упрощенное определение, потому что:
1) совершение меньшего количества действий не всегда даёт быстрее выполнение на современных процах.
2) Java - мультипарадигма, а не чистый ООП, писать как на С никто не запрещает, даже с ручным выделением памяти
3) Тот же пример с размоткой цикла - сишка тупая и если ей сказали крутить циклы - она будет крутить циклы и нарушать instruction pipelining, в то время как джава умная и может понять что цикл можно развернуть и ускорить таким образом код.
4) возвращаясь к "совершение действия А ему не нужно совершать дейтсвие Б" -> джава может в рантайме понять что ей не нужно что-то совершать и таким образом будет быстрее кода, который не адаптируется к рантайму.
А захламить код мусорными аллокациями можно и на С, было бы желание.
>в остальном можете играть в суррогатные гонки с миллиардом повтроений одной вычислительной инструкции и говорить что все одинакого. этот тест необъективен так как байткод исполняется фактически один и тот же на одной и той же машине, тут нет никакой гонки
ничего не понял
суррогатные гонки - это и есть суть бенчмарков, ты о чем?
>к слову мне кажется этот странный челлендж из ссылки - посчитать много даблов в мультипотоке, звучит как задача для гпу
Ну так челлендж выжать максимум конкретно из джавы, а не просто считать числа где-нибудь
>сишка тупая
кукарек, ничем не подкрепленный
>джава может в рантайме понять что ей не нужно что-то совершать и таким образом будет быстрее
время на "понять" конечно же не нужно, ведь это происходит по волшебству
>конкретно из джавы
типичная жавазадача - компайрить даблы, верим
>суррогатные гонки - это и есть суть бенчмарков, ты о чем?
то к чему они пришли, а не их суть
Я тут мимо проходил, если что
Бля, даже для кубейсика был компилятор, который исполняемый файл выдавал.
Для тех же джавы и сишарпа есть АОТ, которая выдаёт машинный код. Только это нахуй не надо, потому что собираешь в машинные коды ты для конкретного набора инструкций, и на более старых процессорах это просто не запустится, а на более новых не будут использоваться новые сокращающие время исполнения инструкции.
В это же время байткод джавы, ИЛ сишарпа, да даже код джаваскрипта выполняются рантаймом, который знает, что поддерживает процессор, а что нет, и во что можно код переводить, а во что нельзя.
Если я в проге использую printf с параметром %d, компилятор засовывает в прогу весь функционал функции или даже stdio.h? Как удалить ненужное?
линкуй только функцию
так как есть скрытый флаг в компиляторе -lstd то линкер так или иначе найдет бинарное исполнение любых функций из стд либы без хидера (малоки хуялоки)
вопрос лишь в том нахуй оно тебе надо? бинарь все равно форматный, будут просто куча пустых адресов, покури ELF если ты на винде
В чем проблема определить сначала размер большей строки, и тогда по смещению от потока вывести ее?
>даже для кубейсика был компилятор
Что значит даже? Для бейсика есть компилятор, а для джавы и шарпа нет, потому что, в отличие от бейсика, жабошарп это скриптовое говно, а не языки программирования.
Да я не настаиваю, решай задачу которая тебе удобней. В любом случае это был просто челлендж ак 100 задачек литкода или типа того, и каждый сам для себя решает принимать участие или нет. Я только прошу внимательно читать условия задачи, а то я уже заебался повторять одно и то же.
Ты вбросил задачу, которой нет в КР. И очень даже возможно, что она не решаема
Есть. Решаема. Тебе не надоело набивать посты этим бесполезным спором? То перевод тебе не нравится, то вообще задачи нет такой.
Есть какой нибудь гайдик что засунуть в мантиссу и сонование чтобы получить максимальное и минимальное значение флоатов по границам? Я ничего не нашел в интернетике кроме формулы.
Пойду пока цветовую схему поковыряю, а то дефолтная всратая.
Всем салют. Чисто из любопытства: как в чистых сях обстоит дело со строками, конкретно с кодировкой? Вот чтобы максимально переносимо было, какой тип используют люди? Utf8, или 16 или 32?
Спасибо
я не иксперт, но вроде как в чистых сях есть какая то библа в наборе стандарта которая работает с вайдчарами и переносимо покрывает все кодировки
но я хз, не пишу переносимые. обработчики текста, так что на своей машине юзаю утф8 юникоды где латинские в один байт русские в два вот собсна и все
>чтобы максимально переносимо было, какой тип используют
Первые 128 символов ascii
>>даже для кубейсика был компилятор
>Что значит даже? Для бейсика есть компилятор, а для джавы и шарпа нет, потому что, в отличие от бейсика, жабошарп это скриптовое говно, а не языки программирования.
Это ложь.
https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/?tabs=net8plus%2Cwindows
Для джавы тоже есть.
Повторяю, в подавляющем большинстве случаев JIT лучше, чем нативная компиляция, потому что JIT может транслировать твою программу в команды текущего процессора, используя всю его мощь, а говноязык без JIT может только нацелиться на какой-то конкретный процессор, причём на более старых моделях программа просто не будет работать, а на более новых она будет выполняться неоптимально.
да успокойся ты, джитошиз, покури флаги компилов и статистику по используемым инструкциям процессоров
а еще раз тебе не лень срать ссылкми принеси джит компиляцию которая юзает все 2к+ инструкций современно проца
жаль а) я нищий б) у ноута всего один слот ссд.
придется отлодить учебу (
так бы купил 8тб ссд м.2
>покури флаги компилов и статистику по используемым инструкциям процессоров
а можно просто использовать жабку и в ус не дуть
>Для джавы тоже есть.
Вот кстати
https://www.graalvm.org/latest/docs/introduction/
c если нужен минимализмc++ если проц без хидера (малоки хуялоки)вопрос лишь в отличии от бейсика, жабошарп это скриптовое говно, а лениво, час ютюба 2 строчки кода в рантайме понять то дефолтная всратая.
сначала мы определяем что это присваивание и что инкремент постфиксный (после присваивания)
потом начинаем вычислять правую часть присваивания
где сначала вычисляется условие тернарника, а затем вычисляется одна из его веток
потом происходит само присваивание
и вот только теперь постфиксный инкремент
докажите что компилер не даун?
Ну да, на пустом месте ругается. Но может быть у него крыша едет из за тернарной операции?
Это UB. Поведение зависит от того, будет ли сначала выполнено выражение слева от знака равенства, или справа. Так что ругается он по делу. Не делай так, короче.
приветствую уб шиза в этом итт треде
поясни за выполнение выражения слева от знака равенства или справа
как вычисление этих частей соотносится с приоритетом вычисления постфиксного инкремента слева от знака присваивания?
https://en.cppreference.com/w/c/language/eval_order
> и вот только теперь постфиксный инкремент
Найди ордеринг рул который говорит что сайд-эффект постфиксного инкремента вычисляется после assignment оператора.
Я сходу такой не нашёл, есть что-то похожее в последних стандартах плюсов.
ну вот например тебе твой ордеринг рул который говорит что сайд эффект постфиксного инкремента вычисляется после эсс игнмент оператора
как видно из таблички приоритетов = и += обладают одним уровнем приоритета выполнения и вычисляются справа налево
и пик 3 небольшая справочка для тебя лично, любителя носится со стандартом как со святой грамотой
лучше бы ты K&R читал а не хуйней маялся
> скрины из K&R
Ну хуй знает.
> и вычисляются справа налево
Я аж сначала охуел от такого пиздабольства, потом открыл и понял что "справа-налево" это сука про ассоциативность оператора. И в этой же сука главе тебе говорят что порядок вычисления операндов не специфицируется для большинства операторов, и приводят твой же UB как пример UB: a[ i ] = i++, долбоёба ты кусок.
> любителя носится со стандартом как со святой грамотой
Если в стандарте нет явно-указанного ордеринга вычисления, они спокойно могут быть как угодно упорядочены компилятором, и разрабам компилятора похуй что ты там думал, щенок ебаный.
И есть ли реальная компиляция джава/шарпа говна в машинный код.
критерии лучшести огласите
ты же понимаешь что проц умеет только машкод выполнять?
Лучше конечно компиляция в машинный код с глубокой оптимизацией. В идеале под конкретную модель процессора, с учётом его микроархитектуры.
Касательно c# - претензий к скорости программ не имею, но вот этот jit во время работы большого проекта (300 тыс. строк, не считая библиотек) очень неприятно и мерзко лагает. Слава богам что не часто. Но при старте программы есть несколько мест где реакция гуя достигает несколько секуд (!!!).
К этому быстро привыкаешь, потому что дальше всё работает весьма сносно. Но когда запустил аналогичную программу, написанную на компилируемом языке, было очень приятно работать из за неестественно отзывчивого интерфейса с нулевой латентностью.
Короче, однозначного ответа на твой вопрос нет.
PGO на твоей пеке под твои юзкейзы со всеми --march=native, графитами, lto и прочим, чем гентушизы упарываются
в этом плане компил в нативный машкод конечно же
за это заплатишь скоростью разработки
>И есть ли реальная компиляция джава/шарпа говна в машинный код.
Конечно есть, иначе бы программы не выполнялись.
>Так все таки, что лучше (с фактами) jit или компиляция в машиный код?
В большинстве случаев JIT лучше - это факт
У джавы и шарпа есть возможность компилить сразу в машинный код, без JIT, как на C. Судя по бенчам выигрышь получается в потреблении памяти, но не в производительности (после разогрева конечно).
Иметь рантайм оптимизации лучше чем не иметь - это тоже факт
Вот пожалуйста
Был бы я не ленив, посоревновался бы с тобой, чья программа быстрее - твоя с git, или моя в нативном коде.
Например, N-ферзей
Это будет не соревнование языков, а соревнование кто ебанутей оптимизации напишет.
Я, при этом, абсолютно уверен, что программа на си будет быстрее программы на сишарпе/джаве хотя бы за счёт оверхеда из-за абстракций и управляемой памяти.
Одновременно я абсолютно уверен, что в большинстве случаев си не нужен, потому что код на си будет писаться раз в пять медленнее и содержать в пять раз больше богов. И выбор в итоге будет не между быстрой программой на си и медленной на джарпе, а между работающей программой на джарпе и недописанной на си.
мимо
>программа на си будет быстрее программы на сишарпе/джаве
Если не будет сборки мусора, будут работать с одинаковой скоростью. Шарп и джава очень хорошо могут в оптимизацию.
Согласно POSIX:
https://pubs.opengroup.org/onlinepubs/9699919799.2018edition/
В math.h обработка ошибок зависит от значния math_errhandling. Если math_errhandling & MATH_ERRNO != 0, то в errno выставляется значение ошибки, если math_errhandling & MATH_ERREXCEPT != 0, то выкидывается соответствующий excpetion.
Тогда почему у меня при math_errhandling = MATH_ERNNO | MATH ERREXCEPT при вызове acos(2) не происходит исключения? glibc вроде как выполняет стандарт POSIX 2008, я проверил там точно также
Я ожидаю что мне придет SIGFPE, но де факто лишь errno выставляется
>math_errhandling = MATH_ERNNO | MATH ERREXCEPT
>math_errhandling & MATH_ERRNO != 0
>math_errhandling & MATH_ERREXCEPT != 0
я не наблюдаю эквала между a = b|c и a&c !=0 а ты наблюдаешь?
При условии того, что и ERRNO и ERREXCEPT 1 и 2 по POSIX соответсвенно.
Тогда a = b|c && b != 0 && c != 0 => a & c != 0 && a & b != 0
хмм ну вроде все верно. для чисел 1 и 2
а не пробовал вызвать троу макрос из глибси принудительно?
Не понял, про какой именно макрос ты говоришь?
Вообще я ожидал что будет что-то типа raise из csignal
Может я просто не правильно понимаю что имеется ввиду под invalid floating-point exception shall be raised, но нигде инфы не могу найти
Дык этож даже не glibc, а отедльная либа
Ну и не вышло к слову...
Отдельно попробовал с мюслями - тоже самое
А потом полез их сурсы:
/ if |x|>1, return NaN with invalid signal./
Реализация:
/ |x| >= 1 or nan /
if (ix >= 0x3ff00000) {
uint32_t lx;
GET_LOW_WORD(lx,x);
if ((ix-0x3ff00000 | lx) == 0) {
/ acos(1)=0, acos(-1)=pi /
if (hx >> 31)
return 2*pio2_hi + 0x1p-120f;
return 0;
}
return 0/(x-x);
}
ЗБс соотвествие стандарту
не хочу вдаваться в подробности, но
>ЗБс соотвествие стандарту
арифметика не может быть стандартизирована так как она за исключением ансигнедов абсолютно машинозависима
ты стандартошиз что ли?
Нет, просто делаю диплом по модельному тестированию на соответствие POSIX, и тут вот это начало стрелять
А на чем мне теперь проверяться то, раз тесты справедливо фейлятся?
хммм я наверное глупость сейчас скажу, но последнее время чот на меня напал интересный язык лисп, кажется он идельно подходит для быстрого прототипирования (макеты программ) ну и соответственно тестирования всякой фигни то же, но лисп СТРАННЫЙ, условно сумма всех чисел в обычном языке это забить массив, пройтись фором все сложить, в лиспе это (PLUS числа через пробел) вот и все
манит меня попробовать эту штуку
Пожалуйста, соревнуйся - https://github.com/gunnarmorling/1brc выбирай победителя, напиши свою имплементацию и попробуй
>программа на си будет быстрее программы на сишарпе/джаве хотя бы за счёт оверхеда из-за абстракций и управляемой памяти
ты можешь писать на джаве (и наверное на шарпе?) без абстракций и без управляемой памяти
А можно из буханки хлеба сделать трамвай, и линукс на домашний комп поставить.
Вся суть джарпа в менеджд коде и ООП. Глупо отказываться от таких удобных вещей в угоду небольшого буста производительности.
ой посоревновались >>3084361 выбираем си
>>3101272
ды да, достаточно просто выбрать нужный инструмент
Конечно глупо, но это ведь абстрактное соревнование в скорости. Плюс к тому Ява позволяет выборочно писать высокопроизводительный код только там где это необходимо и писать как удобно там где нет смысла гнаться за скоростью.
ему нравится как его обоссывают?
Говно. Но хороший компилятор способен оптимизировать это.
Если гцц/мингв, то изящнее range switch.
case 'A' ... 'Z': и тп.
А тут у тебя восемь лишних проверок а худшем случае.
ну это не особо влияет задачка не под бенчмарки и эта функция вызывается 5 раз, все основные мощности в другом куске
ренджовый свич еще не был рассмотрен в этой главе так что его тут быть не могло
>а что ты тут собрался оптимизировать?
Во первых - ничего. Зачем мне оптимизировать твой код, пущай этим занимаешься ты и/или компилятор.
Во вторых, isdigit() и isalpha() для простоты.
В третьих, неоптимизирующий компилятор сгенерил бы такой говнокод, что ты бы охуел - s[p-1] на х86 выродился бы в нечто такое mov %al, (%esi,%eax, -1) и постоянно обращался бы к памяти.
Оптимизирующий компилятор выполнит обращение к памяти один раз, загонит значение из памяти в регистр и дальше будет сравнивать с регистром.
>Во вторых, isdigit() и isalpha() для простоты.
на пике просто наружка твоих издигитов изальф
это уже кому какие сексуальные предпочтения по душе, кто то любит блекбоксить кто то нет
>В третьих, неоптимизирующий компилятор сгенерил бы такой говнокод, что ты бы охуел - s[p-1] на х86 выродился бы в нечто такое mov %al, (%esi,%eax, -1) и постоянно обращался бы к памяти.
чот я тут такого не увидел
>чот я тут такого не увидел
Смотри внимательнее.
Как же ARM посасывает у x86 на этом примере. Загляденье.
у тебя процентики а тут их нет
а еще я тут могу только sp регистр опознать остальное не знаю
>Как же ARM посасывает у x86 на этом примере. Загляденье.
ну и в чем же?
а такие мувы не считаются ансейфед или типа того?
видимо никто не собирается слушать байки о том как х86 ебет арм жопой
>а такие мувы не считаются ансейфед или типа того?
Так за этим ядро следит. Если к незамапленой странице полезет, то сгенерится прерывание, OC его перехватит и посмотрит что произошло - полезла программа в чужую память или страницы в свопе.
Если в свопе, то подгрузит страницу и свопа и перезапустит операцию, а если память чужая, то Core Dump и программа вылетела в ОС с ошибкой.
бля чел
твой мув это ldrsb
ты как без вычисленных оффсетов по стеку решил грузануть мувом байты? получается ты меня наебываешь вот тут - >>3102655
точно так же будешь делать свои 4 инструкции
>ты как без вычисленных оффсетов по стеку решил грузануть мувом байты?
Хмм. Ну да, я форшманулся. Две инструкции на ARM, одна инструкция на X86.
насколько я знаю разница архитектур в том что на арме интрукции одинаковой длинны по машкодам а в х86 разной
думаю листинг асма не такой уж и показатель
не получится так что твой волшебный мув по машкодам и декодингу длиннее в тактах чем мой крестьянский мув в две инструкции? вот щепетильный вопрос
вообще я хуй знает какой то оффтредовый холивар надо в асмотред идти там срать этим
>думаю листинг асма не такой уж и показатель
я придерживаюсь другого мнения.
Не сказать вот чтобы x86 настолько хороша, но плотность кода у неё повыше будет, чем у ARM.
Вроде мелочь, а инструкции из память чуть быстрее выбираются, чуть больше инструкций в кэш поместится.
> Вообще я хуй знает какой то оффтредовый холивар надо в асмотред идти там срать этим
Асмотред помер. RIP. А ОП опрометчиво упомянул ассемблер в названии темы, решив нагнать сюда анонов. У него почти получилось, хоть коряво и неумело.
Итак, нашел причину тряски
Оказывается Posix ТАК ХОРОШО написан, что под raise invalid pointer exception он имеет ввиду лишь установку флага в структуре из <fenv.h>
Код:
https://pastebin.com/EaiXPnUz
ЧЯДНТ?
Ну у тебя т.к. n == 1 чисто aio_read пройдёт и программа выходит, не? Мб просто не успевает aio нихуя сделать, программа выходит
>Ну у тебя т.к. n == 1 чисто aio_read пройдёт и программа выходит, не?
У меня же getchar в конце. Пока не нажму enter - программа не выйдет.
Вроде у меня везде unsigned long long, а результат всё равно - превышение предельного значения (пик 1).
Щито делать? В чём причина?
Аноны, я чутка улучшил ф-цию, но всё равное какая-то залупа происходит: величина переменной num правильная, а когда сохраняю её в массив, то он мне выдаёт превышение допустимого значения!!! Как это побороть?
Может это залупа, отображающая числа в режиме отладки не понимает unsigned, и рисует так как будто число signed?
У тебя там по идее должно быть 1600...00000, а вышло -8....1616
Максимальное 64-битное беззнаковое целое оканчивается на 18...1615
Да, анон, это, короче, мой косяк я в деббагере не увидел, что можно также unsigned выбрать.
И вообще я победил эту проблему - у меня спецификатор в sprintf был неверно указан.
ладно бы какая то задача попалась сложная и поставила бы в тупик, я бы себя понял, но я даже не вникал, чисто глазами пробежался что там надо atoi() переписать и все, тупо не могу даже файлик точнуть...
>и поставила бы в тупик
Пиши на чистом Си, без использования ф-ций из стандартной библы, но только, если ввод/вывод, и то, можешь сам сделать эти ф-ции, используя низкоуровневые вызовы.
канешн, пишу велосипедики, конпелирую, отлаживаю, стараюсь делать для общих случаев, но юникод с разной длинной символов уже заебал костылить его так что последние только на энглюсике работают
ну листинг с пика мало чо показывает, бинари на гит не заливаются, а дебаг выхлопы и кордампы я деличу прост (хотя там то же гитигнор на наих настроен, но прост привычка подчищать всякое говное ненужное)
>пишу велосипедики, конпелирую, отлаживаю, стараюсь делать для общих случаев
Логично. Правильно. Верно.
>но юникод с разной длинной символов уже заебал костылить его так что последние только на энглюсике работают
Не, в юникод тебе рано лезть. Правильно что пишешь на английском. Юникод это своя вселенная.
>хули толку, мотивации нет говорю же
Ну тут хуууй знает, чем тебе помочь. Отдохни, отвлекись, или, если нет мотивации, то и живи дальше в говне (в скрипто-макакном высоко-уровневом мире)!!!
это файл но не файл. в него пишется информация для передачи, а читается для получения
Затем файл просто исчез непонятно почему и я ебанулся
:~/so$ vim lol.c
user@user-A320M-S2H:~/so$ gcc lol.c
lol.c: In function ‘main’:
lol.c:20:40: warning: passing argument 2 of ‘connect’ from incompatible pointer type [-Wincompatible-pointer-types]
20 | int result = connect(socketFD, &address, sizeof address);
| ^~~~~~~~
| |
| struct sockaddr_in
In file included from /usr/include/netinet/in.h:23,
from lol.c:2:
/usr/include/x86_64-linux-gnu/sys/socket.h:126:52: note: expected ‘const struct sockaddr ’ but argument is of type ‘struct sockaddr_in *’
126 | extern int connect (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len);
| ^
user@user-A320M-S2H:~/so$ gcc -o lol.c c
/usr/bin/ld: cannot find c: No such file or directory
collect2: error: ld returned 1 exit status
Хуй мне кто поможет, но я ахуел, что файл просто так исчез и все что я писал
>gcc -o lol.c c
>/usr/bin/ld: cannot find c
Ну ты почитай хоть что пишет. Не может найти файл "с".
>incompatible pointer type
>‘const struct sockaddr ’ but argument is of type ‘struct sockaddr_in *’
>No such file or directory
помог тебе понять
>файл просто так исчез
ну мб у тебя остался вимдамп, а может и не остался нехуй вирусы всякие писать
Во втором случае у него какая-то хуйня в командной строке. Ругается на неё.
выглядит так будто ругается на параметр с в строке
>gcc -o lol.c c
но на первый взгляд все правильно, хоть и корявенько
>gcc lol.c -o c
>>gcc -o lol.c c
Молись, чтобы в той директории у тебя не было файла с
Иначе твой исходник отправится в страну, откуда файлы не возвращаются. Ибо ключ -о требует аргумент (параметр).
>>3116344
Так-то надо мейкфайл написать.
Можно сделать это один раз, написать "дженерик" мейкфайл, который потом всегда реиспользовать для мелких проектиков типа лаб.
CC=gcc
TARGET=c
SOURCE=main.c huy.c pizda.c nebo.c allah.c
all:
$(CC) $(SOURCE) -o $(TARGET)
ну и конечно по желанию клин и ран. Всё, универсальная сборка для подобных проектов готова.
соглашусь с этим аноном
минималистичный тулчейн для поделок (текстовик + сборщик + линтер + тесты) это уже не только уровень, но и удобство
мейк такой же простой как и вим, чуть подрочить его и впринципе уже будет готов мейкфайлик со всеми таргетами ветвелниями параллельной сборкой флажками на тестолинтерах и прочими наваротами
потом уже можно поковырять какие нибудь грейдлы мавены если нужда есть для галеры
по изоляции приложунек я хуй знает, я ничо не юзаю никаких докеров кубернейтсов, пока что не было нужды
> Почему за столько лет не разработали удобную инфраструктуру под си?
Да а нахуй он нужен? Си никому не интересен кроме парочки нердов. Кроме программирования каких-нибудь PIC16 как альтернатива ассемблеру. Нерды умеют и любят пердолить конфиги. А обычным нормальным людям си нахуй не обосрался. Поэтому и удобную инфраструктуру никто не делает.
>>3120718
Он очевидно имеет ввиду аналог npm, pip и прочей такой хуйни, которая сама подтягивает зависимости.
пусть себе напишет такую хуйню
pip то же на сях написан полагаю
все написано на сях
одни только питухонисты о нердах каких то говорят
> Такое ощущение, что всё застряло на уровне 80-90-х и не развивается.
Этот о чем-то догадывается.
Meson уже есть, то что вы на него не перешли - ваша проблема.
Можно деб пакеты ставить, но вообще пакеты - это зло ёбаное.
А куда тогда данные записываются/считываются при сокетном соединении?
> шо такое сокет .
Oh boi https://docs.kernel.org/networking/skbuff.html
Шо такое сокет - это файлы,
Файлы, куда байты шлют сетями,
В дейтаграммах видео приходит без задержки,
Для надежной передачи сделан TCP.
Сокет - база для UNIX систем,
Для работы с сетью сокет нужен всем.
Там, где REST сервис шлет JSON,
Сокетом получается он.
Никак. В современных многозадачных ОС с экраном работать невозможно, это прерогатива ОС которая пользовательским приложениям такого делать не позволяет, иначе одно приложение поломает другие. Если же пишешь под DOS, там просто пишешь в видеопамять и готово, так же в DOS можно пользоваться функциями BIOS, но они тормозные.
>это прерогатива ОС которая пользовательским приложениям такого делать не позволяет
А как тогда opengl работает?
Безусловно, ты, конечно, весёлый парень, но всё же - как opengl работает, если не через системные вызовы?
Ты и сам знаешь, даже текст обрезал чтобы было удобнее жопой вилять.
> без всяких opengl
Нет смысла игнорировать то что тебе даёт драйвер gpu.
>даже текст обрезал чтобы
Т.е. ты знаешь как оно работает, но не хочешь говорить! Ну и как же оно работает, если не через системные вызовы?
P.S. я не знаю как это работает, от того и задаю этот вопрос.
Библиотеки графики через системный вызов ioctl общаются с драйвером gpu.
>Почему за столько лет не разработали удобную инфраструктуру под си?
Разработали, и имя ей - UNIX. Командная строка рулит.
>Чтобы удобно было собирать проект одной командой
make и CMake в той же командной строке
>подтягивать библиотеки из репозитория
Средства Linux для работы с пакетами, а единого центрального репозитория нет. Сишники - люди свободные и гордые, их не заставишь ходить строем, и в цифровой концлагерь Шваба с жучиной похлебкой они не пойдут.
>Такое ощущение, что всё застряло на уровне 80-90-х и не развивается.
Дух старой школы, хакерской романтики и цифрового анархизма жив только в Си. Дедушка Столлман наш учитель и вождь, а порриджам-смузизлебам из пейсбука и реддита здесь не рады.
На низком уровне по-разному, зависит от архитектуры ОС. Например, в Linux можно записывать в файлы /deb/fb (фреймбуфер экрана) и /dev/dri (интерфейс DRI/DRM). Вот пример вывода 2D графики без библиотек, путем записи во фреймбуфер:
https://github.com/BartekLew/fblib/blob/fb-example/fbgrad.c
Библиотеки SDL, OpenGL, Vulkan и др. являются надстройками над ОС и позволяют делать это кроссплатформенно, не вникая в детали, не нужные прикладному программисту.
>>3129349
Реализация OpenGL и Vulkan предоставляется драйвером видеокарты и работает на уровне ядра. А пользовательское приложение уже вызывает OpenGL функции.
Wchar_t не везде есть и не везде работает. Поэтому только char и utf8.
>только char
ну не будь таким строгим, не обязательно только чары, можно и инты, а в случаях ловли ЕОФа исключительно инт
да и вообще инты как то предпочтительнее, так как у большинства машин шина четырехбайтная - меньше жонглирования = быстрее рантайм
>>3132845
или ты имеешь ввиду что это длина элемента в массиве что ли?
типдеф тогда слепи себе из структуры в котором массив чаров лежит нужной длины
А если 2 байта надо?
>>3132847
В других языках типы данных делают точной длины, поэтому можно делать массивы нужного размера, а си расплывчато. Тип может 1 байт, а может 2, иногда 4, хуй знает вообщем. Кто вообще это придумал? Неужели нельзя было сделать чёткие типы в 1, 2, 4 или 8 байт?
Нельзя, потому что наличие таких типов зависит от системы, на которой исполняется код. А вообще смотри типы в stdint.h, если не пишешь код под что-то экзотическое.
>Кто вообще это придумал? Неужели нельзя было сделать чёткие типы в 1, 2, 4 или 8 байт?
Нельзя, это зависит от железа. Я например имел дело с железкой с минимальной адресацией 16 бит, соответственно и char был 16 бит. Остальные языки или работают на виртуальных машинах, или это раст, работающий в тепличных условиях (не на любом говне).
В Vala как-то сделали типы с гарантированным размером (int8, int16, int32, int64, uint8, ..., uint64), хотя это кросс-компилятор поверх обычного си.
> ну не будь таким строгим, не обязательно только чары, можно и инты, а в случаях ловли ЕОФа исключительно инт
Я только и исключительно о представлении строк.
> да и вообще инты как то предпочтительнее, так как у большинства машин шина четырехбайтная
Отстал ты.
>. Кто вообще это придумал?
Ричи. Он отталкивался от В, где был один тип данных.
> Неужели нельзя было сделать чёткие типы в 1, 2, 4 или 8 байт?
Нельзя было вот так вот сплеча. На пдп-11 слово было длиной 36 бит.
typedef signed char int8;
typedef unsigned char uint8;
typedef signed short int16;
typedef unsigned short uint16;
typedef signed int int32;
typedef unsigned int uint32;
typedef signed long long int64;
typedef unsigned long long uint64;
Никак. Что сам написал в объявлении, с тем дело и имеешь. И typeof() тебе не поможет решить такую задачу.
>в зависимости от типа данных направить исполнение кода в нужном направлении
Это просто удобная генерация кода на этапе компиляции.
> И какой алгоритм определения типа у ф-ции typeof()?
Это не функция.
>А если 2 байта надо?
тогда >>3132847
при условии что чар однобайтный
камон мы тут не на экзотике
>при условии что чар однобайтный
опять же чар всегда однобайтный так как чар это синоним байта на любой машине
полагаю дженериками/макросами ветвили, ну в общем то си как раз и предполагает, что такие ветвления делаются до рантайма
прямо в рантайме нахуя если можно до? ну это примерно кейс мультиплатформенности:
ифдеф дарвин
типдеф лонг инт инт32_т
типдеф лонг лонг инт инт32_т
эндиф
ну вот нахуя нам этот кусок в рантайме вычислять? нет никакой необходимости
>Vala
Да мёртвая твоя вала, сами гномерасты говорят, что нужно всё на расте писать. Кому ещё она была нужна, не представляю.
Раст не подходит:
- Большой порог входа. Вы должны освоить borrowed checker семантику с которой поставляется Rust. И он совсем не похож на парадигму C к использованию которой мы все привыкли.
- Приличный, но недостаточный набор инструментов. До сих пор нет IDE для раста. Плагины для других редакторов кода в вечной бете.
- Очень мало GTK приложений написанных на Rust, там 5 или 6 toy приложений на которые можно посмотреть, состоящих из 200 строчек кода, но ничего большого сделанного на Rust я не видел(эмм fractal, привет, он уже был в 2017)
- Медленная компиляция, что плохо для итерационного цикла разработки который вам действительно нужен при разработке GUI
>Вы должны освоить borrowed checker семантику
ну охуеть супер сложное достижение лол
растоклоун твой раст хуйня из под ногтей
>переходить
зачем?
это какая то психологическая болезнь - постоянно переходить на инструмент посвежее? чисто по фрейду: в детстве играл деревянными игрушками прибитыми к полу а дноклы в сегу - теперь вечно прыгаешь на все что вышло вчера. мои соболезнования
Да, у меня не было компа до 15 лет, а до этого изучал программирование по книжкам и писал программы в тетрадках.
>писал программы в тетрадках
А как исполнял эти программы?
Например:
int pInt = 0;
pInt = pInt + 3;
в этом случае прибавится 3 sizeof (int)
а мне нужно, чтоб прибавилось 3 и выглядело не так уёбищно:
pInt = (int)((char)pInt + 3);
>>3134515
Без адресной арифметики нельзя. Можешь использовать поинтер на чары или на войды и делать сдвиги нужного типоразмера.
Но вообще хуй пойми зачем тебе нужно сдвигать на 3 байта если это поинтер на инты.
Ты расскажи что ты хочешь этим добиться, может есть путь попроще
Используй union, чтобы не приводить типы. Без самой адресной арифметики никак.
union P {
unsigned char ×pb;
int ×pi;
};
union P ptr;
ptr.pb += 3; // сдвиг на 3 байта
printf("%d\n", ×ptr.pi); // взять int по адресу
(x вместо звездочек)
>Но вообще хуй пойми зачем тебе нужно сдвигать на 3 байта если это поинтер на инты.
Мне такое требовалось для динамической кодогенерации. Указатель на int, short и т.д. - когда нужно записать параметр такого размера, указатель на байт unsigned char - когда нужно записать опкод инструкции. Еще возможно работа с видеопамятью, байты - отдельные цветовые компоненты, 4 байта - 1 пиксель. Во всех таких случаях следует использовать union.
>На одной машине инты дефолтные четырехбайтные, а на другой вот допустим шестибайтные
Для этого нужно использовать типы из <stdint.h> - uint32_t и т.д. Они явно задают размер в 1/2/4/ 8 байтов.
><stdint.h>
Это интринсики, задаются компилятором, а не стандартом, и зависят от машины. Естественно на машине с шестибайтным интом они будут отличаться.
Хотя конечно сейчас надо постараться, чтобы найти чтото настолько нестандартное.
https://en.cppreference.com/w/c/language/arithmetic_types
Машину с шестибайтным словом сейчас наверно будет тяжело найти. Сейчас практически везде стандартные архитектуры: x86, ARM, PowerPC, SPARC или RISC-X. На других тоже кратная 8 разрядность. Хотя PDP-7 (на котором появился первый компилятор Си) был как раз нестандартным, 18-битным.
поставь vs 6.0, ну и опционально плагин visual assist туда;
и то и то можешь спиздить на рутрекере;
jit это и есть компиляция байт-кода в машинный код;
иногда это называют еще и "интерпретатор компилирующего типа" чтобы отличать от "простого интерпретатора";
тащем то в вики неплохая статья https://en.wikipedia.org/wiki/Interpreter_(computing)
>Машину с шестибайтным словом сейчас наверно будет тяжело найти.
>>3137666
>Хотя конечно сейчас надо постараться, чтобы найти чтото настолько нестандартное.
Это было просто для примера взято с потолка. Всегда проще объяснять принципы на пальцах.
Меня вот из хардварных вопросов больше интересует почему не спроектируют шину потолще. Многоядерность есть, а широкие шины чтобы сразу по 100500 слов забирать - не, интовой достаточно, копошитесь там как нить, жонглируйте.
Вам подарили hdl - напиши шину сам.
Богатым и знаменитым будешь.
Виртуальный - можно, есть такой курс. Начинаешь с логических вентилей, кончаешь ассемблером.
Да хуй знает, чекни объектник там же таблица символов есть чо откуда куда и зачем. Либо ошибка в ней, либо он реально дохуя референсов тащит.
мимо
Ща попробую. Пока не очень понял что именно я там должен увидеть
U caml_apply2
00000054 D camlBindings
000001d0 d camlBindings__1
000001b4 d camlBindings__10
000001ac d camlBindings__11
000001a0 d camlBindings__12
00000194 d camlBindings__13
00000188 d camlBindings__14
00000168 d camlBindings__15
0000015c d camlBindings__16
00000144 d camlBindings__17
00000128 d camlBindings__18
00000048 d camlBindings__19
0000011c d camlBindings__2
00000038 d camlBindings__20
0000002c d camlBindings__21
00000020 d camlBindings__22
00000014 d camlBindings__23
00000004 d camlBindings__24
00000110 d camlBindings__3
000000fc d camlBindings__4
000000f0 d camlBindings__5
000000dc d camlBindings__6
000000d0 d camlBindings__7
0000009c d camlBindings__8
00000090 d camlBindings__9
00000000 T camlBindings__code_begin
000004aa T camlBindings__code_end
00000000 D camlBindings__data_begin
000001fc D camlBindings__data_end
00000440 T camlBindings__entry
00000220 T camlBindings__fix_union_349
000000d0 T camlBindings__flattern_type_351
00000200 D camlBindings__frametable
000000b0 T camlBindings__fun_420
00000330 T camlBindings__fun_433
00000064 D camlBindings__gc_roots
00000410 T camlBindings__ocaml_function_hello_407
000003d0 T camlBindings__ocaml_function_sum_367
00000000 T camlBindings__remove_duplicates_281
U caml_call_gc
U caml_c_call
U caml_curry2
U caml_notequal
U caml_register_named_value
U Caml_state
U camlStdlib
U camlStdlib__failwith_7
U camlStdlib__List__1
U camlStdlib__List__find_all_679
U camlStdlib__List__flatten_477
U camlStdlib__List__fold_left_521
U camlStdlib__List__length_aux_270
U camlStdlib__List__map_482
U camlStdlib__List__rev_append_308
U camlStdlib__Printf__fprintf_422
>>3141245
куча какого то нонейм говна тут вижу по циферкам которые не относятся к исполняемому коду
так что полагаю второй вариант - реально тащит дохуя референсов чтобы это твое говно на 1200 строк работало
скомпиль через раздутый своп да и все, в итоге я думаю линкер выкинет все оттуда на твои 100 гигов, это чисто какой то билдинг блоб для окемла, всяких типов хуипов и прочего говна под циферками
это лично мое мнение, я не знаю как на самом деле
>скомпиль через раздутый своп да и все
Уже выставил своп 128 гигов. Хуй знает куда дальше. У меня всего на диске 500. Еще, конечно, до 248 попробую поднять, если наскребу где то, но он так быстро все жрет, что я до сих пор думаю, что где то ошибка
Вспомнил, что есть второй диск
А то я работая в embedded, не зная его, но вижу часто такие конструкции что как будто и вовсне не язык, а какой-то плейбук с макросами.
ну чел, ты работаешь и не знаешь
а я знаю и не работаю
чувствуешь подвох?
врят ли тебе тут будут помогать, давай сам выгребай, удачи с наебом хозяина работодателя
а мы уже на дне
Обзавёлся серверов в домашней сети. Построил на нём инфраструктуру в виртуалках.. Самое главное - gitlab. Переащил в него пару проектов. Это предыстория.
Гитлаб нндоступен за пределами сервера.
Насколько безопасно открыть его в домашнюю сеть?
А насколько безопасно сделать его доступным из Интернета?
Я думаю, что вполне может быть функция, которая возвращает возможность/невозможность обращаться к ячейке памяти.
да очень просто проверить на самом деле
все адреса или их алиасы в виде названий переменных куда ты можешь писать/откуда можешь читать должны быть объявлены в коде заранее (декларативный язык же)
все остальные адреса и попытка записи туда это сегфолт, попытка чтения - 50/50 сегфолт
а касательно данных которые ты можешь засунуть в ячейку памяти заранее объявленную в коде - тут то же все просто
инфа это инфа, "ophuy" это или числа абсолютно без разницы, можешь в массив интов сунуть строку и потом вычислить сумму всех элементов
инфа это просто биты и все, они приобретают какую либо форму только когда ты их к этой форме приводишь, например напечатав на экран printf("%d\n", a); приводишь к десятичному виду
подведем итог
можешь сунуть чо угодно куда угодно если это куда находится в пихаемом сегменте твоего процесса
Нет, нельзя. Как ты себе это представляешь? У тебя же не просто обращение к ячейке как сам факт. А какое то действие с памятью происходит
Я так понимаю, что на уровне системы может быть какая-либо таблица с указанием, какому процессу какая область памяти дана.
И из этого есть мысль, что как-то можно проверить доступность ячейки.
В чистом С нет такого, это ОС специфичные вещи. Даже если есть, что ты с этой информацией будешь делать? Если ячейка в пространстве процесса, еще не значит, что из нее можно читать или писать
Ты хотя бы ОС назови.
Под Виндой дофига чего можно было делать с памятью.
Ну а так-то, в общем случае, любое обращение к незамапленной странице вызывает Page Fault прерывание, ОС его смотрит и решает что делать - подкачивать память из свопа или прибивать программу.
Ставишь обработчик SIGSEGV и разыменовываешь указатель. Из обработчика архитектурно-зависимым способом пропускаешь инструкцию.
ты дибил, зайди на гитлаб гнома, там все новые гтк4 на расте делают
>>3151064
Раньше была традиция разговаривать с пастами, теперь разговаривают с нейросетками. Прогресс, ёпт!
_Generic
Ну это в компайл тайм
#define ncw_is_array(arg) (((void ) &arg) == ((void ) arg))
#define ncw_gui_add_field0(gui, label, data, max_len) \
ncw_gui_add_field(gui, \
label, \
sizeof(label), \
_Generic(data, char: NCW_FIELD_CHAR, \
int16_t: NCW_FIELD_INT16, \
int32_t: NCW_FIELD_INT32, \
long: NCW_FIELD_NUM, \
double: NCW_FIELD_DOUBLE, \
char *: ncw_is_array(data) ? NCW_FIELD_STR : NCW_FIELD_CHAR), \
&data, \
&data, \
sizeof(data), \
ncw_is_array(data) ? sizeof(data) : max_len \
)
Согласен. Но ты чел не знаешь ради какого говна я это написал. Это был жутко быдло си код, полученный путём авто конвертирования проги с кобола на си. Дальше его пилили индусы и там ваще треш был. Я там микролибу написал вот с таким дерьмом, чтобы немного улучшить ситуацию. Мне даже старшие индусы премию дали за это улучшение.
Освободится вместе с завершением программы.
Но если ты хочешь чтобы программа завершилась корректно, а не от нехватки памяти, то так делать нельзя.
Сам ты нейросетка. Я глубоко изучил тему, поэтому дал развёрнутый ответ.
>> то так делать нельзя.
>Запретить! не пущать!
Ну ладно, можно. Но!
Так можно делать только тем, кто писал свой аллкоатор памяти и понимает как он работает. При этом не освобожать память дозволительно лишь для программ узкого класса задач, например для хитровыебанного консольного парсера каких-то документов со сложной структурой. И чтобы не стримовый был, а файлы с диска брал. Когда заведомо память не перелопнится. В общем, так можно делать только одному из миллиона, да и то не факт.
> Так можно делать только тем, кто писал свой аллкоатор памяти и понимает как он работает.
Достаточно прочитать доки.
Более того, можно и fclose не вызывать перед завершением. Однако лысые обезьяны так делают, хотя возвращаемое значение не проверяют.
> При этом не освобожать память дозволительно лишь для программ узкого класса задач
Большинство утилит командной строки так делают или могут делать.
>хотя возвращаемое значение не проверяют
если ты не проверяешь не значит все не проверяют
шо с ебалом, лысый бибизян?
А можно пример таких утилит, и когда выгодно не освобождать память? Просто интересно
Какие типовые задачи решают на си в бизнесе?
> Какие типовые задачи решают на си в бизнесе?
Ну вот nginx напейсан на си. Некоторым нужен странный функционал от него - пишут модули.
Прата точно есть. У меня у самого валяется. Читай на англ, в любом случае он нужен будет
Много легаси: биллинг, процессинг, бангкинг. Причём, это не всегда говнокод, но очень может быть.
Например, в инотехе допиливыют опенсурс для замены майкрософтской activedirectory - samba ad, которая написана на си.
Во всяких конторах разработчиках железа используются эмулятор qemu - тоже хорошо бы мочь допилить. Им же нужно пилить ядро под linux
Про nginx - чел написал.
Можно вызывать лишь те функции, которые объявлeны как extrn "C".
Не, шаряшие пацаны могут и метод класса вызвать из Си. Но на свой страх и риск, потому что это абсолютно непереносимо между...
На данный момент дергаю с питонидзе через CDLL сишные либы и оттуда получаю функцию.
Примерно как выглядит на примере math.h - с-шный файл обьявляет test_acos(double x) { acos(x) }, компилит в либу и питон использует этот test_acos.
Такой велосипед нужен т.к. ебу где и как будет находиться libc.
Вопрос - можно ли не через обертки экспортировать тот же acos?
Если ты создаёшь либу, которая линкуется с libc, как ты можешь не знать где лежит libc?
Позднее узнал, что она написана под древний стандарт, а текущий C 2017 уже другой.
Это ставит под сомнение идею учиться языку по этой книге, потому что дальше будет только хуже и я буду тратить время на проблемы совместимости стандартов, вместо обучения.
Есть более актуальные книги для 2017 версии языка?
>не компилируется
cc hello.c -ansi
там читать -то нечего особо, епрст, язык маленький, книжка тоже. код поправить(указать тип int main() и вернуть 0) пара пустяков.
c11/с17 можно по докам и интернетам нагнать
а ты пишешь как робот зубрилка какой-то, неудивительно что с таким мышлением возникают подобные вопросы
Я знаю как поправить этот код. Я просто ебал в рот запоминать неактуальные конструкции говна мамонта.
>cc hello.c -ansi
Ещё с
>gcc test.c -o test.c-compiled -std=c89
сработало. Так понятнее. Спасибо.
Да, доебись до того что мне в голову пришло в /tmp набрать чтобы потестить
прикольно кстати
но лично мне нравится классические .о объектники и .b бинарники
Не, ну вы понимаете, я весь такой умный. Да уж, были бы все такие умные как я. С таким великолепным мышлением. Эх, каким был бы мир вокруг тогда.
Число значимых цифр одинаковое, цифра перед запятой тоже значимая.
Пон, я думал, что значимые только после запятой. Странно.
Точка плавающая. Раскладка по битам такая примерно, насколько я помню (для одинарной точности):
1 бит знак - 8 бит экспонента - 23 бита мантисса
Значимые цифры хранятся в мантиссе, кроме первого бита, он для экономии места считается всегда равным 1. Вот и получается, что 1.0/3.0 и 1.0//0.3 различаются только в экспоненте, мантисса у них одинаковая, а значит и число значимых цифр тоже. Сколько их там до и после запятой — не важно, это просто printf для кожанного мешка рисует число в привычном ему виде.
почему совпадение? он же притефает во флоаты, экране просто куча флоатов типа
Потому что в десятичном представлении гарантирована точность 6 знаков (для чисел одинарной точности).
>1.0/3.0 и 1.0//0.3 различаются только в экспоненте, мантисса у них одинаковая,
Нет, поскольку экспонента двоичная, а не десятичная
_DIG дает гарантированное число цыфер. Если ты заставляешь gcvt идти дальше, ты поручаешь мусор.
Что читать/смотреть?
Какой-нибудь ресурс, который расскажет, как правильно C++/C код связывать с Java JNI
И почему раст сосёт по сравнению с C/C++?
>вынужденно надо выучить C/C++
Так не бывает. Нет такой нужды. Ты или сам учишь и выучиваешь, или твоя "нужда" это какой-то чёс.
>И почему раст сосёт по сравнению с C/C++?
Не ебу что там сосёт или не сосёт, но Си это такой продвинутый ассемблер. Когда ты долго пишешь на Си, то ты в целом хорошо представляешь в какой машинный код превратит компилятор твой исходник. Если выключена оптимизация.
А С++ это нехилое такое надмножество над Си. С массой всяких удобных, нужных, а иногда и бесползных фич.
Ты сначала расскажи, для чего тебе надо это выучить. По этим языкам огромная масса информации, и их применение тоже отлчается в зависимости от нужд.
Начни пока с базы си что ли, можно вот здесь:
https://www.youtube.com/playlist?list=PLRDzFCPr95fLjzcv6nNdjMu_9RcZgIM9U
Бля ты чёт какую-то дичь пишешь.
Когда вышел раст? Назови год. И когда вышел с/с++. У них отрыв в 30 лет. Как раст может "сосать", если он проектировался уже с учётом всех косяков и граблей предыдущих языков? Если новый язык ничем не лучше старого, то на🌶 он нужен по твоей логике, а? Это даже не логично.
Ты будешь как полный бичара трахаться с окружением в этих своих с/с++. Там нужно всё пердолить руками, начиная от configure/makefile'а, заканчивая пакетным менеджером и юнит тестингом. У меня в расте уже всё подано на блюдечке. Я просто набираю cargo add и у меня устанавливаются зависимости.
В c/с++ ты будешь миллион лет гадать, почему программа крашится. Оказывается, ты в каком-то месте поставил лишнюю звёздочку. В расте же программа тупо не скомпилируется если поставить звезду не там где нужно, обратиться не к той области памяти.
Ну и плюс, у меня код лаконичнее. То что ты сделаешь на с/с++ в 1000 строк я сделаю в 500, при этом у меня будет такая же производительность. Спрашивается, и на🌶 тогда нужен твой карго культ с с/с++?
>Как раст может "сосать", если он проектировался уже с учётом всех косяков и граблей предыдущих языков? Если новый язык ничем не лучше старого, то на🌶 он нужен по твоей логике, а? Это даже не логично.
пикрил
>>3179077
>То что ты сделаешь на с/с++ в 1000 строк я сделаю в 500, при этом у меня будет такая же производительность.
пикрил х2
Я понимаю, что на хелловорлдах проблем не видно, но раст очень сильно хромает
на сложных структурах данных. Это даже сами разрабы признали, когда начали асинк в язык добавлять, да и Митник какую-то статью об этом писал.
мимошел
На каких конкретно "сложных структурах данных"? Это расплывчатое объяснение. Там искаропки есть HashMap, LinkedList, BinaryHeap. Можно поставить petgraph для работы с графами. Для линейной алгебры ndarray, nalgebra. Для pipeline'ов есть polars.
Что ты можешь сделать такого, чего я не могу на расте?
> а что учить то?
Чтобы было интересно - учи операторы ^ & | ~
Загляни в битовые поля.
Почитай где может быть расположена переменная в памяти - что такое стэк, куча, сегмент данных.
Как-то так. Но я не настаиваю, это лишь один из путей для изучения Си и С++.
>Что ты можешь сделать такого, чего я не могу на расте?
Найти работу.
Это достойно скриншота. Ржал аки конь.
Но растеры сами виноваты - они не в ту сторону воюют и не в те ряды записываются. Стали бы на сторону Света и Силы - катались бы как сыр в масле.
>Найти работу.
Это не аргумент. Сиюминутные хотелки рынка не в счёт. Рынок как ветер. Он сегодня в одну сторону дует, а завтра всё поменяется и станет популярным. Настроение завтра поменялось, снова всё бросаем и переучиваемся на раст.
Раст не отвечает:
- За твою зарплату
- За количество вакансий на рынке
- За количество конкурентов
- За подсознательные страхи кабана
Не вина раста что кабаны решили перебздеть АВДРУХЧО и делать как диды делали.
Не вина раста что у кого-то меркантильные интересы и его больше интересует своя жопа в тепле, а не качества языка.
Так можно про что угодно сказать:
- Матлаб хуёвый потому что на нём нельзя найти работу
- R хуёвый потому что на нём нельзя найти работу
- Не используй языкнейм, потому что васян/сосед маминой подруги его не любит
Ну и так далее.
>Что ты можешь сделать такого, чего я не могу на расте?
Пройти сертификацию ПО в гражданскую авиацию в любой стране мира.
>Пройти сертификацию ПО в гражданскую авиацию в любой стране мира.
>в гражданскую авиацию
На🌶 она мне нужна?
>То что ты сделаешь на с/с++ в 1000 строк я сделаю в 500
А я помню всё в точности до наоборот! Помню как в нашем треде был обильно обоссан один растопетучило, который выкатил длиннющую ООП-парашу на расте, которая должна была имитировать работу с вектором из плюсов.
Ещё помню, как этот же растопетучило после того, как мы его лаконично обоссали (лаконичным, красивым кодом на Си, который также имитировал работу с вектором), начал кичиться знаниями в линейной алгебре, думая, что вектор из плюсов нужен для вычислений, связанных с линалом (или это было до его массового обоссывания? не помню уже точно, но точно помню, что в тот день весь наш тред надорвал животики от смеха над этим дегенеративным животным).
Возможно, кстати, что это был ты, потому что настолько отбитых ебанатов, которые продолжают упорствовать на своём, даже после того, как его обильно и с пруфами обоссали, крайне мало в мире. потому я надеюсь, что сейчас тебе причиняют ужасную боль флешбеки с того, очень позорного для тебя дня, и поэтому ты в скором времени свалишь обратно в свой петушатник
Тебе не хватает денег на авиарейсы? Ты тупое нищее говно, которое никому нахер не нужно.
Мне надо сделать апи для джавы, чтобы джава хоть как-то могла работать с ui. Текущие библиотеки не устраивают, поэтому надо портировать условное апи Dear ImGui на джаву. Воооот... В команде в данный момент есть 2 человека помимо меня на эту задачу, но я сам вообще никогда с С не работал, только на джаве с котлином писал
>Что ты можешь сделать такого, чего я не могу на расте?
В общем, согласен с этим
https://www.linux.org.ru/forum/talks/17633741?cid=17634275
Да паебать на твои алгоритмы. У с++ искаропки нет:
- Нормального пакетного менеджера
- Нормального линтера
- Средств для unit-тестирования
- Средств для генерации документации
и так далее
То есть ГОЛОЕ ОКРУЖЕНИЕ.
А ты мне втираешь дичь про алгоритмы, ещё какую-то хню. Это всё надо идти качать одну из 10 реализаций каждого вышеперечисленного и по-одному устанавливать. В расте ты одной командой отформатировал код, сгенерировал документацию, запустил бенчмарк. Не надо ни с чем пердолиться, искаропки всё стоит.
Комьюнити у с++ ДОХЛОЕ. Любая сраная библиотека/фреймворк последний раз обновлялась 5-8 лет назад. И лежит где-нибудь в SVN-репозитории на SourceForge (как будто кто-то ещё помнит ёбанный sourceforge).
>есть со структурами ебля
>нет, ебли
>вот держи
>РЯЯЯЯ, НИНУЖНА
Понял.
>Комьюнити у с++ ДОХЛОЕ. Любая сраная библиотека/фреймворк последний раз обновлялась 5-8 лет назад.
Если либа не обновляется и не ломается каждую неделю, то комьюнити мертвое, правильно понимаю? Вариант того, что либа имеет финальную форму для решения задачи даже не рассматривается, верно? Веб-макаки as is.
>То есть ГОЛОЕ ОКРУЖЕНИЕ.
Да, но это особенности системной разработки и швабоды. NPM-like говну и вендорлочному тулингу здесь не место.
Вот в этом и основная проблема раста, что на бумаге заявляется одно, а на практике происходит совершенно другое. Люди, которые не занимаются системной разработкой приходят со своей библией и начинают все перестраивать. В раст-сообщество в основном приходят макаки с веб-параши/прочих скриптух, которые никогда даже не писали на Си и начинают лепить говно, повторяя корпоративную методичку. По этой же причине на расте перенаписано тысячи мокрописек для вывода ЛГБТ текста в терминал и всякие копровебсерверы, но нормальных системных решений так и не нашлось. И все эти пакеты сырые с версиями 0.0001, которые никогда не станут нормальными, потому что макаки не привыкли делать готовые решения, они привыкли срать, забывать и снова срать. Но зато сообщество живое да, пару сотен очередных лефтпадов не помешает.
Как думаешь, почему тот же zig привлекает к себе больше системных программистов чем раст даже находясь на версии 0.000001?
>они привыкли срать, забывать и снова срать
Чёт проиграл с этого речевого оборота.
Лол, блядь, даже в вашем треде эта тема поднималась >>3179043 →
ЧДТ - раст это больше социальное движение как БЛМ и прочие мутанты, нежели что-то технократическо-разумистическое.
Прости, дружище, что написал такой эмоциональный текст с оскорблениями. Не хотел, честно, просто день был хреновым, что конечно же не является оправданием такого антисоциального поведения.
А что касается сабжа, то в системной разработке есть некоторые правила, которые придуманы дедами-пердунами не просто так, а являются прямым следствием от работы с предметной областью. В данном случае, модель разработки прикладных/веб приложений не совсем гладко ложится на системное и низкоуровневое программирование.
Также советую оценивать вещи с инженерной точки зрения и точки зрения системного подхода, задаваясь вопросом почему было сделано так, а не как-то иначе. Конечно, не все историческое решения были самыми эффективными и многие из них можно улучшить, но понимание этих моментов также необходимо при оценке вещей. Не стоит решать эмоциями и не стоит слушать говорящие головы с методичками.
анон->>3179370
>Си это такой продвинутый ассемблер
Нет.
>Когда ты долго пишешь на Си, то ты в целом хорошо представляешь в какой машинный код превратит компилятор твой исходник. Если выключена оптимизация.
))
C++ != C, для ентри вката в си норм книжка у сикорда.
>И почему раст сосёт по сравнению с C/C++?
Если ты совсем нубас, то лучше вкатывайся в раст.
Не, я не совсем хлебушек, просто никогда с системным программированием не связывался.
И спасибо за книжку, почитаю
Тебе дали Visual Studio для этого. Выносишь платформонезависимую часть в отдельную сущность, пишешь тесты для неё и отлаживаешь в IDE. Затем переносишь код на целевую платформу.
Это самый короткий, лёгкий и правильный путь.
А gdb? Ну он может помочь когда программа падает. Компиляешь с отладочной информацией, а как упала - смотришь стек. Там обычно сразу видно где и почему упала.
Ладно, анон, спасибо за ответ, но я уже разобрался!
>Тебе дали Visual Studio для этого. Выносишь платформонезависимую часть в отдельную сущность, пишешь тесты для неё и отлаживаешь в IDE. Затем переносишь код на целевую платформу.
Да, анонче, возможно ты прав, но сейчас для меня это выглядит слишком сложно, потому что я только вкатываюсь в алгоритмы и до того уровня, что ты описал мне ещё пердолить и пердолить.
Кстати, а посоветуй гайды для освоения VS, а то я чёт потыкался в него, потыкался и понял, что это очень сложно, и решив, что попробую изучить его по ютубу, не нашёл ничего годного кроме, как гайдов для верстальщиков веб-страниц. Буду очень благодарен, если ткнёшь меня мордочкой в годный гайд (ютуб/книга/набор статей) по VS.
>Кстати, а посоветуй гайды для освоения VS,
Не, не знаю гайды. Только есть два VS - VS Code и VS Community Edition. Вот я о втором толкую.
Там всё просто - создаёшь проект (для вката неплохо консольный), добавляешь туда свои исходники линуксовые. Они сразу не компилятся. Поэтому делаешь
#ifdef _WIN32
// Здесь инклуды и макросы для Виндовс
#else
// Здесь инклуда и макросы для Linux
#endif
Можно ещё и макос добавить, она хоть и POSIX-совместимая, но на сложных проектах чудеса бывают.
В общем, правишь пока не скомпилится. Затем клавиша F10 и началась пошаговая отладка.
F9 - точка останова. F5 - исполнять до следующей точки останова.
Shift+F9 - продвинутый инспектор объектов.
Задержал мышку на переменной - видишь её значение. Если переменнная сложный объект - можно посмотреть его поля. Для списков самое масло - можно вот так в процессе исполнения лацить по спискам - IDE это делает великолепно.
Анон, спасибо, что таки замотивировал снова попробовать VS Code! Действительно там очень удобно наблюдать за связными списками! Только я пока ещё пердолюсь с тем, что не могу просмотреть область памяти под массив, который получаю через malloc, т.е. VS показывает мне лишь первый элемент, а остальное хуй! В gdb я мог через команду "x/5dw arr" глянуть на область памяти размером в 5 "машинных слов", которая выделена под arr, а в VS это какой-то пердол. Я в прошлый раз, кстати, и бросил VS, потому что так и не допёр как я это могу просмотреть. Может ты знаешь решение?
Вот красным обвёл - это меня выводи окно с дампом памяти.
Когда окно выведешь, у него будет заголовок с адресом памяти - мышкой туда перетаскивай например перменную-массив и увидишь что там в памяти.
Там ещё размер элементов можно переключать - 8, 16, 32, 64 бита.
Спасибо, анон! Правда в VS Code это всё сильно отличается - там надо пердолиться с .json файлами, чтобы объяснить IDE как именно должна проходить отладка. Сегодня продолжу разбираться с VS Code, если опять встряну, то тогда перекачусь на VS Community.
>>3180442
Отладка отладчиком это вообще-то крайнее средство.
Лога и тестов достаточно в большинстве случаев.
Ну не знаю... Мне нравится "ковырятся" с отладчиком, т.е., изучая алгоритм, изменять прогу и смотреть где что и как меняется, конечно, чаще это можно в голове всё просчитать, но иногда без отладчика никак не обойтись.
Понимаю тебя.
Однако, отладчик он не оставляет артефактов, которыми можно воспользоваться еще раз. А лог и тесты - оставляют. Потом если что-то сломается в будущем они тебе сразу покажут.
Короче, с отладчиком это как на слух послушать что-то, а с логом-тестами как будто записал конспект сказанного.
В целом, твоё дело конечно, но вот мой совет такой был.
Понял, анон! Буду стараться идти в сторону тестов, а то чёт не ты первый мне это советуешь.
Еще небольшой совет.
Есть практика вводить флаг NDEBUG
И потом места вызовов тестов обрамлять
#ifndef NDEBUG
... тут вывод в лог или тестов ...
#endif
И этот флаг является стандартным, его еще понимают ассерты. Регулировать флаг можно мейком -DNDEBUG как-то так.
Почитай про это поточнее, я так - навскидочку рассказал.
ООП ничего толком нового из себя не несёт, но зато его можно было легко впарить менеджерам. "Вот смотрите у нас есть класс фигура, мы можем унаследовать от неё классы квадрат и и круг и у них будет одинаковый метод посчитать_площадь...", буэээээ.
Да. А российскую заставляют запоминать в кои-8R, cp866, windows-1251 и utf-8
Вместо азбуки Морзе.
Ответы преподу покажи обязательно.
И пусть он спросит у тебя на какую величину увеличивается адрес указателя на структуру при инкременте этого указателя. Если ответишь, то молодец.
Си умеет, только на костылях. Ну типа как в Линукс все является файлом. Ооп языки добавили чтобы меньше возможностей было выстрелить в ногу.
>Ну типа как в Линукс все является файлом.
так это не костыль, а единственный ахуенный концепт
костыль это как раз обратный подход, мол хуитка 1 это файл а хуитка 2 это чот другое пердолься как то там сам
Это была попытка юниксвея, соединять всё со всем, но юниксвей обосрался, Так что вот, просто осколок обосравшейся концепции. Нет ничего хорошего когда разные вещи выглядят одинаково, из за этого они плохо работают и искажают мышление тех кого по этому говну с нуля учат.
Ты жопой читаешь. Когда у тебя все файл - это полиморфизм. Когда тебе не особо нужно знать, как этот файл внутри устроен - это инкапсуляция. Когда внутри все эти файлы имеют общую структуру из указателей на функции - это наследование.
Это ооп, но реализованный на костылях, т.к. не поддерживается искаропки.
Это примерно как автомобиль является автомобилем, велосипед является автомобилем и пешеход до кучи является автомобилем. Ещё зачем-то канализационный люк является автомобилем и белый шум тоже автомобилем является.
Поехали.
Это вас в си так учат? Отладчик не нужен, у меня нет времени ебаться с ним, лучше ещё высру логов в консоль. Что? Проебался с указателей и высрал в лог сегфолт? Это же очевидно, как это решить, правда придётся опять полчаса всё перекомпилировать.
я как раз про это и говорю, что я та не думаю
но вы продолжаете один и тот же принцип и базис прикладывать к другим сферам, а выходит говно
всё файл - ахуенно
всё объект - говно
всё автомобиль - шизоидный бред
теперь ясно?
Это линукс так учит. Есть только калсолька для логов, гуёв для отладчиков не завезли. так что решение проблем как всегда: "НИНУЖНО!"
>всё объект - говно
Не все, а все кроме функций:
https://en.cppreference.com/w/c/language/object
Нихера язык не знает, а что-то вякает. Ты же достаточно трезвый, чтобы понять что это стандарт си, а не крестов?
хватит передергивать хуйлуша оопэшная
ооп кал, сынок
запомни
>ооп кал, сынок
Тебя так напрягает передача this в функцию?
Тебя так напрягает таблица виртуальных методов?
Да?
Нет. ООП это не указатели и таблицы, а парадигма программирования. Напрягают программы в виде лапши из классов с наследованием.
Да, это так учит Керниган и Ритчи - создатели языка Си.
Какие-то проблемы?
Кстати, дебаггер для девочек и геев.
Это какие-то "староверцы", не слушай их! Хз, может быть, конечно, правильно будет всё обмазывать тестами и логами, но, на мой взгляд, правильно это будет делать тогда, когда ты уже знаешь правильное поведение того алгоритма, который ты используешь. Но когда ты только изучаешь, то дебагерр это мастхэв! Дебагерр, особенно тот, который имеет мощную гуи, ускоряет твоё обучение. Хз, я чёт столько месяцев пердолился с вимом, гдб, ddd, edb (дизассемблер), сам писал мэйкфайлы, когда писал проги, состоящие из многих модулей, что сейчас, пропердолившись с VS Code неделю, и изучив cmake, я просто получаю удовольствие от пользования этой прекрасной программы. Кайфую от того, что у меня всё в одном окне, ёпту бля!!! Мне теперь не надо прыгать по терминалу, чтобы что-то сделать!!!! Да, я умею всё это делать и в терминале, это, конечно, мастхэв для системного программирования, но всё же, когда у тебя всё в одном окне это очень удобно.
Я такое же удовольствие получал, когда после нескольких месяцев изучения и кодинга на асме, я перешёл на Си. Эти удовольствия эквивалентны!!! Конечно, когда я стану крутым программистом, и вкачусь в системное программирование на ставку, то, тогда и можно будет продолжить пердолиться в терминале, виме, гдб, с тестами, с логами... А сейчас, извольте, алгоритмы я продолжу изучать в VS Code.
Ассемблерный код прикольно прогонять в отладчике.
На уровни Си уже не нужно.
Ты сгущаешь краски - современные плюсовики больше дрочат на шаблоны и синтаксический сахар. И во многих случаях используют десятки сторонних библиотек, как и все остальные.
Сама же парадигма ООП в стиле С++ идеальна - она обратно вытекает из Си, понятна, потому что программист понимает где и как расположен объект в памяти и т.д. и т.п.
Более того, абстрактные классы это идеальное описание интерфейсов.
В общем, мне лениво расписывать прелести ООП, но если ты понимаешь как устроены объекты, при этом если начаниешь программу с этапа проектирования, а не кодирования, то объекты это очень годная вещь.
Круче только субъекты.
Вот в качестве шутки "идеальная программа" на С++
#include <hiscoollib>
int main(int arrc, char * argv[])
{
HisCoolClass myprog(argc, argv);
return myprog.Run();
}
>не слушай их!
>когда я стану крутым
а кого слушать, тебя что ли?
Слушай всех - их, меня, своё сердце, птичек, звук долбящихся в анус педиков, сигнализацию, крик бабушек...
Слушай жизнь, анон!
А если вам это не нравится, то какой в этом смысол?
Ну и по советам величайшего не забываем трогать траву.
https://youtu.be/-QxI-RP6-HM?si=uRGffJYV7m1ALp-I
>Вот в качестве шутки
Это не шутка, а ошибка, серьезная проблема ООП.
Программы не ложатся на ООП, на ООП ложатся библиотеки, потому что библиотека это не одно целое, а лишь набор маленьких, простых, и главное самодостаточных элементов. ООП библиотеки действительно красивы и удобны, но для программ это не работает. Программа - не набор самостоятельных хуевинок, а одна целая система из запутанного клубка перекрестных ссылок где всё зависит от всего, никакой простоты и разрозненности. Попытка инкапсулировать куски программы приводит к нечитаемой дрисне из бесконечно разрастающихся деревьев.
>Ассемблерный код прикольно прогонять в отладчике.
>На уровни Си уже не нужно.
Два чаю. Просто держишь всю память в голове, и идёшь построено по листингу.
,cos();main(){float A=
0,B=0,i,j,z[1760];char b[
1760];printf("\x1b[2J");for(;;
){memset(b,32,1760);memset(z,0,7040)
;for(j=0;6.28>j;j+=0.07)for(i=0;6.28
>i;i+=0.02){float c=sin(i),d=cos(j),e=
sin(A),f=sin(j),g=cos(A),h=d+2,D=1/(c
he+fg+5),l=cos (i),m=cos(B),n=s\
in(B),t=chg-f e;int x=40+30D
(lhm-tn),y= 12+15D(lhn
+tm),o=x+80y, N=8((fe-cdg
)m-cde-fg-l dn);if(22>y&&
y>0&&x>0&&80>x&&D>z){z=D;;;b=
".,-~:;=!#$@"[N>0?N:0];}}/*#!!-*/
printf("\x1b[H");for(k=0;1761>k;k++)
putchar(k%80?b[k]:10);A+=0.04;B+=
0.02;}}/*####*!!=;:~
~::==!!!!!!==::-
.,~~;;;========;;;:~-.
..,--------,*/
пробовал запустить этот бублик в консоли, но не могу понять, какое разрешение консоли ставить что бы кадры плавно сменяли друг друга, какое бы не ставил, всё равно получаются разные куски бублика. а чистить консоль я умею только через system("cls"), но тогда картинки подвисают заметно
а ты попробуй этот бублик написать больше профита получишь чем от бездумной копипасты
я пробовал квадратик вращать в консоли, но у него так же кадры сменяются неравномерно, так что неважно что именно крутить
значит ты используешь медленные методы вывода на консоль
используй быстрые
чем ближе к зашитому в компилятор путчару тем быстрее
>чем ближе к зашитому в компилятор путчару тем быстрее
Как же больно это читать...
int d = open("/dev/tty", O_RDWR);
write(d, " НЕ ПИШИ ТУТ БОЛЬШЕ\ r\n", 42);
повторяю
чем ближе к зашитому в компилятор путчару тем быстрее
дизасемблировать бинарь с этой хуйней? да сискол там зашит, как и на врайте, ниже уже нихуя нет
а вот выше есть макрообертки всякие, путсы принтефы, они уже помедленнее
Во времена MS-DOS можно было сделать ещё быстрее, путём записи сразу в видеопамять, минуя все медленные вызовы ОС или биоса.
ещё раз повторяю
проблема не в том, что медленно выводится, а в том, что следующая каринка неправильно заменяет предедущую, когда строка идёт вниз, какое бы разрешение консоли не ставил, проблема остаётся
static fd_table_t s_fd_table[MAX_FDS] = { [0 ... MAX_FDS-1] = FD_TABLE_ENTRY_UNUSED };
Понятно что это инициализация, но где прочитать про этот синтаксис с "..." (тремя точками)? Нагуглить не могу Мне это нужно потому что я пишу описание грамматики
Это нестандартное расширение gcc
https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html
Спасибо, добавил
Думал это вообще способ присваивания к массивам, а оно только в инициализации дозволено
Нормальных эмуляторов очень много. Не знаю правда, какие есть альтернативы для твоей игровой прошивки. wincmd — это косплей на терминал. Полагаю, что он как-то буфферизует вывод и из-за это рвёт тебе изображение.
баш точно есть на масдаях, но там надо будет подтягивать пути в окружение на всякие компилеры и порчий софт по типу мейков
мимо
А про доллар на конце имени переменной что скажете?
/ Initialize the stack frame. /
extern uint32_t __global_pointer$;
Тоже какая-то хрень непонятная. Отсылка к скриптe линкера?
>
>Тоже какая-то хрень непонятная. Отсылка к скриптe линкера?
Нашёл сам: тоже расширение GCC - он позволяет использовать доллар внутри имён переменных
в чем разница? оболочка командной строки/эмулятор терминала
живых терминалов наверное даже в at&t нету
>И нахера это надо?
От OpenVMS пошло
А мне это надо потому что я пишу парсер C в AST
>в чем разница?
Терминал это терминал, аналог вот этого аппаратного живого терминала
А шелл это программа которая с тобой в диалог вступает через этот терминал
>аналог вот этого аппаратного живого терминала
и что же делает ентот ваш аналох? что то иное?
>А мне это надо потому что я пишу парсер C в AST
Все уже написано давно
github.com/antlr/grammars-v4/blob/master/c/C.g4
>github.com/antlr/grammars-v4/blob/master/c/C.g4
Мне проще, я много что пропускаю из-за ненадобности, я ж не компилятор пишу
>>аналог вот этого аппаратного живого терминала
>и что же делает ентот ваш аналох? что то иное?
Принимает по виртуальному каналу буковки и рисует в окне, и наоборот
Может хранится имя глобальной переменной в таблице символов. Адрес таблицы задаёт компоновщик. Смещение в таблице полагаю соответствует порядку обработки файлов. Но это используется только в целях отладки.
>>3192940
Строковый литерал это тоже массив. Если ты объявил массив как массив, а не как указатель, получаешь такое поведение. Честно говоря никогда не задумывался о его причинах. Могу предположить, что когда ты пишешь такую конструкцию ты ожидаешь, что будет скопировано содержимое массива, а в си нет толком размера, чтобы делать это безопасно.
>Строковый литерал это тоже массив.
нет, это константа и ее содержимое лежит в сегменте текст, а в твоем коде объявляя массив ты его инициализируешь строковым литералом, но это не одно и то же, строковы литерал лежит в тесте, а чары в массиве после инициализации лежат на стеке
у массивов действительно механизм работы похож на работу указателей, но это не одно и тоже, об этом в своей книге так же писал ритчи, грубо говоря массивы используют принцип указателей, но ими не являются
>PEG
Я писал на boost spirit. Там почти полностью бекуса наура переложили на крестовые шаблоны.
Вот, к примеру, такой код:
int fignya(int a){return -a;}
Если я хочу через указатель типа void передать адрес функции fignya, то для вызова функции нужно сделать явное приведение типа. Как это сделать?
Я знаю, что указатель на такую функцию выглядит так:
int (fignya_)(int);
Из этого было интуитивное предположение, что нужно использовать конструкцию (int()(int))
>>PEG
>Я писал на boost spirit. Там почти полностью бекуса наура переложили на крестовые шаблоны.
Меньше всего я бы хотел ебаться с крестами и их шаблонами
Бекус не нужен - peg лучше для машинных языков
Войд в сишечке автоматом приводится, не нужны никакие конструкции дополнительные. Но для удобства лучше отдельный тип завести.
Без шаблонов вообще невозможен никакой полиморфизм. Точнее только хардкор-си-стайл, когда ты что угодно можешь кастовать к чему угодно, а корректность проверять только в рантайме, если повезёт.
https://pastebin.com/dLhdwZTf
Конечно, лучше по неделе на каждую фичу сегфолты дебажить.
Осциллоскопом смотрел, че там на линии творится? Может коротнуло на корпус. Всякое бывает.
Достаточно писать на сях, а не эмулировать на них свою привычную макакину скриптопарашу. Разумеется для этого си не подходят, си - не скриптопараша, не для тебя сделано, макака, ты лезешь не туда со своими скриптами.
И в чём проблема void? В том, что неудобно эмулировать скриптопарашу? Так и не надо, ты не нужна в сях, скриптовая макака, не для тебя сделано.
Нахуя паять? В 2024 существуют pcb-платы и гора инструментов для их проектирования.
Сейчас уже нет.
А вот лет 20-25 тому назад это умение было неплохим бонусом.
Да, но это так не называют, и структуры позволяют реализовать только самые базовые возможности классов и с намного меньшим синтаксическим сахаром. "Методами" будут просто функции, виртуальными методами - указатели на функции, расположенные в самой структуре. Но this/self в них ты можешь передавать только сам среди прочих аргументов. Так же не предусмотрено никакого автоматического неймспейсинга, поэтому у "методов" очень длинные названия, например
mysql_stmt_bind_param(MYSQL_STMT ⚹stmt /⚹ это this ⚹/, MYSQL_BIND ⚹bind)
Наследование с полиморфизмом делается просто помещением родительской структуры в качестве первого поля в наследнике. Компиляторы гарантируют, что у них будет одинаковый адрес, передавать можно через параметр ⚹void, недостаток - контроль типов не производится.
Есть и достоинства - например, можно получить адрес структуры по адресу одного из ее полей известным макросом offsetof. То есть, если у тебя структуры соединяются в какие-нибудь цепочки или деревья, то представляющие их структуры могут просто содержаться в полезной структуре с данными. Это позволяет намного меньше ебать память и ебаться с нею.
Нет, в нормальных языках это тоже называется структурой
https://docs.python.org/3/library/struct.html
https://github.com/dubrousky/javastruct
https://learn.microsoft.com/ru-ru/dotnet/csharp/language-reference/builtin-types/struct
Суп програмач.
Вкатываясь в сокеты встретился с проблемой. Написал простенькие клиент и сервер на TCP, порт оба получают через командную строку, но по неведомой причине серверу похуй порт он себе делает рандомный. Есть подозрение, что проёб на этапе заполнения struct sockaddr_in.
Клиент:
int port = atoi(argv[1]);
sockaddr_in cli_addr;
cli_addr.sin_family = AF_INET;
cli_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
cli_addr.sin_port = htons(port);
Свервер:
int port = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(port);
Где я обосрался?
И ещё. Узнал, что сервер делаем рандомный порт через netstat -lt. Последний в графе Local Address у сервера выдаёт подобное:
0.0.0.0:32919 или 0.0.0.0:56557 и тд.
>себе делает рандомный
Не должен.
>Где я обосрался?
Переполнение 16бит/проеб с аргументами/ебанутая система которая при недоступности порта выдает рандомный а не ошибку/еще какая-то хуета.
unsigned int ip = 0xc0a8012d;
unsigned char byte = (unsigned char )&ip;
у меня есть конеш какие-то мысли что просто в чар не влезло всё число, но хочу услышать знатока
он спрашивает почему хвост, а не голова, а за это отвечают эндианы
я понял почему хвост. Но похоже тупанул когда увидел два шестнадцатиричных числа. Я чёто подумал что это два байта. Всё понятно теперь
постарайтесь формулировать свои вопросы точнее
>понял почему хвост и знает как пользоваться поинтерами, но не знает размеры типов
кек
Обычно это делается так:
unsigned char byte = ip & 0xFF;
Чтобы получить другой байт используешь смещение, например чтобы a8 выдрать:
byte = ip >> 2 & 0xFF;
Какого размера получится тип X?
Как же заебали ебать мозги сраные компиляторы говна мочи
>sizeof(long) вот такого
gcc на ту конструкцию говорит 32 бита, clang - 64 бита
Почему не сделали нормальные типы с точными размерами? К примеру, int8, int16, int32, int64 и сразу понятно сколько что занимает в любой ос и компиляторе.
Буквально в этом треде чуть выше всё это уже обсуждали...
Такие типы доступны в stdint.h, но конкретный набор зависит от целевой платформы.
>Почему не сделали нормальные типы с точными размерами? К примеру, int8, int16, int32, int64 и сразу понятно сколько что занимает в любой ос и компиляторе.
Когда делали (60-70 годы) то думали что, наоборот, лучше сделать типы не зависящими от размера слова в системе. Мол, под задачу пользователь (физик какой-нибудь или инженегр) выберет систему с нужным размером слова и у него всё будет максимально возможно точно считаться
Теперь ясно что это был один из множества проёбов, отравляющих нам жизнь до сих пор Хорошо что я юзаю только как lingua franca
>пользователь (физик какой-нибудь или инженегр)
Это такое представление у макак о программистах? Понятно, что-то уровня бабки-сраки с рынка.
>>пользователь (физик какой-нибудь или инженегр)
>Это такое представление у макак о программистах?
Не было программистов в 1960-е. Точнее, были, но это было что-то типа праздного интереса уровня увлекательного хобби, идущего параллельно с какой-нибудь настоящей инженерной деятельностью
Программист был клоун или баба
>Не было программистов в 1960-е
>Программист был клоун или баба
>2к24
>во всю эксплуатируют наработки клоунов
>мы программисты а вы нет
пон
Смотря чем планируешь заниматься.
Если писать софт под готовое железо и ось, то скорее нет.
Если же разработка чего-то своего, то желательно - экономия времени и денег на начальном этапе. Макетирование/отладка прототипа не обходится без навыков пайки.
>>Не было программистов в 1960-е
>>Программист был клоун или баба
>>2к24
>>во всю эксплуатируют наработки клоунов
>>мы программисты а вы нет
>пон
Долбоёб ты не уверенный в себе. нихуя ты не пон
Я об этом говорю не потому что это правильно, а как раз потому что это было ещё одной ошибкой дидов, как и >>3198587
Обучать программированию стали как бы не в двухтыщные годы только, даже в США. До этого оно не считалось чем-то серьёзным.
прекрати срать своей шизой в этом итт треде
я буквально отупел от твоих постов
>Обучать программированию стали как бы не в двухтыщные годы только, даже в США. До этого оно не считалось чем-то серьёзным
Лолчто. Наоборот оно было предельно серьезным - всякие расчеты ядерных взрывов, банковские системы, налоги и прочее. Меняться начало после появления персональных компьютеров, и особенно ibm pc, когда действительно стало массовым.
>Меняться начало после появления персональных компьютеров, и особенно ibm pc, когда действительно стало массовым.
Тупой поридж, не кукарекай раз не видел. Массовыми были спектрумы всякие, а айбиэм-писи был ёбаным гробом с космической ценой доступным только организациям, что твой суперкомпьютер. человеку недоступно, и что еще более офигенно, этот гроб дико всирал тем же спектрумам по спекам, то есть не имел никакого аппаратного ускорения ничего, даже звука не имел, так что хуй там было поиграть даже в игры в которые все играли на массовых компьютерах, только таблички для работы набирать как дебил на печатной машинке, благо памяти дохуя.
>организациям
Малым организациям. Дальше сам додумаешь, если не тупой.
man malloc:
calloc(), malloc(), realloc(), and reallocarray() can fail with
the following error:
ENOMEM Out of memory. Possibly, the application hit the
RLIMIT_AS or RLIMIT_DATA limit described in getrlimit(2).
Another reason could be that the number of mappings
created by the caller process exceeded the limit specified
by /proc/sys/vm/max_map_count.
То он бы выделил тебе виртуальные адреса, которых не существует физически, а что произошло бы при попытке обращений к ним − зависит от реализации. Но скорее всего тебе контроллер памяти выкинет хардверный эксепшен.
>я буквально отупел от твоих постов
Так не бывает. Отупел ты сам по себе когда-то раньше, а может сразу тупым был
>>3199456
>>Обучать программированию стали как бы не в двухтыщные годы только, даже в США. До этого оно не считалось чем-то серьёзным
>Лолчто. Наоборот оно было предельно серьезным - всякие расчеты ядерных взрывов, банковские системы, налоги и прочее.
Хуй там плавал. Учёный муж выдавал тянкам Алгоритм. И они его нахуячивали. Потому что нахуячить программу считалось несложным и нечего этим голову себе забивать.
Так всё и было. Меняться стало где-то в середине 1970-х только, а оформилось по факту в 1990-е где-то, в РФ вообще в 2000-е
>Хуй там плавал. Учёный муж выдавал тянкам Алгоритм. И они его нахуячивали.
Или даже Формулу. Хуле там алгоритм какой-то сделать - говно вопрос же. Циклограмма!
unit8_t хз, а uint8_t это беззнаковый целочисленный размером 8 бит. Никакого обобщения, предельно точно.
>bool
Появился только в C23, ЕМНИП, до этого был только _Bool. Надо читать стандарт про его представление, точно не знаю, но вангую, что он должен заниматить минимально адресуемое значение. Это не обязательно 1 байт на всех платформах. Пример обратного впрочем привести не могу.
>byte
Ты про какой язык спрашиваешь?
>uint8_t
Как тебе написали выше, это беззнаковое целое размером в 8 бит. Его может не быть, зависит от платформы.
Ну я для Ардуины код пишу, как я понял, там почти все как в Си. До этого я писал только на gml, там вообще этой шизы с типами нет. Правильно я понял, что условное число 23 будет хранится как набор разных битов для разных типов?
Число 23 довольно маленькое (<128) и положительное, поэтому для всех однобайтовых типов представление будет одинаковое.
А в чом тогда смысл делать кучу типов для хранения одного байта? Ну я понимаю можно ещё сделать знаковый/безнаковый тип
прикол в разной математике и в декодинге при вытаскивании значения
Ты погоди, продолжишь писать на си, и будешь ещё свои типы от этих определять.
Все еще хотите изучить этот язык?
могу сказать да, не открывая твои ссылки на порно с карликами геями
>с картинками, заданиями и похвалами
Порридж, это тебе не гейские плюсы, изучив которые ты захочешь сменить пол!! Это хардкорный Си, порриджище, тут все картинки должны быть только у тебя в голове; задания ты должен сам себе придумывать, чутка изменяя задачки из хардкорных учебников по алгоритмам; похвала, ну тут всё просто, порриджище, когда у тебя прога отрабатывает без сегфолтов, то это именно то состояние, от которого ты захочешь кончать радугой, а следовательно вновь и вновь возвращаться к нему!!!
прототипы нужны линковщику
сишник декларативный - сначала заявил, потом юзаешь
и вообще съеби нахуй со своими гейскими крестами в другой тред, это давно два разных языка
а как ты понял что там плюсы? просто я их до сих пор не различаю
почему кресты гейские? крест - символ христианства, где традиционно, очень негативно относятся к гомосексуаллизму, несмотря на некоторые поп ытки примирения. Второй крест может означать ещё большее усиление религиозной позиции.
Чел, у тебя расширение файла говорит о том, что ты приверженец жопотрахов.
>>3205043
Так ещё и защищаешь свою касту жопотрахов. Чел, ты стопроцентный плюсовик! Тут даже логику не нужно подрубать, чтобы понять, что ты плюсовик из жопотрахов, просто нужно быть слегка погружённым в лор.
понятно... получается я через три месяца программирования для ардуино случайно узнаю, что там не с++ а си
>крест - символ христианства
а вот и нет
иудеи экпраприировали древний алхимический символ и разбили его на крест и полумесяц, а еще объявили будто это две враждующие религии, в то время как обе являются переводами торы
можем продолжить в зогаче
получается си++ это почти то же самое что си, только больше плюсов на два
Ну допустим, у тебя большой проект, ты Линукс собираешь из исходников. Эти исходники, модули, писали сотни разных людей, и у них сто процентов есть совпадающие названия функций и особенно макроопределения. Если при компиляции всего этого дерьма на любом этапе файлы не были бы явно связаны подключением одного заголовочного файла, а вместо этого подрубалось бы всё, что просто подходит по имени из всего вагона сорцов, это был бы полный пиздец.
Не говоря о том, что это просто удобно, открыть заголовочник, посмотреть на прототипы и почитать их описание прямо там. Ещё если ты коммент напишешь над прототипом, то IDEшки подтянут его как всплывающую подсказку.
а почему нигде не подключается файл с расширением .c? компилятор автоматически начинает его искать при виде заголовочного?
Нашёл книжку "Obfuscated C and other mysteries" by Don Libes, https://archive.org/details/obfuscatedcother0000libe/ Если кто-то умеет в могучее колдунство по снятию drm, закиньте эту книгу на любой файлообменник, другие сишники наверняка будут рады.
Во-первых, си задизайнен для однопроходных компиляторов, которые обрабатывают исходный код последовательно сверху вниз. Такие компиляторы проще для написания. Теперь представь ситуацию когда функция foo использует функцию bar. Пусть они расположены в одном файле и foo находится выше, чем bar. Тогда, если не сделать объявление bar перед её вызовом, то как компилятор узнает её сигнатуру, чтобы проверить корректность вызова?
Во-вторых, в си единицей трансляции является файл и они компилируются по отдельности, никак не пересекаясь. Представь, что в file_a.c есть функция foo, которая использует функцию bar, определённую в file_b.c. Вопрос тут тот же самый, как без объявления bar компилятор может узнать её сигнатуру, если он даже не знает в каком она файле?
>>3205101
>а почему нигде не подключается файл с расширением .c? компилятор автоматически начинает его искать при виде заголовочного?
Компилятор ничего автоматически искать не начинает. Он компилирует только то, что ему скажут. Обычно, программист пишет какой-то скрипт (или это делает за него IDE), который последовательно компилирует каждый файл с исходным кодом в проекте. В итоге получаются объектные файлы. Потом сборочный скрипт помещает их содержимое в исполняемом файле как в контейнере с помощью сборщика. Это если совсем не вдаваться в подробности.
Вот никогда не понимал чрезмерной любви к typedef и using. Потом нихера не понятно, что за типы кругом, и чо происходит. Особенно в с++
Мне вот больше нравится std::shared_ptr<std::vector<float>>, чем floatptr_t
>Мне вот больше нравится std::shared_ptr<std::vector<float>>, чем floatptr_t
А в чём разница?
Мимоходом из D lang
>floatptr_t
ну это типа короче писать. Ну я вот щас поддерживаю проект где на каждый базовый тип свой синоним. И вообще непонятно, что такого. Будето бы живём с 80 пиксельными мониторами в 70 годах
Когда-нибудь тебе придётся заменить тип в большой куче вонючего легаси, чтобы портировать и оживить его, например. Тогда сразу всё поймёшь, насколько же божественно иметь такие синонимы на каждую используемую семью переменных. А где-то прямо при сборке проекта можно указать размер типа с плавающей точкой для математики, например. Собрать хоть на обычных float, хоть на long double. Причём 0 гемора при написании всего этого, просто несколько блоков в одном заголовочнике, и всё.
struct xyi
{
char __unused_20[20];
char used_1;
char used_2;
char __unused_10[10];
char used_3;
} __attribute__((__packed__));
Хочу избежать объявления __unused_X и использовать что-то вроде __COMPEXT_UNUSED_BYTES(count).
struct xyi
{
__COMPEXT_UNUSED_BYTES(20);
char used_1;
char used_2;
__COMPEXT_UNUSED_BYTES(10);
char used_3;
} __attribute__((__packed__));
Так специально же сделано, чтобы можно было бы менять тип в одном месте, а не прыгать по всей проге/проекту и менять один тип данных на другой.
Нужная была бы вещь.
Вот здесь есть вариант, через макросы.
https://stackoverflow.com/questions/42837863/how-to-name-unnamed-fields-in-a-c-structure
Переменным даётся имя с номером строки. Но, если поля структуры объявлять подряд, то всё посыпется к чёрту. Нужно какой-нибудь счётчик глобальный прикручивать. Там же предлагается делать через __COUNTER__, но тот не везде есть.
> всирал тем же спектрумам по спекам
Но спектрум уебище 8бит с резиновыми блять 40 кнопками, монохромом 256x192 на отбросах памяти 16кбит и колхозными интерфесами нгмд.
> Нужная была бы вещь.
Ненужная. Это буквально нужно чтобы раз в год сэкономить 5 минут.
>Какие есть готовые расширения/решения для объявления неипользуемых полей структур?
Один раз я случайно забыл написать имя поля в структуре и получил жалобу типа эта возможность поддерживается только в каком-то стандарте новом
Подробностей не помню
Или так:
#define pad(n) char padmyass##__LINE__[n];
>ну это типа короче писать. Ну я вот щас поддерживаю проект где на каждый базовый тип свой синоним. И вообще непонятно, что такого. Будето бы живём с 80 пиксельными мониторами в 70 годах
Отвечаешь не на тот вопрос что задан же
Так не бывает, чтобы можно было безболезненно поменять типа. Тем более какой-то хуйни вроде std::shared_ptr<std::vector<float>>.
Вообще, это закладывание на супергибкость проекта - мрии
какие то гейские шаблоны опять
тут мужской трид для макросов, осел
Кто в индийских проектах не работал, тот макросы не видел
>std::shared_ptr<std::vector<float>>
Блять, опять эти гейские плюсы в нашем треде!!
Вы издеваетесь????
Ты наркоман? Хули ты прочитал про один make, а больше ты ни про что не читал? CMake, ninja?
Пакетных менеджеров придумали примерно миллион. От себя рекомендую nix.
какая реализация здесь предпочтительнее, первая или вторая? или нет никакой разницы?
>двойной обход цикла вс одинарный
ну ты сам то как думаешь?
ну так то и в первом и во втором случае одинаковое число операций
и почему чар 8 битный? в условиях задачи это установлено?
>a - это просто указатель на какой то участок памяти
>массив использует механизм указателей, но им не является
ритчи (с)
sizeof вернёт размер указателя на кучу, а не объём выделенной на ней памяти; размер же статического массива известен компилятору ещё на этапе компиляции
сайзоф ничо не вернет, это не функция, а макрос препроцессора, вычисляется на этапе компиляции
что значит ничего не вернёт?
int a[2] = 3;
int b = sizeof(a);
вот, я на основе одного числа (указатель a), получаю другое число (b). почему это не функция? почему она ничего не возвращает?
Первый вариант более читабельный, во-первых, во-вторых, меньше действий компу нужно делать, имею в виду, во втором варианте на каждой итерации деление и взятие остатка нужно производить.
>что значит ничего не вернёт?
>почему это не функция?
>почему она ничего не возвращает?
значение знаешь?
>почему это не функция?
Чел, это оператор языка Си. Во-первых, исходя из синтаксиса языка Си, то функцию надо объявлять, а sizeof объявлять не надо. Во-вторых, может быть он и работает, как ф-ция (типа передаёшь ему аргументы и он тебе возвращает некоторое тебе значение), но это не ф-ция, потому что это оператор. и никогда в обществе приличных людей не называй sizeof ф-цией, потому что обоссут.
Первый варик компилирует на -O3 в какую-то дичь на сто миллионов строк, но полагаю работает быстрее.
https://godbolt.org/z/qf3cG9xzG
Ну он, кста, AVX инструкции использует, следовательно, это связано с распаралеливанием, т.к. чисел с плавающей точкой в этом коде нет.
Ну да, меня удивило что он все их использовал. Некислое ускорение должно получится.
>>3211490
Вот тебе третий варик, кстати. Он алгоритмически более быстрый, потому что число операций пропорционально количеству бит.
>>CMake, ninja
>Они ещё сложнее и конфги ещё долбанутее
>
Meson глянь. Это подмножество cmake, я его очень люблю
А там можно делать так?
meson new myproject
meson addlib path-to-lib/namelib
meson build
meson run
meson test
Анон, подскажи, пожалуйста, что нужно читать, чтобы научиться составлять такие решения?
Конкретно этот алгоритм Кернигана я встречал в нескольких задачах на литкоде, там же про него и узнал. Хз, что посоветовать. Классика — это "Искусство программирования" Кнута, но это хардкор, сам не читал. Для дебилов и совсем новичков есть "Грокаем алгоритмы" Бхаргавы. Вот чего-то адекватного в промежутке не знаю. Просто читай больше чужого кода и решай больше задач, а интересное себе выписывай куда-нибудь.
>А там можно делать так?
>meson new myproject
Не помню
>meson addlib path-to-lib/namelib
Нет, ручками конфиг пишешь
>meson build
Да
>meson run
Нет
>meson test
Да
>Анон, подскажи, пожалуйста, что нужно читать, чтобы научиться составлять такие решения?
Найди задачу Fizz-Buzz test и не подсматривая в ответы реши её
В голове щёлкнет и всё поймёшь
>Найди задачу Fizz-Buzz test и не подсматривая в ответы реши её
Я не понимаю? Это троллинг такой или нет? Просто не первый раз встречаю людей, которые советуют эту задачу, когда она является элементарной, в которой нужно просто понимать как работает взятие остатка!!
А тут анон привёл решение, которое даже понять можно только, если самому на листке бумаги произвести несколько раз операцию and над числами в двоичной системе. А не то, чтобы додуматься до него (решения), если ты не имеешь чёткой привычки представлять числа в двоичной системе.
>А тут анон привёл решение
там еще можно сократить код, сделав вайл однострочным и соответсвенно фор, используя оператор запятая
Не, ну соращение кода это другое!
Тут же речь идёт про то, что это решение сокращает общее количество шагов, т.е. каждый раз while пробегает ровно столько раз, сколько единиц есть в двоичном представлении числа, а не каждый раз по 8 повторений или столько повторений из скольких битов состоит тип данных, к которому принадлежат числа.
>в которой нужно просто понимать как работает взятие остатка!!
Нет, она не про это
Да, это довольно тупой троллинг. И да, бро, круто что ты не поленился разобраться в коде, который я вбросил только чтобы пофлексить. Продолжай в том же духе.
Аноны, занимаюсь по книге Кернигана. Делаю одно упражнение если вкратце то там надо создать и заполнить массив
Пишу значит
int nletter[10];
А потом заполняю
for (i=0;i<25;i++)
ndigit=0;
Ага то есть делаю ошибку как бы вначале. Но прикол в том что программа работает! Все нужные элементы массива были созданы при заполнении. Что это за фигня, с каких пор в сишке динамически расширяющиеся массивы?
Писать ты можешь по любым адресам страниц, полученных от операционки. Но за пределами могут оказаться другие твои же данные, так что не надо промахиваться.
>>3211817
>>3211733
>>3211798
Не согласен с этой категоричностью. Ну функция этапа компиляции. Более широкое восприятие этого понятия не мешает, на мой взгляд, пониманию различных его реализаций. Разница ещё более сотрётся с каждым уровнем абстракции. Кроме того, некоторые функции могут в будущем стать макросами; а работа кода при этом нарушена не будет.
>Писать ты можешь по любым адресам страниц, полученных от операционки. Но за пределами могут оказаться другие твои же данные, так что не надо промахиваться.
Кек то есть я могу создать массив arr[10] а потом заполнить его сотней символов и скормить принтф и всё это будет работать и компилятор даже ничего не скажет?
Фига себе.
>а потом заполнить его сотней символов
Ты не заполнишь этот массив сотней символов! Когда твоя прога будет пытаться впихнуть 11-й символ в arr[10], то твоя прога падёт с ошибкой "Segmentation fault", т.е. что означает, что ты вылез за границы той области памяти, которую для твоей проги предоставила ОСь.
>и скормить принтф
Естественно, если твоя прога упадёт с ошибкой сегфолт, то никакой принтф уже не будет отрабатывать.
>Когда твоя прога будет пытаться впихнуть 11-й символ в arr[10], то твоя прога падёт с ошибкой "Segmentation fault",
Тогда почему у меня всё работает и ничего не падает ммм?
>это будет работать и компилятор даже ничего не скажет?
Такое случается, грозя впоследтвии очень трудно находимыми ошибками. Писать ты будешь, вероятно, по своим же переменным, но другим, которые компилятор расположил на той же странице памяти, где-то возможно рядом с твоим массивом.
>Тред синтаксического сахара над языком ассемблера
Ну написано же. )
Тот анон был не совсем прав. Запись за пределы массивы это UB, может быть что угодно, в т.ч. segmentation fault. В данном случае, ты портишь содержимое стека, которое хранится дальше твоего массива, например перезатирается значение i и все переменные которые там размещает putchar. Работает она из-за этого непредсказуемо. Обрати внимание, что букв B выводится явно меньше 100 (лень считать вероятно это 100-'B' = 44), а один символ это @. Первое происходит из-за того, что i становится B, а второе из-за того что 12-ая итерация цикла портит стек для putchar. На следующих итерациях всё улетает в неиспользуемую область стека, поэтому отрабатывает без особых проблем.
Если честно удивительно, почему не падает, потому что должен перезатираться адрес возврата для putchar, мб там какой-то инлайнинг происходит, хз.
Как я понял, никакая функция в стандартном понимании, не может вычислить длину массива, имея только адрес первого элемента
Ну тут у тебя классическое "переполнение стека", да, это не всегда приводит к сегфолту, и вот пример, когда это не привело к сегфолту. Такими ситуациями, кста, и пользуются злоумышленники, когда память за пределами массива заполняют "прыжками" в нужную область памяти.
Звёзды удачно сошлись.
А вообще такие баги ловятся не компилятором, а санитарами типа valgrind. Если ты серьёзно собираешься писать на си, сразу привыкай пользоваться ими обязательно. И при компиляции к флагу со стандартом добавляй ещё '-Wall -Wextra -Werror -pedantic -g' - компилятор всё-таки кое-что может найти. И линтером пользуйся, хотя бы простым типа cppcheck. И хотя бы самый минимальный набор позитивных юнит-тестов.
Если всё это делать по ходу разработки, то сэкономишь огромное количество времени на отладках с дебаггером, а это самое медленное и печальное.
>>3214205
>>3214250
Спасибо за подробные пояснения, анончики.
Я вначале реально подумал что в сишку завезли динамические массивы кек.
> Тогда почему у меня всё работает и ничего не падает ммм?
Если ты на этой хуйне будешь програмить, то ты будешь молится чтобы падала.
Variable-length Array (VLA) в стандарте языка с 99-ого. Правда применять их безопасно как задумано — юзлесс хуита.
>>3212202
Раз уж вы тут пипиркамиалгоритмами меряетесь, скину ещё пару вариантов 80-го уровня.
Вложенный цикл можно вообще убрать.
4-й вариант - создаем массив с возможными значениями количества единичных битов в ниббле, а дальше просто суммируем по индексу (пик 1).
5-й вариант - модификация 4-го. Упаковываем массив констант в uint64_t и суммируем нибблы со сдвигами и смазкой. В идеале, если компилятор сообразительный, можно будет теребить биты напрямую в регистрах без обращений к hashtable (пик 2).
Практика решает, гугл и гитхаб помогают. Нужно было подобное решение несколько лет назад, вот и нашел.
В пятницу не смог вспомнить это решение, зато вчера глотнул коньячку и как вспомнил!
Для начала нужно отрастить длинные патлы, бороду и усы. Остальное придет со временем
Это будет не менее грубая ошибка, ты в первую ячейку массива char будешь запихивать указатель.
Он здесь не в ячейки что-то пишет, а с адресами работает. И cinv, и cheap − нормальные указатели и работают, а cmut это адрес статического массива, и хотя синтаксис работы с ним очень похож на синтаксис указателей, это не указатель, и об этом нужно помнить.
printf("% %d", var) или printf("\% %d", var)
Нашел способ, как втиснуть его, используя переменную чар, но наверняка же есть более вменяемый путь.
Аноны, может быть не совсем в тему, но что почитать по системному программированию для линуха?
Блин точно. Спасибо большое. Мне почему-то уперлось в голову, что должен быть обратный слеш и пиздец.
если я создам массив в стеке (допусти arr) и напишу arr = 10
это приведёт к ошибке компиляции? или я просто потеряю адрес этого массива, и он будет висеть в стеке до завершения программы.
Ошибка компиляции. Адрес статического массива неизменяем. А ещё в стеке что-то может висеть только пока текущий контекст не выбросит из стека.
Так ты попробуй напиши такую программу. В этой строке массиву пытаюсь присвоить значение указателю, но это разные типы. Значение массива вообще нельзя поменять, считай его константным указателем. Чтобы в первый элемент массива написать другое число, нужно сделать как-то так:
cmut[0] = cheap[0];
Иными словами сделать как в учебнике: менять не адрес, а в цикле переписать значения массива.
Чел, имя статического массива это указатель на первый его элемент, следовательно, компилятор понимает, что: "Вот есть метка, от которой я должен отсчитать энтое кол-во байтов на стеке." Если компилятор, при компиляции, выделяет это энтое кол-во байтов на стеке, а потом при дальнейшем шаге меняет это начало отсчёта (адрес первого элемента) на другое значение, то мы получаем утечку памяти, и не по ходу криворукой проги, а по ходу компиляции. Поэтому статические массивы неизменяемы, точнее, неизменяемы его размер и начало его отсчёта.
>Чел, имя статического массива это указатель на первый его элемент
int arr[10];
Что вернёт sizeof(arr) и почему это не будет равно sizeof(int *)?
>sizeof(arr)
Показывает размер массива, т.е., если у тебя int в системе равен 4-ём байтам, то в твоём случае (массив состоит из 10-ти элементов типа int) sizeof(arr) равен 40, т.е., в твоей системе этот массив будет занимать 40 байт. Ну, следовательно, если int это 8 байт, то sizeof(arr) вернёт 80, если int 2 байта, то sizeof(arr) вернёт 20, и т.д.
>sizeof(int *)
В данном случае sizeof возвращает размер указателя, и ему абсолютно неважно на какой тип указывает этот указатель (int, char, double, etc), он всегда будет возвращать одно и тоже значение, в зависимтости от системы, например в 32-х битной системе он будет равен 4-м байтам, в 64-х битной 8-ми байтам, в 16-ти битной равен 2-м байтам (надеюсь ты понимаешь почему так).
Дополню анона. Посмотри, что вернут arr и &arr[0], если не веришь ему.
>Показывает размер массива
>В данном случае sizeof возвращает размер указателя
Ну то есть ты и сам видишь, что имя массива не является указателем, несмотря на то, что по нему можно получить адрес массива. И нельзя их путать, потому что это приводит к ошибкам (самую распространённую ты избежал). Это синтаксический сахар, который близок, но не совпадает на 100% с настоящим указателем.
И не смотря на то, что ты можешь присвоить имя массива указателю в функцию, чтобы потом по этому указателю читать этот массив?
>>3216197
Т.е. в моем понимании имя массива - это константный указатель, т.к. он обладает всеми его свойствами, но имеющий дополнительные свойства и дающий пользователю расширенные возможности, делающие его "именем массива", а не простым указателем.
Однако если работать с ним в пределах возможностей константного указателя, то он ничем от него принципиально не будет отличаться. Мне кажется под капотом так и есть - структура данных с обычным указателем в качестве имени.
1) Сравнить с другим указателем - можем
2) Присвоить другому указателю - можем
3) Прибавлять-отнимать-делить-умножать, чтобы получать смещение, как и у обычного указателя - можем
4) Разыменовывать, соответственно - тоже можем
Т.е. пока ты не пытаешься нарушать эти границы - всё в порядке и поведение будет именно что соответствовать константному указателю.
Разве это ошибка?
Передать в функцию, ты имеешь в виду? Так а как функция его принимает, знаешь? Она в своём контексте создаёт уже настоящий указатель и приравнивает его значение к адресу массива. Там уже и адресной арифметикой можно с ним работать.
Наглядно эта абстракция ломается с двумерными матрицами. Не видел функции с аргументами типа int(*)[]?
>Разве это ошибка?
Да, всё равно ошибка, потому что нужно помнить про sizeof(), про 2д массивы и ещё мелочи, которые сразу не вспомнишь. Ты в курсе, но человек, который с нуля так выучил, наговнокодит и даже не поймёт, что не так.
Я и есть тот человек, который с нуля еще не выучил. Поэтому спрашиваю.
Подожди, но в двумерной матрице у тебя же сохраняется эта закономерность
a == &a[0] == &a[0][0]
и
&a[1] == &a[1][0]
Т.е. понятно, что на большой программе и многомерной матрице я в 99 случаях из 100 обосрусь, если начну мешать одно с другим, но это ведь больше речь про самоконтроль, самодисциплину и защиту от дурака. Иными словами, я могу с ним работать как с указателем и извлекать из этого необходимые профиты, но должен помнить, что это не указатель.
Так вижу.
Интересные решения. Я тогда подумал про таблицу в 256; считай 2 КБ в памяти, немного - зато лишние сдвиги и промежуточные переменные отлетают.
Почему? В первом случае тебе вернулся размер массива, а во втором размер указателя. Всё логично.
Если на ПК, то можно и большую таблицу замутить. А я, в основном, с микроконтроллерами связан, поэтому привык байтоёбить. Там памяти обычно не так много, да и лень бы мне было таблицу на 256 генерить.
sizeof(a+0)
Дурачки пытаются формализовать семантику С, когда это собрание хаков, придуманное под пдп-11 на основе B.
>1[array]='f';
для доступа к 2-му элементу массива, вместо
>array[1]='f';
Впечатляет немного. )
>>3216984
Дело в том, что ты делаешь то, чего боялся тот анон, которые был против того, чтобы воспринимать имя массива, как указатель.
Ты всё смешал и перепутал.
В программе происходит следующее:
Ты присваиваешь переменной x типа int значение 0. Теперь по тому адресу лежит 0.
Дальше ты вызываешь функцию scanf, которая ждет ввода значения типа int, т.е. целое число, что указывается (забыл как назыавется) с помощью %d.
В случае корректного ввода функция scanf запишет введенное тобой значение по адресу &x и вернет 1, в случае некорректного ничего никуда не запишет и вернет 0.
Соответственно ты вводишь букву и функция ничего никуда не пишет. По адресу перtменной x всё также остается значение 0, которое ты задал при инициализации.
Дальше ты забиваешь болт на преобразование типов и ЙОЛО пишешь значение типа int в строку, но (забыл как назыdается) не как %d, что соответствует int, а как %c, что соответствует char.
C позволяет так делать, но преобразует число в символ в соответствии с ASCII таблицей, где число 0 эквивалентно NULL, т.е. на месте %c у тебя напечатается ничего и аутпут должен быть:
"x = "
Числа больше 127 должны давать вывод также и в соответствии с ASCII таблицей. Возможно ты просто не замечаешь, что у тебя оно сидит слева от стрелочкb для инпута в консоли, т.к. ты не воткнул '\n' в конце строки.
1. всё хорошо, всё рисуется (включая невидимый пробел), все довольны
2. вообще ничего не отрисовалась
Ну значит дело либо в системе, либо компиляторе. Тут мои знания уже всё.
Но краткий ответ простой: У тебя у типа чар максимальное значение 127, соответственно при выходе за пределы начинается анэкспектед хуйня, за которую уже никто не несет ответственности.
К примеру у меня на винде и gcc после тильды идет домик, а потом перебирается русский алфавит.
>максимальное значение 127
256
>>3218097
>Дальше ты забиваешь болт на преобразование типов и ЙОЛО пишешь значение типа int в строку
>Дальше ты забиваешь болт на преобразование типов и ЙОЛО пишешь значение типа int в строку
да это похуй ваще
можешь йоло дабл высрать в %c но лучше в %s тогда больше байт высрется в юникоде
>>3217985
будет инициализация числом представленным в виде литеры
>256
Во-первых, unsigned char, а во-вторых 255.
Просто char +-127.
Если мы говорим про стандартную реализацию.
Подключай limits.h и смотри сам CHAR_MAX и UCHAR_MAX
>да это похуй ваще
Похуй, если твои ожидания - твои проблемы.
Не похуй, если ты хочешь получать ожидаемый результат.
какой результат ты ожидаешь получить пихнув децимал и распечатав его как строку символов? твоя мать умрет если не ответишь в этот тред?
душнила блядь душная напридумывал тут ожиданий каких то
Я ожидаю от себя не пихать децимал > 127 в чар без преобразования типа, потому что компилятор мне нассыт за это в жопу, вместо того чтобы подтереть.
Ты ебучего Прату вообще не читал? У него там дохуя умного написано, попробуй.
у тя чот с компилером нелады, отрицательный децимал в юникоде это дефолт тема для русик ленгвиджа, надо всего лишь понимать как работают кодировки, а не ебучего пирата читать
от меня ты можешь ожидать что хочешь, на это мне абсолютно поебать
У меня всё в порядке с компилером, а у того анона залупа вылезла на губе, потому что у него компилер оказался другой.
При этом стандарту поебать, что ты там понимаешь и не понимаешь.
Там четко прописано, что не лезь, блядь, а то заглотишь хуя немытого, но можешь пробовать у нас демокртатия. Хули тебе ебаклаку не понятно?
не понятно почемы ты душнила ебаная пеняешь на компилер когда отрицательные чары превратить в читаемые символы проще простого, достаточно погуглить юникод а не заниматься шизотерией пирата
Потому, дурнина тупорогая, что помимо пекарни есть еще сотни устройств и помимо gcc сотни компиляторов, где твой хак не будет работать. И именно поэтому тебе, еблану, в стандартах расставляют предупреждения об этом.
>предупреждение о неработающем юникоде
Это троллинг тупостью?
Братан, да хуярь, как на питоне, компиль узнает своих. Кто я такой, чтобы тебя отговаривать?
(Пчел, за переполнение знаковых я на код ревью тебя без премии оставлю, если будешь защищать такое. Стажёру простительно, но у нас даже на собесах спрашивают, что будет, если к инту макс_инт прибавить 1, и что будет если к юинту макс_юинт прибавить 1, и почему одно UB, а второе нет.)
Круто, даже не думал про такое.
На первый взгляд не понятно, но в целом логично.
Хотя компилятор всё же ругнулся перед тем как дать результат.
Так тут вроде всё то же, не? "Конкатенация" чисел на чарах и доп вывод байтами этого числа для наглядности.
это у тебя просто рандомная шиза компилятора, или в этом есть глубинный смысл?
В этом есть глубинный смысл, завязанный на байтоеблю непосредственно
Так ты запусти это же просто warning.
У меня на гцц тоже работает хз как и почему лол.
>>3219125
Си берет буквы в одинарных(это важно) кавычках, делает из них числа и складывает цифры этих чисел вместе, получая инт.
Подозреваю что в int у нас попадает адрес начала строки. Поправьте если не так.
>"Конкатенация" чисел на чарах и доп вывод байтами этого числа для наглядности.
Ну ты запусти и наглядно увидишь, что такое little endian, а заодно увидишь утверждение этого >>3219130 , что это число не может превышать инт.
Уже, это оба я.
Вот так повеселее будет.
#include <stdio.h>
int main(void)
{
int x = 'k';
int y = 'ke';
int z = 'ker';
int a = 'keru';
int b = 'kerus';
printf("k\t%d\t%s\n", x, &x);
printf("ke\t%d\t%s\n", y, &y);
printf("ker\t%d\t%s\n", z, &z);
printf("keru\t%d\t%s\n", a, &a);
printf("kerus\t%d\t%s\n", b, &b);
return 0;
}
>>3219134
У тебя всё в компе числа, потому там и используется адрес переменной, а не переменная.
Так число и выводится! Просто спецификатор %s "напрямую" берёт участок памяти и каждый байт преобразует в символы из таблицы ascii.
>рандомная шиза одного, конкретного анона
зис
ему сказали что можно пихать чо угодно куда угодно и это просто биты в байтах, он порвался и пошел срать уб шизой и "цирком"
Да не фигня ничего он не складывает.
int a = 'kek';
putchar (a);
// k
Странно, что он в выделенном случае вылазит за границу своего участка памяти, и печаетает ещё и следующий участок памяти.
Только, если закоментить/убрать объясвление и инициализацию переменной b, этот баг исчезает.
Смотри, чар у тебя занимает 1 байт - это от 0 до 255 комбинаций.
инт а = кек - это 3 байта
к - 1 байт
е - 2 байт
к - 3 байт
Когда ты колешь путчар, то он выводит тебе один байт, т.е. первый, а остальное обрезает, потому что получено достаточно. По той же схеме у тебя тот же сканф работает. Вот ты и получаешь свой к вместо кек.
>>3219149
Не странно, а делает то, что ему сказали.
Подключи лимит и выведи макс. Посравнивай цифры.
Если не до конца понимаешь, то еще %x выведи, и посмотри байтами.
>>3219157
Да, оно
>дамп памяти
а с чего такая уверенность что это символы, а не команды проца? ты же принтеф юзаешь, это не лоулевл сискол с жесткой передачей содержимого
\0 не будет. Он есть только в массивах.
А еще можешь запитьса переменные, как int a = '101a', 101b и так далее. Будет еще страннее.
Потом поочередно закоментируй принтфы и посмотри выводы еще раз.
Как будто бы происходит следующее: компитятор выстраивает все эти значения в порядке возрастания перед исполнением программы. Дальше обрабатывает вывод в принтфы до вывода на экран и потом выводит первый принт с указанной в нем переменной и остальные из таблицы, содержащей значения незадействованных в выводе переменных. В каждом последующем принтфе он добавляет вызов новой переменной и хвост от предыдущего вывода.
Чего я совершенно не понимаю - как он определяет, какие переменные используются в последующих инструкциях, а какие нет. Возможно дело в том, что код статический, мб в динамике будет как-то по другому.
Что еще понял:
тащилово колбасы начинается тогда, когда переменная занимает все 4 байта, читай 4 символа, если меньше, то оно не попадает в вывод.
Поэтому в 4-5 выводе цепляются значения из предыдущего вывода.
Что всё ещё не объясняет, каким образом в этот паровоз попадает содержание неиспользуемых, но объявленных переменных.
Анон, ты чёт запутался! Смотри пик 1 и пик 2. Эта прога выводит только i, исходя из little endian, т.к. дальше идёт символ '\0' как ты можешь видет на пике 3, следовательно 'ab' не выводится, т.к. принтф строку выводит только до нуля. Также на 3-ем пике ты можешь видеть, что после последней переменной нуль встречается через большое кол-во инструкций проца, следовательно, когда переменная занимает все 4 байта, и среди этих 4-х байт нет символа '\0', то сканф продолжает выводить "мусор" из памяти, пока не встретит нулевой байт.
почитай про буфферы консоли я хз
гадаешь на кофейной гуще как убдаун
Вот продолжение.
>почитай про буфферы консоли я хз
Дай хуйней позаниматься, заебал. Спасибо, почитаю
А вот так вот выглядит дамп памяти последней проги, как видишь, нулевой байт встречается здесь только в переменной a.
Ну так всё правильно.
Если у тебя нет \0 в последовательности, но есть число в соседней ячейке, то %s потянет его за собой, что у тебя и происходит в первой строке вплоть до \0, либо, если у тебя, например, в int a будет записано просто от 1 до 3 чаров, то оно тоже прервет чтение.
Иными словами, %s по указанному адресу хуярит, пока данные не закончатся. Поэтому на коротких чарах всё норм, а на длинных начинаются магические трюки.
А затупил я потому, что помимо размера надо было еще адреса вывести. Тогда всё наглядно становится.
Советую тебе также разбираться с каким-нибудь мощным дизассемблером. Если кодишь в линуксе, то это edb, либо GUI оболочка для radare2, которая называется Cutter. Если в винде, то это олли-дбг, и вообще этот курс (https://www.youtube.com/watch?v=lTrA0AKUmus&list=PLYcYkbu2jlH2dMXtMD3qky3iIgQ5yLDg7&index=1).
С асмом и этими инструментами и этими знаниями совсем иначе будешь смотреть на Си, и вообще на работу компа.
Хорошо, спасибо. Я вообще сперва хочу упражнения из учебника дорешать и по 99 стандарту полноценно, но по диагонали пробежаться, чтобы рука набилась и не тупить на простых моментах вроде сегодняшнего. А дальше уже переходить к интересным вещам. Рекомендацию записал.
Ну это не то, чтобы интересные вещи, просто это фундамент, на котором стоит Си. Без него никак! Ну, наверное, можно, но будет сложно. Я тоже тупил на простых функциях, пока один из анонов в прошлых тредах по Си не рассказал про дизассемблирование. И после этого я каждую непонятную штуку пытаюсь дизассемблить.
Ещё, кста, запиши к себе в рекомандации этот сайт: https://godbolt.org/ . Когда погрузишься в дизассемблирование, то угоришь с него.
>Советую тебе также разбираться с каким-нибудь мощным дизассемблером.
Самый надежный способ бросить учить Си ага.
Разбираться нужно с системными библиотеками и реальными программами, а не эти вот все игры.
Ну конечно надо, кто спорит то? А что тебе, главное, мешает совместить?
>А что тебе, главное, мешает совместить?
То что одно отвлекает от другого. Я так уже бросил однажды учить сишку из-за того что вместо нее начал учить асм который потом тоже забросил. Сейчас заново вкатываюсь.
Так асм нужен на уровне понимания того, что происходит, когда дизассемблишь код. Никто тебя не заставляет учить асм до уровня, когда ты уже сможешь сам игровые движки на асме писать, или компиляторы. Чтобы понимать что происходит, когда дизассемблишь непонятные для тебя моменты на Си, достаточно прочесть Ван Гуйа "Программирование на ассемблере", а дальше уже практика дизассемблирования, и вообще любопытство, которое только усиливается, кода ты узнаёшь что-то новое, расставят всё по полкам в твоей голове.
>Так асм нужен на уровне понимания того, что происходит, когда дизассемблишь код
Только вот зачем тебе нужно дизасмить код? Все сто пятьсот тысяч чужих библиотек которые делают 90% работы тоже дизасмить будешь?
Ебать тут нафлудили конечно. А секрет прост.
В одинарных кавычках не просто символ, не 1 байт. Символьный литерал имеет тип int. И поэтому до 4 байт спокойно в него помещается, причём литерал из трёх букв, например 'rek', представлен в памяти как k, e, r, 0. ← А это валидная строка со \0 на конце. С 4 буквами строка уже без \0, и может печатать содержимое соседних переменных или мусор.
А компилятор ругается только на неявное приведение типов указателя, можно просто явно кастануть.
> когда дизассемблишь непонятные для тебя моменты на Си
Ёбнулся что ли? Если непонятен кусок кода на С, то на асме будет ещё непонятнее, плюс туда вмешиваются оптимизации компилятора.
в стм32 запись сразу в eeprom, и реализовать идею будет просто.
в есп32 какая-то хитровыебанная ёбань с nvs, который представляет собой апишку записи-чтения в формате key-value.
внимание вопрос, можно ли писать напрямую в память в есп32? Не случайно там используют эту ненужную хуйню. В esp8266 например эта апишка заботится о том, чтобы NOR-память чистилась как надо
в есп32 для nvs апи есть запись в большущий блоб, но при записи придётся писать сразу дохуя памяти ради маленькой 8битной настроечки
для того чтобы сделать атомизированную память в еспшках надо хитровыебаться в общем
почему x считается за int, если создаётся как char?
типа компилятор насильно превращает его в int из-за инициализации строкой?
Потому что строка — это указатель. Т.о. образом ты инициализируешь char указателем, который неявно приводится к int'у.
Если я правильно понимаю, это этот nvs — по сути какая-то библиотека для работы с flash-памятью? Ты напрямую можешь конечно в неё писать, но очень ограниченно. Если на пальцах, то у тебя есть две операции — стереть сектор целиком (по-моему обычно минимум 4096 байт, смотри к доки к своей железке), т.е. заполнить его 1, либо выставить произвольный бит в 0. Выставить произвольный бит обратно в 1 ты не можешь. Поэтому видимо этот nvs и пишет сразу большой блоб. Тебе часто менять эти настройки надо что-ли?
> умный компилятор сам всë заменяет?
This, хотя зависит от упоротости компиляторописателя. Китайцы, например, могут и не заморачиваться.
>>3223668
Ещё была фишка в компиляторе от ARM, деление на константу преобразовывал в умножение на магическое число и сдвиги. Алгоритм известный, но больше такой магии ни в одном компиляторе не встречал.
Не будет ли так, что будут учейки, номера которых вне диапазона void?
А вообще в чем смысл делать тип вида size_t?
Ну так посчитай сам диапазон адресуемой памяти для своей целевой платформы. Например на 64 битном процессоре это будет 2^64. Правда обычно ОС не даёт приложению напрямую обращаться к памяти, а делается это через виртуальную память и значимыми в указателе являются не все биты. В линуксе это вроде 48, т.е. 2^48=256 Tb, что всё равно является дохрена большим числом.
size_t это тип, который может хранить размер максимального объекта. Используется для всяких подсчётов длин и счётчиков в циклах. Если использовать какой-нибудь unsigned int для этих целей, то при запуске программы на другой платформе его может не хватить.
Это вкусовщина. Алиасы через typedef делают, чтобы не писать каждый раз enum или struct.
Это то же вкусовщина. Алиасы через define делают, чтобы не писать typedef'ы в коде в котором все алиасы были заданы дефайнами например.
Он будет висеть занятым, т.е. там будут те данные, которые твоя прога туда загнала, но этот кусок памяти будет помечен осью, как то, что могут юзать процессы, поэтому, если твоя следующая прога будет использовать этот же кусок памяти, то в нём ты сможешь обнаружить то, что оставила твоя предыдущая прога, это называется мусор.
допустим мне нужно прочитать данные по какому то рандомному адресу. просто так операционка мне это сделать не даст, сразу же выдаст сегфолт. а выдаёт она переменные с рандомными адресами. можно ли инициализировать переменные до тех пор, пока её адрес != нужному мне. и после этого прочитать. получается я могу получить доступ почти к любой свободной ячейки памяти и прочитать что там оставила прошлая программа
А почему ты просто сразу по нужному адресу не хочешь обратиться, разыменовать этот указатель и записать в переменную?
>>3230522
Аноны, подождите, а разве так можно делать:
>сразу по нужному адресу не хочешь обратиться, разыменовать этот указатель и записать в переменную?
Под каждый процесс же выделяется виртуальное адресное пространстов, следовательно, за это пространство мы же не можем выйти?
>можно ли инициализировать переменные до тех пор, пока её адрес != нужному мне.
Так-то можно делать, конечно, но это слишком долго ждать, а в Windows вообще так не получится так сделать, потому что там каждый процесс начинается с адреса исполняемого файла и считай у каждого процесса одни и те же адреса, т.е. тут должно совпасть так, чтобы виртуальный адрес одного процесса совпал с виртуальным адресом другого прцесса, да так, чтобы они ещё совпали и с физическим адресом, в который сохранил данные предыдущий процесс.
Или я в чём-то неправ? Тыкните мордочкой, анонсы!
Это не совсем так. Из-за вопросов безопасности ни одна ОС не делает так уже очень давно. Они держат пул свободных обнулённых страниц. Когда приложение запрашивает память ему выдаётся страница из этого пула с нулевыми значениями. Дальше с этой памятью работает аллокатор приложения, и если много раз освобождать и занимать её, то только тогда там появится мусор. После завершения работы приложения, ядро в бекграунде снова почистит эти страницы.
>>3230507
Нет, нельзя (на декстопных ОС). Приложение работает с виртуальной памятью, адреса которой ОС транслирует в реальные физические адреса. Области памяти разных приложений не пересекаются (в общем случае).
К примеру:
int main()
{
int i1=20;
void* i2=&i1;
}
В i2 физический адрес или виртуальный?
Виртуальный конечно же. До физического тебя ОС не подпустит.
>>3231641
ОС — это тоже программа на си, которая вполне работает с физическими адресами...
Правильный ответ — зависит от программы и среды.
>конкретная программа.
>конкретный вопрос.
>а вот если у рыб были вши.
Куда ты лезешь, умничать, ебанашка?
>>3232585
>>3231641
>>3231634
Да вы все тут дауны, успокойтесь. Адрес в си это просто адрес, и сам ЯП не различает, физический он или виртуальный.
int main() {
for (unsigned short i=0; i<256; i++)
printf("%d\n", 42 (i100000/255) / 100000);
return 0;
}
Если ПРОСТО конвертить во флоут будет по эффективности разница?
смотря что ты вкладываешь в понятие эффективности
не пойми меня неправильно, но судя по твоим каракулям ты под этим словом можешь подразумевать как скорость исполнения/сложность алгоритмов так и получение хотя бы какого то числа отличного от нуля
Ты определенно точно ускоришь код поделив 10000 на 10000 в уме. Но лучше всё же уточнить, что имеется ввиду в реквесте.
Уже три часа прошло, длина всё вычисляется? Чел, у тебя на куче 4 гига мусора по кольцу пересчитываются.
Садишься сверху на прерывание обработки клавиши и отдаёшься
ты за полгода так и не понял куда гуглить
>Как можно быть таким дауном?
/трид
Это вопрос про особенности ОС и си как язык тут не причём. Это как спрашивать: научился забивать гвозди молотком, почему я не могу построить дом? Потому что это отдельный большой пласт знаний. К тому же ОС разные и твои хаки клавиатуры будут тоже отличаться на разных ОС по исполнению. Во времена MS-DOS действительно сами писали обработчики прерываний. Так что тебе верно ответили. Научись формулировать свои мысли точнее.
Книги по системному программированию в UNIX/Windows тебе в помощь.
>По чему учить С?
по любой из представленных на рынке книг
книга K&R прекрасна, но с подвохами, мы уже как то срались в другом тредике по поводу задачи, которая якобы то нерешаема, то это кривой перевод и имелось ввиду другое.
имелось ввиду то самое и она решаема, но вероятно анон так и не решил задачу
2) как вообще работать с пакетным уровнем в си?
Учить его чтобы что? Вот вопрос, на который ты должен ответить. Если тебе на си задачки порешать или там отбор в школу 21 затащить, то поучи его в курсе на степике и не трать своё время.
Если именно серьёзно учить сам язык, то на мой взгляд есть два варианта:
Modern C for Absolute Beginners от Apress, очень круто именно для новичков, с задачками и примерами распространённых ошибок. Но я не знаю, есть ли она на русском.
В пару к ней Стивен Прата − Язык программирования С. Последнее издание, 6е. Это больше справочник, где те же темы разобраны глубже, если нужно.
K&R нахуй не нужно даже открывать, это ловушка. Это говно мамонта, в котором в принципе даже не рассмотрены важнейшие темы, по которым тебя будут ебать на собесах на си девелопера. А хорошая часть из того что рассмотрена, давно устарела.
1. Зависит от типа сокета настроек сети, конечно. Если сообщение размером больше MTU, как оно отправится одним пакетом? Будет разбито. От типа сокета тоже. Потоковый сокет тоже не гарантирует один пакет, даже если сообщение меньше MTU.
2. Да как угодно, это же си! Можно работать с RAW_SOCKET и вручную собирать пакеты и заголовки, если хочется. Можно пользоваться готовыми. Можно подрубать библиотеки для упрощения, от pcap для работы всё ещё на низком уровне, до curl, где уже всё есть. Обычно конечно с curl, нахуй изобретать велосипед-то.
>Обычно конечно с curl, нахуй изобретать велосипед-то.
Хотя это конечно уже не пакетный уровень, сорян. Libnet тогда.
>>3246120
>книга K&R прекрасна
>K&R нахуй не нужно даже открывать, это ловушка.
duality of a man
>это кривой перевод
Я и не собирался на русском читать. Мне хватило просто увидеть перевод одной книги чтобы понять что переводы говно.
>Учить его чтобы что?
Делать 2д игры на SDL. Ну т.е., ебли всяких STM не предусматривается.
>>3246009
Знать бы ещё какая страница.
А, вот. Ну, кстати, с наскока непонятно что просят. Типо чтобы длина хранилась прям любая но при этом сама строка может выводится не полностью?
Анон, объясни, пожалуйста, а что тут сложного?
Если у нас в условии есть строка, то, следовательно, она либо где-то хранится, либо её подают на ввод. Следовательно, если её подают на ввод, то пик1; если уже есть строка, то пик2; если же надо таки посчитать длину строки, то пик3 или 4. Конечно, до пик3 и пик4 можно доебаться, что типа они ограничены длиной строки (2^31 - 1) и (2^64 - 1), а потому это всё не робит... Но типа мы ограничены тем, что только вкатываемся в кодинг, а потому ещё не про различные алгоритмы и структуры данных, которые позволили бы преодолеть рубеж длины строки в 2^64 - 1.
Короче, анон, я чёт не понял в чём подвох в этом задании, поэтому прошу помощи в пояснении.
опять начинается это верчение жопой вокруг пня
книгу открой и почитай ой как сложна а пачиму ты проста ни сделаишь гетчар ой пук хрюк мы же проста вкатунишки и ограничение пазвалитильна пук пук
>>книга K&R прекрасна
>>K&R нахуй не нужно даже открывать, это ловушка.
>duality of a man
Кернигана-Ритчи предлагают читать те, кто собственно не работает на си с какими-то реальными задачами. Преподы и студенты, в основном. Ебутся с какими-то бессмысленными сферовакуумными задачками и теорией CS, а потом удивляются, почему их красный диплом никому не интересен на собесах.
Собственно, вся суть выше в треде с этой задачкой. Её решение никого не интересует, зато на собесе спросят, "Чё кодил по многопоточке, рассказывай."
что мешает в свободное время покодить каэр? не все развиваются через аниме
В основном отсутствие смысла. Если мне захочется кодить на си в свободное время, я в опенсорс буду что-нибудь полезное контрибьютить.
коденг ето процесс, а не результат, совсем уже мозги пропил дед старый
Хех, главное на собесе такое не говори.
А так да на здоровье, кому что нравится. Я действительно люблю результат. И ещё тестами обмазывать.
Учитывая условия:
>Из доступных инструментов первой главы: ветвления ифами, циклы, массивы, функции (без поинтеров, векторов, макросов и всего прочего).
То пикрил. Конечно, если в системе хватит памяти, то MAXLINE можно установить в 2^64 - 2. Что-то большее использовать, учитывая условия, нельзя, потому что надо создавать другие структуры данных, а не исходить только из массива. Конечно, можно доебаться до того, что можно юзать динамический массив, а потому, если хватит памяти, то можно преодолеть и 2^64, но и там не обойтись только массивом, потому что арифметика указателей не позволит использовать целые неотрицательные, больше 2^64 - 1.
да бля
там прикол как раз в том чтобы написать эту хуйню без хранения строки в массиве величиной макслайн
это же очевидно из слов без ограничений
в этой задаче ограничение это макслайн, ты его просто раздвинул, а без ограничений по макслайну могешь?
я написал без хранения строки в массиве (но у меня вроде все равно есть макс длинна ограниченная верхней планкой ансигнел лонг лонг инта для счетчика символов)
Вот это твой код? А в чём ты хранишь строку, если не в массиве? Если это компилить на линуксе, то ты её вообще дважды хранишь, в сегменте .text и на стеке, а стек у тебя 8Мб ограничен по дефолту, и никакой ансигнел лонг лонг не нужен, эта шляпа вылетит в сегу задолго до того как переполнится обычный 32-битный uint.
В винде вообще 1Мб емнип.
не, это не мой
ладно хуй с вами, раз сами не можете решить
храню в выводе консоли
>>3246679
Чел, ну это хуцпа какая-то!
Прикол то в том, что нужно вывести максимальную строку из всех тебе поданных, а ты выводишь вообще все строки. И где здесь решение? Просто нужно признать, что эта задача с "подвохом" и "подвох" в том, что есть ограничения на размер массива, следовательно, и ограничение на массив символов. Это само ограничение даже исходит из того, что арифметика указателей не позволит тебе взять индекс массива больше 2^64 - 1, и не говоря уже о том, что есть ограничения по размеру памяти, ограничения в архитектуре проца, даже, если технические моменты считать преодолимыми, то ты упираешься в ограничение самого Си, а именно в ограничение арифметики указателей.
Поэтому моё решение самое верное! Оно позволяет выводить саму строку и её длину, независимо от длины этой строки, и насколько позволяет система.
у моего решение есть проблемы, но чот мне лень над этим думать, писалось полгода назад на похуй, строку в 2 гига шлепает и ладно
твое решение позволит вывести строку в 2 гига?
Ну, если попердолиться с ограничениями ОСи, то позволит.
о, надо ради этой задачи свою ось написать, тогда попрет, да?
воистину ахуенная книга
Подожди, какой вообще нахуй long long, это C99, а не K&R / ANSI C. В книжке нет никаких лонг лонгов и вообще 64-битных целочисленных, а есть максимум 32-битный лонг. Ну и конечно авторы не ебались с такой хуйнёй, потому что даже представить не могли строку в 2 гига.
ну блядь сишник машинозависимый и на моей машине есть лонг лонги в чем предъява нахуй?
На твоей машине всё есть, можно и на С23 кодить. А в книжке-то нет, то есть ты не по ней си учишь, получается.
Пикрил1.
>>3246624
>>3246671
Мне кажется, смысл задачи в том чтобы если MAXLINE будет скажем 10, а строка 25, то вывести первые 10 символов и 25 как длину. Это первый раздел, это не должно быть настолько заёбистым чтобы лезть во всякие ограничения ОС. Ну и там сказано редачить именно main что как бы намекает.
Тут такое дело, решил по приколу написать что-то типо стринга из плюсов чисто чтобы поиграться и получаю прикрил2. Код: https://privatebin.net/?c632c88f4bebc789#2D8HGjYGwhMswCYsfcVFwmoMUcu9HVrCtLbRCxLNn3xW
Я немного не вьехал, что имеется ввиду. Как s может быть невалидным? При том ворнинг висит только на getString() и deinitString().
А что это триггерится, статический анализатор? Может ему не нравится, что нет проверки на NULL после аллокации/перед деаллокацией.
size может быть равен нулю, тогда s->data будет указывать на NULL.
Что-то в CLion, может clang-tidy, может Resharper C++.
Но это баг, судя по всему.
https://youtrack.jetbrains.com/issue/CPP-25277/Bogus-local-variable-may-point-to-deallocate-memory-warning
https://youtrack.jetbrains.com/issue/CPP-21666/Wrong-warning-Local-variable-data-may-point-to-deallocated-memory
>>3247213
Если бы.
https://en.cppreference.com/w/c/memory/malloc
>If size is zero, the behavior of malloc is implementation-defined. For example, a null pointer may be returned. Alternatively, a non-null pointer may be returned; but such a pointer should not be dereferenced, and should be passed to free to avoid memory leaks.
Ну и жаловалось оно не на data а именно на сам s целиком.
Пропал ворнинг когда я немного переписал код, чтобы init при size = 0 сразу NULL в казатель ебашил и потом проверку на NULL перед вызовом free в функции set добавил.
Новая версия: https://privatebin.net/?5c4248b0e27eb4d1#GgykRpdZD831tKTtCWnvBod2pn2R77ivk14Y49QhJ335
Что я мог забыть/упустить? в плане дыр в памяти и UB
>Что я мог забыть/упустить?
то что это нахуй ненужное говно?
Ну да, но это отличная практика. Знаю что есть дауны которые не могут в поинтеры вообще.
согласен с тобой
я придерживаюсь такой же мысли - лучше писать, чем не писать, даже если это никому не нужно говно
блокчейн и каскады ИИ то же в 50х никому нахуй не были нужны
Забей, ты всё равно не осилишь, даже если тебе дать всё необходимое.
Ты не хочешь программировать и тебе это не нравится.
Вот поэтому у тебя ничего и не получается.
Язык ты тоже не выучил.
>В пару к ней Стивен Прата − Язык программирования С. Последнее издание, 6е. Это больше справочник, где те же темы разобраны глубже, если нужно.
Лучший учебник по программированию из тех, что мне доводилось читать. Базовые "почему" полностью закрывает.
А как можно ответить на ебанутый вопрос? Всем уже и так известно что голый синтаксис как и стандартные либы зачастую в хуй никому не упёрлись и для написания конкретных программ решающих конкретные задачи надо учить ещё и как из твоего ЯП взаимодействовать с чем-то.
>надо учить ещё и как из твоего ЯП взаимодействовать с чем-то.
Вот тут поподробнее, тоже думал с чем бы можно было перемешать синтаксис, например с картиночками или игрульку сделать простую, но смешную, или еще например микро приложение на шиндос для какойто мало нужной фигни. Например зацикленый платформер из знаков с увеличением скорости цикла
https://2ch.hk/pr/res/3249376.html
вроде в мане была инфа по уровням оптимизации и конкретным флагам
ну еще в интернете почитай, надеюсь он у тебя есть
для сравнения компил сишника
профайлинг не делал, но думаю итак очевидно что лисповый бинарь отстает и по скорости исполнения то же (хотя по честному надо сделать)
что интересно объектники напоминают байткоды джавы
считай полноценное приложение, только ему нужна лисп машина, но в то же время исполняется она уже не в репле
просто балуюсь, вдруг кому интересно
В документации, очевидно же.
https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html
Но если вкратце, то O1-O3 это оптимизации бинаря по скорости в ущерб размеру и времени компиляции. О3 заметно раздувает бинарь по объёму. Os это оптимизация по размеру бинаря (но и скорости тоже, там включена большая часть флагов уровня О2). Полезно для дохлого железа типа контроллеров.
Из важного, оптимизация убирает из кода всё неопределённое поведение, и иногда получаются совершенно безумные ситуации, когда компилятор выкидывает целые куски кода или сводит целые функции к { return 0; } отлаживать код нужно без оптимизаций.
>оптимизация убирает из кода всё неопределённое поведение, и иногда получаются совершенно безумные ситуации, когда компилятор выкидывает целые куски кода или сводит целые функции к { return 0; }
Что? По-моему, предел это просчитать что-либо на этапе компиляции и заменить на константу в коде. Если какая-то функция, скажем, степени, должна считать 2³ то она вернёт 8 всегда и это будет захардкожено в итоге.
Не, смотри как он может. Вот есть код. Всё, что он делает − вызывает функцию по неинициализированному указателю. Там есть ещё куски кода, но они не используются. То есть прога ровным счётом ничего не делает. Казалось бы, такая хуйня не должна компилиться, а если компилится, то падать в сегу. Но нихуя, она компилится даже с флагами -Wall -Werror -Wextra -pedantic, а флаг оптимизации, достаточно даже O1, убирает из кода неопределённое поведение − компилятор шарится по коду и подставляет просто чё ему понравится, в данном случае неиспользуемый кусок кода. Скомпиленная с оптимизацией прога полностью валидна, не имеет ошибок и прекрасно работает, просто не совсем как задумано. Когда такая хуйня происходит в проге на десятки тысяч строк − удачи в отладке.
Вот, можешь попробовать у себя: :3
https://gcc.godbolt.org/z/bvT39cPfa
Чуть-чуть переписываем (добавил static для unused_2), чтобы у компилятора было побольше информации для оптимизаций и внезапно сегфолтов нет и UB куда-то пропал.
Спору нет, удобно, когда код написан так, что в нём внезапно сегфолтов нет и UB куда-то пропадает. Вот бы хотя бы почти все так код писали, а остальные знали, что именно нужно чуть-чуть переписать и добавить в небольшом проекте на 50к строк.
ну если вы монолит пишите - земля пухом как говорится
мимо
Вебушок, это не тот тред. Тут мой прадед улыбается мне с небес, наблюдая, как я рефакторю его труд. А твой?
мои предки выбрали юниксвей и микросервисы, больная ты шиндузоскотина
это продолжение юниксвея, базейшая база еще с 50х
блокчейн то же хайпят недавно, а технологии уже ахуллион лет
Потому что они всегда превращаются в колосса на глиняных ногах в итоге.
Это не значит, что монолит всегда заебись, но микросервисы от этого лучше не становятся.
Хз почему ты тут, а не обсуждаешь раст. Там все твои соратники.
мне нравится ретро, причем тут растобляди? может мне еще поzigовать?
>причем тут растобляди?
Такие же любители модных в бизнесе подходов к разработке. У вас много общего. Не вижу никаких проблем в написании микросервисов за деньги, но нахуй за это на борде усираться?
>может мне еще поzigовать?
Зачем? Там ты не заработаешь.
Вот тебя и отпетушат за то, что микросервисы в губы целовал.
Официальные? На iso.org за солидные деньги, очевидно же. Документация по стандартам не бесплатная. Надеюсь, теперь понятно, почему было непонятно, где так просто её взять?
А так погугли, хуле. Наверняка есть дохуя сайтов со 100% скидочками на эти пдфки.
Понял, спасибо за наводку, прост щас книгу у праты взял "лекции" Чуть члекции не написал там вроде пишет что код переписывать сильно не придеься, но это для тех книжных примеров лол
у компилера есть флажок под нужный стандарт, так что даст консоль вообше не надо будет переписывать ничо
ну и си спроектирован с обратной совместимостью вдобавок
Ну такое. По стандартам языка сильно переписывать не придётся, да. Даже если переписывать прадедовское говно из K&R. Где-то убрать deprecated говно типа gets(), переделать объявления и определения функций под нормальный стиль... и всё.
Но это только то, что абсолютно нужно для совместимости.
Ну вот и нахуя, спрашивается, это уточнение про то, что, видишь-ли, нельзя предполагать длину чисел, т.к. она может быть разной, если это убивает суть задания?
>начинаться нулями?
думаю надо доделать форматный выпук модификатором длинны выпука %3d например
хотя хуй знает, нейронка говорит он пробелы будет ставить или я ее не понял
хотя не, хуйню несу, ничо не надо доделывать
если начинается нулями значит просто префикс такой вот короткий будет, не 978 а например 32 или 6 или вообще 0
так что все там у автора четко получается, однако он отдает задачу по проверке корректности данных пользователю, что хуево
Чтобы отбивало нулями, надо флаг 0 в спецификатор добавить: %03d
А вообще задача как задача, на такие мелочи похуй в целом.
>у компилера есть флажок под нужный стандарт, так что даст консоль вообше не надо будет переписывать ничо
Надо будет глянуть, у меня чегото сложно мингв ставился, но вроде я не везде галки наставил, посижу подумаю, понаблюдаю
>>3253354
>Даже если переписывать прадедовское говно из K&R.
Этим как раз и занимался, впринципе жить можно
>>3253914
Чтобы были нули надо %.5d для числа длинной 5, например. Но в задании сказано что нельзя предполагать что длина будет фиксированной при том что она фиксированная так-то. За %05d в книге, опять-таки, не написано, но да, это тоже решение.
Нет, блять, в плюсах и в принципе везде всё нормально.
int x = 25.5;
Вернёт 25. Имело бы смысл если бы вернуло 25.5. Или х. Но, сука, просто 25 это бред ебучий. Я понимаю что применений было бы не очень много (если вообще хоть какие-то), но я не понимаю почему нет. Выглядит как будто кто-то принял необъяснимое решение, а теперь менять уже поздно.
Нет, почему, всё логично, если копнуть. Всё в си состоит из результатов выражений между сиквенс пойнтами. То есть идеальный валидный код на си выглядит как-то так:
7;
0;
-3;
(void);
25.5;
42;
Всё остальное − побочные эффекты. В твоём примере выражением будет (int)(25.5), каст подставится при препроцессинге или токенизации.
Если что-то менять в этой парадигме, то усложнится и компилятор, а ведь это одна из ключевых фишек си, что для любой залупы есть компилятор си, а если его нет, то его несложно портировать или даже написать.
Ну ХЗ, я нахожу странным то что результат операции присваивания не соответствует ни одному из операндов. Я понимаю что каст делается неявно перед операцией и всё такое, но это всё равно контринтуитивно.
Не спорю, действительно контринтуитивно, тем более в 2024-то году. Но и можно понять, почему так сделали и не трогали.
Захотелось поковырять внутренности древней заезжанной вдоль и поперек CVE, но что-то оно не хочет мне корректно показывать содержимое кучи, если в прогу пихнуть достаточно данных и она под-map-пит несколько heap-ов (). Если пытаться скормить адрес кучи вручную, то структура с нужными данными все равно получается скоррапченная и мусорные чанки по итогу.
Знатоки потрохов glibc, помогите плес - чому так и как починить?
Тут уже соль в том что в int не влазят числа которые просят прочитать. Решается банальным переездом на long long или сразу unsigned long long (unsigned int не поможет). Но угадайте что? Правильно: этого в книге пока не было. Знания читающего заканчиваются тем, что для целых чисел есть int и надо использовать %d. Про unsigned, long long и %llu пока ни слова.
Интересно, а дауны сами решали задания которые писали?
>Правильно: этого в книге пока не было.
Этого в книге не будет и не может быть, потому что long long это C99, а книга по C89. Более того, это ты привык к 4-байтовому инту, а для авторов книги он был везде 2-байтовый, и в приложении даже даны типичные определения из limits.h для того времени.
Очевидно, авторы подразумевали какой-то другой способ решения. Думай. А лучше перестань тратить своё ценное время на какую-то музейную хуету и возьми нормальный учебник
Интересно, если тебе дать аналогичную задачу, но со 100 цифрами в числе вместо 13, как ты оправдываться будешь?
>>3257428
Бля, шизонул. Я криво прочитал, нужно чтобы пользователь ввёл всё число за раз но не сказано было что нужно всё прочитать в одно число. А я думал что нужно прочитать в одно число.
>long long это C99, а книга по C89
Ну вообще нет, во твором издании есть 99. Но он как side note, задачи делались под 89, то да.
>А лучше перестань тратить своё ценное время на какую-то музейную хуету и возьми нормальный учебник
Ну так я спрашивал какой. K&R это ещё более музейное говно, а больше никто ничего не предложил. Я и решил что прочитаю этот и потом по https://beej.us/guide/bgc/ пройдусь чтобы новые стандарты подучить.
>>3257278
Я буду читать в строку и потом буду парсить, а не буду создавать 11 переменных для каждой цифры. И парсить в массив скорее всего. Я понимаю что эти задачи сделаны чтобы потом показать как всё на самом деле можно охуенно сделать с массивами, но, как по мне, это уже трата времени.
>>3257479
Из http://knking.com/books/c2/
Да не надо тебе ничего в строку читать и парсить какие-то массивы. Читай посимвольно с помощью getchar() и сразу же суммируй попеременно. Потом делаешь проверку по описанным правилам.
так может тебя подталкивают к реализации длинной арифметики исключительно на интах? ты так не подумал?
ваще я тут читал книгу по лиспу и там есть ахуенный пример почему мы решаем задачки так а не иначе - мы размышляем на уровне своих знаний языка. вот ты наешь что есть лонги и сразу про них подумал касательно решения, а если бы ты не знал про лонги (как и предполагалось)? а? а? а?
шрифт уебищный
будто обратно в уник вернулся где на экране таймз нью роман ебаный а лабы надо в куриер нью печатать
боль и разочарование
моноширинный полужирный скачай себе чо как препод
Ну или так. Но я как бы отталкиваюсь от того что уже было в книге. Поэтому решение там scanf("%1d%1d%1d%1d%1d...") ну ты понял. А чтение в строку хорошо для реальных программ так как проще потом проверять ввод, это я на опыте знаю.
>>3258086
Я же сказал, я неправильно понял задание, там надо чтобы пользователь вводил единым числом но не сказано читать единым числом. Но вообще тут длинной арифметики то и нету, как бы ты не читал, всё равно придётся циферки выдёргивать.
>>3258088
> моноширинный
Значение слова знаешь? Потому что у него как раз моноширинный.
>>3258243
> Ну или так.
Значит притворяешься...
Зачем эта хуеверть со степенями 10ки, scanf разве не может 16ку считывать?
Пихай её хоть в массив интов, а потом сдвиги со смазкой и сложение в цикле как анон с getchar сделал.
Только проверку диапазона 0..9 добавь, а то контролька может случайно сойтись.
imho, конечно, но я байтоёб со стажем, и ещё узрел оптимизацию деления на константу на уровне компилятора. Вам такое не светит, похоже.
Прикольные подсказки. Но сомнительно немного: как представлю какие-нибудь XSetWindowAttributes из X11...
>шрифт
Он просто какой-то очень узкий.
>куриер нью
Хороший. Ну кроме разве что этих
>1OO l00
приколов.
поддвачну
за всю карьеру было пожалуй пару дней когда я кодил с этими блобами по причине лень было разбираться как из очередной говнины их выкорчевывать
у меня прототип перед глазами, нахуй мне эти подсказки, нахуй они вообще кому то нужны, засплить экран и посмотри протосы которые юзаешь
>>3258427
san francisco mono ебани, он вроде под фри лицензией
Стало интересно, это я такой тупой, что не смог навскидку решить задачу, или это действительно не тривиально?
>Стало интересно, это я такой тупой
хз, навскидку это все равно что в первой итерации разбора строки определить последнюю букву. без знания длины самой строки невозможно понять где последняя буква, так же и тут думаю. классически число раскладвают с младших разрядов к старшим, а если тебе нужно это сделать в обратную сторону - сначала определи сколько вообще разрадов в этом числе, ну и дальше ловкость рук домножения на 10 для вытаскиваяния нужного разряда если мы про десятичные, на 16 - шестнадцатеричные и тд
так что думаю сама по себе задача с ебанцой вот и всё
Ещё раз, для тупых, я отталкиваюсь от того что уже было разобрано в книге. По-хорошему там и массивов быть не должно, но я ебал делать 11 переменных как в примере.
>>3258305
Бля, да выделять конкретные разряды из числа это вообще не про оптимизацию, getchar() энивей быстрее будет в разы. Считал, тут же посчитал как анон в >>3258043 и готово.
>>3258420
Отключаются. Просто пока не мешали, поэтому я этого не сделал.
https://www.jetbrains.com/help/clion/parameter-hints.html
Но думаю они полезны когда юзаешь слобознакомую либу или ищешь где какой-то долбоёб попутал порядок аргументов.
>>3258427
https://www.nerdfonts.com/
>>3258503
Спойлер: если ты поделишь число со, скажем, 5 разрядами на 10^5, то гарантированно получишь 0.
Ну и реализайия от меня: https://privatebin.net/?f7073733bfef08aa#GarMgrmUzggcVLgVt6m1ivzjEEvN98csrq6zfZhcgPDU
Напечатай число в строку, а потом перебирай её посимвольно, азаза! Будь как веб-макака.
Логарифм сам по себе имеет сложность от n зависящую, насколько я знаю. Т.е. это то же самое решение, что как если вручную найти старший разряд.
>>3258642
вы посмотрите какой умничка
приятный шрифт, классическая цветовая раскладка, все аккуратненько с разделителями строк, и даже комментарии
не пойму это вижуал студио?
учитесь оформлению у этого анония
замкнутые списки
в качестве рубрики "ебанутые задачки" как бы вы реализовали такую механику? в конце массива поинтер на начало массива
стоит учитывать что интерпретатор лиспа написан на языке ассемблера, а списки (по-моему) реализованы как массивы, и все это реализация на айбиэм писи каком то древнем, так что думаю такое должно быть несложно сварганить на сишке
нахуй оно надо вообще? а хуй знает, просто из мануала по лиспу увидел
Ну это уже шиза, тебе помимо этого кода надо будет ебануть ещё абзац документации по-хорошему. Но да, за оптимизацию зачёт.
>>3258917
Там комменты на русском и нету пробелов между запятой и следующим аргументом при вызове функции. Такое.
>>3258642
Не используй malloc.h, используй стандартную stdlib.h
>>3259082
LinkedList замкнутый сделать несложно. А делать именно массив в хипе в котором последний элемент будет указателем на первый это хуйня ненужная, но всё же делается через malloc(sizeof(T)*ARRAY_SIZE+sizeof(size_t)). И потом просто пишешь адрес первого элемента сразу за последним. Только нахуя? Типикал задача для даунов, ничего сложного в ней нет, практического применения тоже. Ладно если бы LinkedList, но если у тебя была выделена память через malloc то проще просто хранить размер который ты туда передавал чтобы знать насколько надо откатиться назад с конца чтобы достать первый элемент.
>проще просто
проще вообще не отвечать на пост
а касательно задачи, полагаю она должна проходить тот же тест что и на скрине
тобишь
arr[] = {1,2,3, *1};
printf("%d\n", arr[4]); // 2
> Ну это уже шиза
Если ты про проверку введённой строки, то это скорее привычка.
> Но да, за оптимизацию зачёт.
Ваше мнение очень важно для нас.
Кидай ещё, если найдёшь что-нибудь "мемное".
>>3259153
>должна проходить тот же тест что и на скрине
> тобишь
> arr[] = {1,2,3, *1};
> printf("%d\n", arr[4]); // 2
Интересно, что за гений такую хрень придумал. Зачем, а самое главное нахуя в конце линейного массива указатель на 1й элемент?
Предполагается, что размер массива нигде ге хранится и определяется перебором при каждом обращении? И это меня тут в шизе подозревпли, лол.
>что за гений такую хрень придумал
джон маккарти
>>3259181
ну а например arr[5]?
чота я пока не пойму, все еще думаю ты нас наебываешь, засунь в аррай числа 10 20 30
а вот еще что хотел у тебя попросить
можешь дать какой то годный гайдбук по емаксу?
хотел пощупать эту говнину, но в туторе половина хоткеев не работает, да и вцелом мало инфы, даже темка кастомизации не раскрыта
Держи https://ideone.com/WBribW и засовывай себе сам все что хочешь, ЕВПОЧЯ.
Я пересел с вима посмотрев ролики на канале System Crafters. Вот этот плейлист вроде бы https://www.youtube.com/playlist?list=PLEoMzSkcN8oPH1au7H6B7bBJ4ZO7BXjSZ
Тутор у меня прекрасно работал кстати, и не думаю что за четыре года после моего прохождения его сломали, но один хер я чистыми емаксовыми хоткеями не пользуюсь.
Лол, нахуя?
Вы тут типо всякие нереалистичные задачки без практического применения решаете?
Блять, ты настолько тупой? Просто бери остаток деления индекса на размер массива и ты никогда не сможешь вылезти за него, а будешь ходить кольцами. Только, имхо, это немного наеб, а не выполненная задача. Просто используется математика чтобы нельзя было вылезть за массив, никакого указателя там нету. Я ХЗ как это работает в оригинале правда, может там идея такая же была, за лисп не шарю.
пиздец
Чел, ну ты кринжулик конечно в i и j запутаться в одной строке
думаю поинтер на кучу + размер в байтах
тупа два поля, а там как хошь верти, инты у тибя там или даблы уже пахуям
ну я бы так сделол, но я тупой
описать отдельно в файлике структуру динаррай или вектор
хуйнуть ей поинтер на кучу и размер байт
написать поп/пуш интерфейсы, и еще чтобы гап просчитывали при маллоке, потом из мейна прокинуть эту хуйню в основную структуру где тебе дин аррай нужен и дергать функции управления
но нахуй оно надо как говорится
на с99 думаю делается
в новых стандартах по рукам бьют за пропуск аргументов функции
Делается, но это какой-то дедовский код у тебя. В С99 есть такая фишка как Flexible Array Member — когда последним полем в структуре объявляется массив без размера (обрати внимание на размер disp). Это позволяет осуществлять такую прикольную фишку, как на моём примере. Память выделяется сразу подо всю структуру вместе с этим массивом. При этом у тебя не будет происходит лишнего разыменовывания, не хранится лишнего указателя, а ещё все данные структуры располагаются рядом в памяти и попадают в кеш вместе. А для инициализации структур удобно применить механизм compund literals.
ля миня ажтрисет от этого шрифта
залей на пастебин .emacs гляну как у тебя выкрашены разделители фреймов, а то у меня дефолтные слишком контрастные какие то
с меня вот этот шрифт https://fonts-online.ru/fonts/san-francisco-mono
Причина тряски? Спасибо но этот шрифт меня устраивает, собираюсь им пользоваться примерно всю оставшуюся жизнь, если ничего в технологическом плане не изменится.
Сорян, весь конфиг выкладывать не хочу, там личное присутствует. Тебя эта однопиксельная линия вертикальная интересует, если я правильно понял?
(scroll-bar-mode -1)
(setq modus-themes-fringes nil)
(load-theme 'modus-operandi)
>(scroll-bar-mode -1)
у меня эта хуйня фейлилась вроде все равно попробую
>обираюсь им пользоваться
пидарас
>>3262617
а чо такова, малочит сайз поинтера + сайз 4 полей и сразу туда инциализирует структуру с полями
size: вероятно блобящая подсказка местной говнины
1. Подсказка от LSP, как здесь >>3258243 Бесполезная хуита кстати, никак руки не дойдут отключить её по умолчанию.
2. Вроде стандартный синтаксис: взять 0-ой элемент массива - поля структуры по указателю на неё.
3. Compound literal, C99. https://en.cppreference.com/w/c/language/compound_literal
мне вот надо не заходить в вайл если была вызвана $ ./a.out
и наоборот повайлить ввод когда $ ./a.out < filename
по argc/argv в обоих случаях не детектиться
мб копать в сторону stdin структуры? куда там поинтер смотрит или чо?
атмена
ето опять емакс мозги ебет с сохранением файлбуфера
алсо как починить, чтобы трим-вайтспей/формат-буффер и прочая хуйня норм работала? он из за этого нихуя не сейвит
пришлось закомментить вимом
если я правильно понял, единственный вопрос почему умножаем на 4, а не на 3
Не совсем так. Размер поля status - 0 байт, а размер всей структуры - 4 байта. В окошке gdb слева я распечатал это с помощью p sizeof(*disp), можешь сам убедиться. Зато размер первого элемента disp->status[0] — один байт, поэтому умножаем на 4.
Такое поле без размера может быть только одно в структуре и должно быть последним. Из подводных камней тут есть паддинг, который компилятор может задействовать под хранение элементов status. Это стоит учитывать, чтобы не перерасходовать память. В данном конкретном случае у нас общий размер получился 8 байт, поэтому ваще пофиг.
Впрочем так как ты описал тоже делают, если хотят чтобы гарантированно скомпилировать код на любом компиляторе, т.к. FAM это фича C99. Только для C89 нужно указать размер status, т.е. объявить его как unsigned char status[1];
>>3263952
>алсо как починить, чтобы трим-вайтспей/формат-буффер и прочая хуйня норм работала?
whitespace-mode настрой по вкусу, я так сделал:
(use-package whitespace
:hook (prog-mode . whitespace-mode)
:custom
(whitespace-action '(auto-cleanup))
(whitespace-style
'(face trailing tabs tab-mark lines-tail missing-newline-at-eof empty)))
> В окошке gdb слева
окошко слева выглядит слишком страшно, что бы на него смотреть
ещё вопрос. Откуда древнеязыческий бог маллок знает, чему равен sizeof(disp) если disp ещё не создан? разве не должна сначала правая часть вычислится?
sizeof это оператор, который работает с типами, а не данными. Типы известны на этапе компиляции. Само выражение компилятор не вычисляет.
Довольно удобно писать именно выражения, тогда не надо обновлять строку с выделением памяти, если вдруг поменяешь тип переменной, под которую выделяется память. Звучит глупо, но это частая ошибка, которую очень легко пропустить, причём программа может работать корректно, пока очередные изменения в совершенно другом месте не перестанут работать.
а я вот подумал повесить автоформат (ну эти три функции вов врайтин файл листе обернуть в новый дефун) на хоткей какой нить глобальный, ну типа мод+ку который регион форматит чтобы ваще все форматил например
ну просто вот у меня уже есть кусок кода на 300 строк и мне надо его в иф завернуть - я заебусь 500 строк вправо двигать, а так бы автоформат сюда и готово, ну крч ты понял, пойду чо нить поолдую
Как я читаю эту строку в своей голове:
Создай объект структуры, размером больше на 4 байта чем создаваемый тобой объект структуры
Именно так я и выгляжу, только у меня ноутбук, я тощий, патлатый и не курю
>сделал 5 байтовый
а схуяли ты так подумол? инт четырехбайтовый, поинтер интовый, ты попросил пять байт памяти чтобы засунуть инт, инт засунулся в первый байт (эндианы) еще 3 зануленные, и один байт с мусором
ебало?
>чо тут происходит?
Классическая ошибка — перепутаны размеры переменной и указателя на неё.
>>3264839
Скорее 9-байтовый, если ты на 64-битной ОС сидишь. Впрочем используются только 4.
8-байтовых интов я пока не встречал. Что значит "используются только 4"? Если я сделаю кучу интов и проверю их адреса, они отличаются друг от друга на 4.
Размер указателя на 64-битной системе 8 байт, а именно его ты написал в malloc.
sizeof(cat) == 8
sizeof(*cat) == 4
>Классическая ошибка — перепутаны размеры переменной и указателя на неё.
ля тачнягг
чота я то же проебланил что он не разыменовывал в сайзофе
да и хуй с ним
а что такое (звёздочка)cat? какой это тип? int, потому что указатель был типа int?
что будет если обратиться к звёздочка(cat + 1)? сегфолт, потому что программа попытается прочитать ещё три недоступных байта сверху?
да бля не три там сверху
✻(ptr + 1) это как если бы ты обращался к массиву интов arr[1]
поинтер интовый и сдвиг у него на 4 байта при попытке ++ (плюсануть) адрес
у тебя там 9 байт, поинтер смотрит в первые 4, +1 по адресу значит будет смотреть в следующие 4 байта а через звездочку ты их вытащишь сразу все как будто это инт
хочкшь перебрать свои 9 байт по 1 байту - делай чар поинтер и двигай
хочешь по 3 байта - делай типдеф структуры в которой лежит char[3] поле, от него делаешь поинтер и двигаешься со сдвигом 3 байта
дальше сам нафантазируешь себе сдвиги по 2 гига
что тут не так? почему первый файл он проходит (сначала срет итер при заходе и потом срет брейк когда feof(file)) а второй стабильно виснет?
я уже поинтер пробовал занулять, перекопал брейки, хуета какая то, какого хера он во втором файле не может найти признак конца файлв? тут что надо еще fseek хуячить? я же новый дескриптор получаю при fopene
пизда я нипанимаю в чем проблема, хелп
>пик 2 не помог
>>3265947
я нашел причину
но я все равно не понял почему так происходит
что было - в коде остались гетчары и на втором файле прога просто вставала на этом моменте пытаясь получить символ из потока ввода
я не могу понять почему тогда в первом файле не вставала, в мейне гораздо больше всякой хуйни понаписано и он во все ифы заходит, а в юзайдже всего один принт, но там встает намертво
алсо просто заменил гетчары на фгетси
разве файл после фопена не является новым потоком вводы? хули гетчар просит чары с клавы?
>>3265947
>>3266609
Во-первых, бога ради, отформатируй код. На FILE * file просто больно смотреть. Ну и переписать бы его, тут много можно сократить.
Во-вторых, по твоим огрызкам мало что понятно, надо было кинуть весь код.
В-третьих, нету смысла использовать feof() в твоём коде. Просто сравнивай c EOF и всё. То что возвращает feof() всё равно засисит от последнего прочитанного символа.
Вот как я накидал прогу для переписывания файлов в консоль: https://privatebin.net/?9c46d536bffb7076#3jdBX2hgB2oU98QyQGe8bqd9EGJ6shiTCggD8NK9KfpA
Вместо (current_char = fgetc(current_file)) != EOF можно смело ебануть current_char = fgetc(current_file), !feof(current_file)? поменяется аж нихуя.
Ну а что за ошибка так и не понял, скорее всего где-то вне кода на скринах, потому что он выглядит валидным.
Я долбоёб забыл файл закрыть.
https://privatebin.net/?ec4a20a73e933cf0#FKsP3wWNiTMesJkMBX9XPQabeZBGUd2YxXRpsQPEgUfF
Пофиксил.
>То что возвращает feof() всё равно засисит от последнего прочитанного символа.
да хуй пойми, там какие то дебри с попыткоами чтения вне файла, а EOF это интовый минус адын, то бишь прям символ в файле должен быть
крч я бы не сказал что это идентичные хуйни
>>3267136
>Я долбоёб забыл файл закрыть.
>
похуй, я даже не смотрел пастбины твои, как высрать фалй в консоль я и так знал.
>>3267132
>отформатируй код. На FILE * file просто больно смотреть.
предлагай. я пораскинул мозгами и понял что мне достаточно один поинтер юзнуть, ну а раз это поинтер на файл - так и назвал. хз чо тебе не нравится. ptrFile на 3 символа длиннее, а мне лень длинные имена писать так что я часто вообще херачу алиасы в пару букв дефайнами в блоке где надо дохуя поюзать лонгнеймов или однотипных конструкций и потом андефаю
ну вот такой вот у меня кодстайл
>Ну и переписать бы его
вот тут двачую
я дошел до момента когда мне не нравится архитектура
над чот подумать другое
мб примитивную оопэшку прикрутить или я хз, крч думаю
словарь надо еще пилить, ну линтер же, надо будет по словарю чекать ключевые слова всякие и ворнингами срать в выхлопе зис нэйм декларед бат невир юзид
я так и не понял
getchar достает чар с потока stdin
а fopen разве не присваивает поинтер stdin`а на файл?
getchar не работал в файле usage.c, это какая то бага полюбому, объективных причин этому случиться я не вижу
> да хуй пойми, там какие то дебри с попыткоами чтения вне файла, а EOF это интовый минус адын, то бишь прям символ в файле должен быть
Боже, да сьебни в JS, раз читать доки не умеешь.
https://en.cppreference.com/w/c/io/feof
> This function only reports the stream state as reported by the most recent I/O operation, it does not examine the associated data source. For example, if the most recent I/O was a fgetc, which returned the last byte of a file, feof returns zero. The next fgetc fails and changes the stream state to end-of-file. Only then feof returns non-zero.
Иными словами, если ты пытаешься прочитать символ после того как вылез за файл то получишь EOF -1 это на твоей ОС, а так там может быть что-то другое, и да, его нету в файле, это тебе функция туда это суёт чтобы ты как раз и мог понять что файл всё.
Если по итогу последнего чтения было получено EOF, то вызов feof() вернёт не 0. Поэтому и нету смысла его вызывать если больше никаких проверок не делается, просто сравнивай символ с EOF. Ну а по-хорошему проверять получен ли EOF из-за того что файл закончился или ещё чего может быть ошибка во время чтения, тогда тоже будет EOF в переменной в которую читаешь.
+/- эталлонный пример оттуда-же:
int c;
while ((c = fgetc(fp)) != EOF)
putchar(c);
if (ferror(fp))
puts("I/O error when reading");
else if (feof(fp))
puts("End of file is reached successfully");
> предлагай
Поставь себе clang-format, выбери понравившийся стиль и формать автоматом. Я жаловался даже не сколько на нейминг а на положение символов. У тебя код будто в спешке обычным блокнотом писался. Никто не пишет FILE * file.
https://zed0.co.uk/clang-format-configurator/
Тут можешь сгенерить под себя, но я лично не запаривался и взял LLVM форматирование. Нейминги тоже лучше делать сос мыслом. Я в проектах юзаю гугловскую конвенцию.
https://google.github.io/styleguide/cppguide.html#Naming
> мб примитивную оопэшку прикрутить
Тебе в плюсы обмазываться RAII. Иначе что-то мне подсказывает что заебёшься распутывать.
>getchar достает чар с потока stdin
>а fopen разве не присваивает поинтер stdin`а на файл?
не заметил этот рофл
Блять, ну вот опять же, либы ты не знаешь, доки читать тоже не удосуживаешься.
Используй то, что позволяет указать поток. А лучше то, что подразумевает файл.
>Боже, да сьебни в JS, раз читать доки не умеешь.
>>3267248
> доки читать тоже не удосуживаешься
спакуха пердолик, ман отъебнул -> >>3265655
>стена доказательств что юзанье feof неравно юзанью EOF
я так и скозал
>положение символов
у меня стар нотэйшон, или я тебя не понял
>Тебе в плюсы
спакуха пердоля 2
пойди питон поковыряй раз так больно от моей сишечки
>я так и скозал
Не, ты думаешь что эта разница имеет значение конкретно в твоём коде. Но это не так. Я думал объяснив принцип работы ты поймёшь что можно упростить, но, увы, для тебя всё утеряно.
>ман отъебнул
Боже, какие же деграданты плодятся нынче, это пиздец.
Пиздец ты говно, чел. Тебе всё объяснили и ссылочек дали, а ты агришься и набрасываешь в ответ.