Вы видите копию треда, сохраненную 30 января 2018 года.
Скачать тред: только с превью, с превью и прикрепленными файлами.
Второй вариант может долго скачиваться. Файлы будут только в живых или недавно утонувших тредах. Подробнее
Если вам полезен архив М.Двача, пожертвуйте на оплату сервера.
Пожалуйста, пользуйтесь https://ideone.com/ или http://pastebin.com/ для вставки кода, если он длиной больше нескольких строк или содержит [i] или ∗.
Что читать:
- Классика от Отцов: http://www.cypress.com/file/56651/download
- Stephen Prata "C Primer Plus, 6th Edition" (2014): свежая, знает про C89/C99/C11, описывает различия, объемная (около тысячи страниц), годная, с вопросами, упражнениями и ответами. Читать после K&R или до.
- Годное пособие для гуманитариев: http://web.archive.org/web/20160727235220/http://c.learncodethehardway.org/book/ (автор внезапно захотел денег)
- Немного примеров хорошего стиля: http://www.oualline.com/books.free/style/index.html
- ООП, например: http://www.cs.rit.edu/~ats/books/ooc.pdf
- Стандарт ISO/IEC 9899:1999 (он же C99): http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf (драфт) не драфт ищем на торрентах
- Стандарт ISO/IEC 9899:2011 (он же C11): http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf (драфт)
- man/Dash/zealdocs
Чем конпелировать:
- Очевидный GCC.
- clang: оче годно, батя рекомендует.
- Intel C++ Compiler: оптимизации, тысячи их.
- Visual Studio 2017 Community Edition: внезапно этим стало можно пользоваться, особенно с тулсетом clang/C2. Поддержка C11 на уровне "есть все, что тебе понадобится в реальном проекте плюс кривая библиотека". Анализатор кода в комплекте.
- Pelles C (шиндоуз онли): поучиться, вкатиться в C11 (стандарт полностью реализован, имеются в том числе threads.h и прочие stdatomic.h), но количество багов в оптимизаторе и редкие апдейты напрочь отбивают желание собирать этим что-то сколько-нибудь серьезное.
- TCC: очень маленький компилятор с багами и неполной поддержкой C99. С ключом -run умеет компилировать код в память и запускать его, что позволяет писать скрипты прямо на сишечке.
Что еще почитать:
http://c-faq.com/
FAQ из comp.lang.c. Древний, но все еще актуален.
Samuel P. Harbison, Guy L. Steele Jr. "C: A Reference Manual, 5th Edition" (2002)
Ебаный пересказ стандартов C89 и C99 (включая стандартную библиотеку). Для не осиливающих стандарт в оригинале. Читать в качестве подготовки к собеседованиям (есть задачник с ответами) и для ознакомления с масштабами пиздеца перед написанием своего парсера/компилера.
Peter Van Der Linden "Expert C Programming. Deep C Secrets" (1994)
"Си: грязные истории". Смехуечки, немного объяснений, чем обусловлены особенности языка, всем известные подводные камни кто там ругал косяки в JS? у нас в сишечке их гораздо больше, просто они лучше спрятаны, немного байтоебли и непонятно откуда взявшаяся глава про старинные плюсы. Читать в качестве сказки на ночь (на пару вечеров хватит).
Richard M. Reese "Understanding and Using C Pointers. Core Techniques for Memory Management" (2013) - почитать, вкатиться в указатели.
Ben Klemens "21st Century C: C Tips from the New School" (2012)
Paul Deitel, Harvey Deitel "C for Programmers with an Introduction to C11" (2013)
Stephen G. Koch@n "Programming in C (3rd Edition или 4th Edition, если найдется)" (2014)
MISRA Ltd. "Guidelines for the Use of the C Language in Critical Systems" (2013)
Набор рекомендаций по написанию надежного кода на C (промышленный стандарт). Читать - однозначно, следовать - вдумчиво и без фанатизма. Также можно посмотреть https://www.securecoding.cert.org/confluence/display/c/SEI+CERT+C+Coding+Standard
Еще более длинный список: http://www.iso-9899.info/wiki/Books#Learning_C
Онлайн-утилиты:
- https://godbolt.org/ - Compiler Explorer позволяет посмотреть выхлоп компиляторов для введенного куска кода (больше полусотни разных версий компиляторов).
- http://cdecl.org/ - С Gibberish ↔ English помогает читать сложные сишные декларации.
Прошлые треды:
- №23: https://arhivach.org/thread/277223/
- №24: https://arhivach.org/thread/291766/
- №25: https://arhivach.org/thread/303902/
Шапка: http://piratepad.net/bJ1SdmkZyu
Осторожно.
Как программировать на <любой язык нейм>, если компилятор проглатывает умножение на -2 там, где нужно было прибавить 3? Это же очевидная ошибка!
> .cpp
Во-первых, ты ошибся тредом. Во-вторых, тебе чистейшим английским языком написали, что в этих ваших крестах указатель на воид не кастуется в другие указатели автоматом (а в Си кастуется). Поэтому:
1) Не юзай маллок, у вас там завезли всякие векторы или new на худой конец.
2) Если уж юзаешь маллок, влепи каст к (char *).
https://github.com/id-Software/Quake-III-Arena/blob/master/code/qcommon/common.c#L1193
>2) Если уж юзаешь маллок, влепи каст к (char *).
что енто значит? ет не плюсы, просто на сайте почему-то cpp не обращай внимание
значит переменная не в начале блока объявлена и это < c99
char a[2];
int b = 10;
sprintf(a, "%d", b);
printf("%d\n", b); // 0
Нахуй так делать? Может я где-то ошибаюсь?
Если заслать ему const, то всё нормально кстати. Но для меня это не решение.
что, тож даун, очевидно что в младший байт его числа записался завершающий \0. компилируйте уже через gcc, там хоть чаще падать будет из за защиты стека.
> хотя, это наверно от системы зависит... но я помню читал, на винде что-то же было подобное, может в vc.
Довен, у тебя массив утек, sprintf записал в a[2] терминирующий ноль следом за двумя цифрами, компилятор в стеке разместил b следом за массивом. И терминирующий ноль у тебя записался в b.
>>096068
>хотя, это наверно от системы зависит
Да, довен, зависит. От endiannes процессора. На штеудах байты идут в памяти от младшего к старшему, на коком-нибудь PowerPC ты бы долго думал что у тебя все в порядке.
>Для вас даже создание строки на хипе - это уже проблема
Для тебя, довен, это действительно проблема.
> в то время как все остальные об этом даже не задумываются
Ога, core i7 с 64гб памяти будет достаточно каждому для запуска калькулятора, как же, слышали-слышали.
> Вы хоть сами понимаете, как низко вы пали, со своим устаревшим на десятки лет языком программирования?
шел бы ты отсюда, скриптушок. У нас тут эффективные программы, бекэнды, операционные системы и прочие высокоэффективные вещи пишут. Со своими дружками-скриптушками в другой тред иди пердолиться.
Hunk - это чтобы такой выделять-выделять, а затем прибить все разом. Для больших данных - карта там текстурки, модельки.
Zone - такой обычный велосипедный malloc повер большого куска уже выделенной при запуске памяти. Для всякой текучки. Я не понимаю чего там непонятного, по твоей ссылке там все очевидно на уровне хеллоуворлда.
тут даже читать не умеют. нахуй ты мне это всё написал - загадка истории.
В этом и челлендж, руки и мозги должны быть, кто хочет просто писать говно для заработка бабосиков и думать, что он крут и 300к в секунду цель его жизни, то пусть топает в иные языки ну или просто в жопу.
> А как вообще программировать на С и при этом не косячить, если компилятор проглатывает практически любой код, даже такой, который очевидно ошибочен?
Сорцы линух кернела почитай, ну или там кваки iii кою тут вывесили.
посоветуйте что нибудь написать на си , знаю глупая просьба, но я сам учусь и по книгам надоело хочу написать что свое что, но знаю что, а то из-за соло обучения скоро депрессия сожрет
арифметику безграничной длины. сложение, вычитание, деление, умножение - соответственно и сдвиги.
Окей, если ты хочешь кодить на плюсах, как на Си по давно протухшим статьям, посмотри внимательно на свой же скриншот, тебе там компилятор волшебный ключик подсказал в скобочках.
Каким образом можно решить данную проблему? Использование только целочисленной арифметики, написание специальных функций или существуют особые ключи для компилятора?
> Каким образом можно решить данную проблему?
Округлять, менять методы вычисления, использовать типы с большей мантиссой (double, long double).
https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ - скроллим чуть-чуть вниз, там список статей, которые категорически рекомендуются при попытках писать что-либо с использованием арифметики с плавающей точкой.
> Я только начинающий и столкнулся с проблемой, суть её представлена на скриншоте. Как видно, в результате нескольких арифметических операций число теряет своё значение. Я ожидал что уже после первого умножения число станет равным 122.000060. Та же проблема наблюдаются и при преобразовании типов.
Добро пожаловать в мир байтов.
В мире байтов разряды у чисел не 1,10,100,100 и 0.1, 0.01, 0.001
а 2 4 8 16 32 и 1/2, 1/4, 1/8, 1/16 соответсвенно. И с числами, не кратными 1/степень двойки будут всегда проблемы.
https://www.youtube.com/watch?v=PZRI1IfStY0
> В мире байтов разряды у чисел не 1,10,100,100 и 0.1, 0.01, 0.001
На самом деле, в IEEE 754 (и, сооответственно, в Си) допускается существование чисел с плавающей точкой с FLT_RADIX=10 - реализуй такое в железе или софтфлоат в компиляторе, и будут тебе 0.1. Но на практике, да, в большинстве случаев везде FLT_RADIX=2.
В интернете встречал два подхода:
1. Лезть в байты, арифметические функции с нуля, так сказать, даже "+" нинужны.
2. Реализация, которая базируется на стандартных "+", "*".
Имеет ли смысл лезть в (1)? Или на (2) готовые функции на ассемблере всё равно опередят?
Если захочу в (1), то "Алгоритмические трюки для программистов" - то, что надо?
> арифметические функции с нуля
Лолшто? Ты хочешь реализовывать побитовую арифметику софтом на ксорах и вручную перенос в каждый бит добавлять? Какой в этом практический смысл?
> Реализация, которая базируется на стандартных "+", "*".
Есть стандартный стул: берешь stdint.h, берешь какой-нибудь uint, работаешь, соответственно, со словами. Слова хранишь в массивах, little endian (слова, а не байты одного слова!), бегаешь по этим массивам быстро и комфортно.
А как я могу, допустим, поксорить элемент произвольной длины, если у меня есть указатель на него и его размер?
Он спрашивал длинную арифметику, это где флаг переполнения проверяют. Carry Flag то есть.
3. Запилить арифметику на BCD.
П.2 ты не сделаешь по причине отсутсвия доступа к флагам переполнения на чистых сях. Изи делается на ассемблере.
>П.2 ты не сделаешь по причине отсутсвия доступа к флагам переполнения на чистых сях.
Это не так. Как минимум можно просто считать старший разряд битом переноса.
>это где флаг переполнения проверяют
Нет, так поступают только говномесы. Использование флага C и инструкций adc не позволяет использовать векторные операции над массивом данных, которые выполняются мгновенно. Поэтому в одном разряде числа хранятся числа в таком диапазоне, чтобы переполнение не возникало. При этом флаг C не используется вообще, и число дробится на увеличенное число Chunk'ов (увеличено за счет уменьшения диапазона значений разрядов).
Иначе говоря, если число дробится на chunk'и по одному байту, то в этом байте используется не весь диапазон, а только 5 битов. При таком подходе переполнение не возникает вообще, и операция adc не нужна. Проблема здесь в том, что векторные операции отбрасывают флаг C.
Ты, может, и сосешь, а я предпочитаю тянок.
Анонимус
> как я могу, допустим, поксорить
С чем поксорить? С другим подобным? Просто ксоришь побайтово или пословно, пока один из массивов не кончится.
>>096527
Я про длинную арифметику и отвечал. Просто я так понял, он хочет по битам считать, и проверять флаг каждый бит. А можно по словам считать, и переполнением заниматься каждое слово.
А что в этом приятного?
спасибо
Мимо напомнило. Пилил руками транслятор, над каждой функцией в комментариях ставил соответсвующее правило на манер Exp = Term {('+' | '-') Term. В одном месте забыл про //, и нихуя сожрал всё, только много странных предупреждений выдал.
Очевидно, обмазываться разными инструментами, которые призваны облегчить жизнь C/C++ разработчика.
valgrind, clang-analyzer, pvs studio - вот это все
Есть ли разница между static и static inline функциями?
Судя по всему именно сюда прописыват себя вся первоклассная малварь (на этапе работы), ибо найти эти сервисы можно только в реестре, либо с помощью той же тулзы.
У рихтера почти ничего нет про это, мс предлагает качать последнюю WDK и идти по туториалам.
Может тут сможет кто подсказать где искать материал?
писал только обычный сервис на крестах
>Недавно наткнулся на волшебную тулзу - Process Hacker. Трейсит практически все что можно на венде, поэтому я узнал про такую штуку как сервисы типа драйверов.
в сервисах не показывается?
Кто в теме вообще по этой вакансии, там я как понял щас идет массовый набор?
Где можно достать тулчейн с компилятором gcc version 4.2.0 20070413 (prerelease) (CodeSourcery 2007q1-21. Marvell GCC-4.2.0 201111.12345)) для сборки ядра линукс 3.0.0 под ARM?
const int b = a * 2;
clang на маке компилирует, а msvc на вниде или gcc (4.8.4) на убунте ругаются на
>initializer element is not constant
Собственно, с какого перепугу он не константа-то? Как починить? static дела не меняет.
И ещё относительно связанный вопрос: как можно во время компиляции записать в константу результат (чистой) функции? Квадратный корень числа получить надо, поэтому вручную все действия расписай (через макро, например) не особо получится.
>с какого перепугу он не константа-то
Это лишнее, погуглил уже.
Короче говоря, могу я как-то произвести вычисления некоторые во время компиляции для статичных констант?
Точняк лол. Тогда макросы.
>Какой-то ебанутый вопрос.
Мы занимаемся реверсом прошивки. Модули ядра написаны под kernel 3.0.0, собранного под ARM.
И нам нужно собрать ядро версии 3.0.0 под ARM, чтобы запихать его и модули ядра в отлачик и по стеку вызовов определить, откуда вызывается очень интересная для нас функция и что в нее передается.
Ясно, т.е. вам нужно чтобы ABI той же версии было. Хуй знает, а эти CodeSourcery не дают доступ к исходникам своей бадяги? Можно было бы нужную версию скомпилировать.
> Может тут сможет кто подсказать где искать материал?
Zeal
>>098778
Констант в Си почти нет. const задает тип доступа в рантайме, а не то, что принято считать константой в других языках (собственно, тебе и ругается, что ты инициализируешь одну переменную значением другой переменной, а инициализировать можно только константным выражением). Если не можешь что-то вычислить простой арифметикой в макросе - используй кодогенерацию или C++. На самом деле, любой уважающий себя компилятор и сам отлично свернет sqrt(константа) в вычисленное значение на этапе компиляции, но полагаться на это без проверки не стоит.
>>098810
Да возьмите обычный ARM-ассемблер какой-нибудь fasm, точнее fasmarm умеет ассемблировать "поверх" файла, хукните свою интересную функцию прямо в бинарнике, сдампите обычным printk параметры и LR. Дел - на 20 минут, и никакой возни со сборкой.
Но даже с -std=c89/c11 -pedantic пропускает, как это расширение отключить то?
>Да возьмите обычный ARM-ассемблер какой-нибудь fasm, точнее fasmarm умеет ассемблировать "поверх" файла, хукните свою интересную функцию прямо в бинарнике, сдампите обычным printk параметры и LR. Дел - на 20 минут, и никакой возни со сборкой.
Можешь описать подробнее?
However, Clang is more strict than other popular compilers, and may reject incorrect code that other compilers allow.
Они там что, охуели?
>>098810
А именно, у нас есть модуль supplies.ko с очень интересной функцией, которая получает данные, в формате которых нужно разобраться. Сейчас известно немногое: например, поля в дампе, где содержится чек-сумма. Мы хотим раскрутить эту функцию, чтобы узнать назначение всех полей в данных. Пока мы договорились до возможности все это дело проэмулировать, но для этого надо собрать ядро.
> Можешь описать подробнее?
Ну, если у тебя есть рабочая прошивка и железка:
Читаешь любую статью по хукам в Windows (их овердохуя). Делаешь то же самое в прошивке: ищешь пустое место (длинный ненужный текст, неиспользуемую функцию, можно даже "ненужную" функцию, их дохуя в ядре - втыкаешь возврат в начало, остальные байты твои) - будешь там хранить свой код. Воруешь из интересующей тебя функции несколько инструкций, на их место втыкаешь безусловный переход на свой код, твой код дампит все, что тебя интересует, под конец выполняет украденные инструкции и возвращается на следующую после украденной. Возможны варианты.
Пикрелейтед - подобный хук, дампивший RSA-ключи из одной софтины под WinCE прямо во время инициализации библиотеки, работающей с длинными числами. Вместо того, чтобы долго и мучительно искать два десятка ключей в каждой новой версии покриптованного бинарника, мы патчили программу по сигнатурам, и ключи самостоятельно укладывались штабелями в txt-файл рядом с ней.
Блин, не увидел сообщения. Ну у вас немного не тот случай, да. Можно заняться инструментированием по-крупному (не вручную). Правда, тут уже может оказаться быстрее собрать ядро.
Какие именно дефайны и зачем они в коде, написанном на скорую руку? Там даже GetProcAddress на каждый вызов заново делается, потому что возиться было лень. Алсо, это совсем не 2017, а скорее где-то 2009.
Открываешь такой через неделю код
@
Не понимаешь что там происходит
@
Удаляешь все нахуй
@
Делаешь заного
>True story
char array[5];
нуль-терминатор (\0) автоматически добавляется в последний элемент массива? Т.е. в a[4] уже записывается \0, как только я пишу char array[5]?
Нет.
Терминатор "автоматически" добавляется только в строковый литерал (например, "test" - это { 't', 'e', 's', 't', '\0' }). В том числе, когда ты инициализируешь им свой массив char[5].
Хорошо. Тогда, например, создаю char array[5];
затем заполняю его символами с помощью scanf
Во-первых, какой формат ввода нужно использовать в scanf? %c или %s? И как вообще заполнять массив через scanf? Можно увидеть коротенький пример?
%c читает и присваивает один символ. %s присваивает последовательность символов до первого пробельного символа или пока не превышен лимит (например, %4s). При этом %s допишет \0 автоматически (т.е., для %4s массив должен вмещать минимум 5 элементов). Алсо, если тебе нужно ввести кусок строки с пробелами, можно задавать наборы символов - какое-нибудь %4[^\n] то же, что %s, но читает до конца строки, а не до первого пробела. И вообще, http://en.cppreference.com/w/cpp/io/c/fscanf
Спасибо за пояснение. Теперь стало понятнее.
"%s присваивает последовательность символов до первого пробельного символа или пока не превышен лимит (например, %4s)"
А Enter прерывает ввод аналогично пробелу?
Хм, тогда почему в таком коде программа падает при после ввода строки? Ввожу однозначное или двузначное число, например, 5 или 14, нажимаю Enter, получаю виндовое сообщение об ошибке, типа, "Прекращена работа программы...".
int main () {
char b[3];
scanf_s ("%s", b);
printf ("%s\n", b);
return 0;
}
Компилятор вычислит значение "var1 + var2" один раз, или будет это делать в каждой итерации?
Будет ли правильным создать ещё одну переменную перед циклом, "var3 = var1 + var2;", и использовать её в условии?
var1+var2 вычислит один раз.
Можно создать var 3 перед циклом и использовать ее в условии - разницы никакой
> scanf_s
Потому что:
1) #define _CRT_SECURE_NO_WARNINGS.
2) Не используй никогда scanf_s и все прочие _s. Их обещали выпилить из C2x.
3) Если уж используешь, читай справку. У scanf_s на каждый спецификатор нужно ДВА аргумента. Первый - указатель на переменную, как в scanf. Второй - максимальный размер.
>>099129
Стандарту определяет "наблюдаемое поведение": выражение вычисляется каждый раз. Если ты не можешь никак увидеть, что реальное поведение как-то отличается (например, в твоем случае никаких побочных эффектов от вычисления выражения до цикла не будет), тогда компилятор может оптимизировать, а может и не оптимизировать. Можешь надеяться, что такое простое выражение он проглотит, но вот если у тебя там есть что-либо сложнее strlen, лучше создавать переменную. Например, так: for (int i = 0, n = var1 + var2; i < n; i++). Или использовать цикл с декрементом, если тебе похуй на порядок for (int n = var1 + var2 - 1; n >= 0; n--) (хотя тут нужно думать уже - можешь только еще сильнее отсосать по скорости из-за кэша).
Алсо, я тебя наебал про %с в scanf. Я тут полез в справку и внезапно узнал, что оно тоже умеет читать несколько символов, но только указанное количество (%c - 1 символ, %3с - 3 символа), и НЕ дописывает \0 в конец.
Алсо, >>099144 тут я тебя тоже наебал. Второй аргумент с размером нужен только для спецификаторов %s %[] и %c. Никогда этим говном не пользовался.
> Кто обещал?
Комитет по стандартизации. Потому что это хуйня, интересная только Microsoft и попавшая в стандарт под ее давлением.
> И когда этот стандарт выйдет
С99 вышел в 1999. C11 вышел в 2011. Используй логику, чтобы понять, когда выйдет C2x.
аа, так вот почему у меня программа падала. Спасибо, тогда буду онли использовать scanf, вместо scanf_s. А можно еще за \0 пояснить? Что будет, если его не дописывать в конец массива? Ну, допустим буду заполнять через %c. Или это уже совсем другая тема и лучше сейчас этим не заморачиваться?
#define FILE_(номер файла) (размерность массива)
int myfunc(double (звездочка)x, бла-бла)
{ бла-бла}
Также есть один на всех main-файл. Хотелось бы переписать его так, чтобы он по очереди запускал каждый из двухсот файлов, получал некоторый результат и записывал его в выходной файл (выходной файл тоже один на всех).
Как это можно сделать?
>Комитет по стандартизации.
Где можно ознакомиться с обещаниями?
>С99 вышел в 1999. C11 вышел в 2011. Используй логику, чтобы понять, когда выйдет C2x.
C++0x тоже обещали в нулевых, а вышел он аж в 2001 году. Стандарт не принимают каждое десятилетие, а по мере необходимости. Си не особо живой язык, новый стандарт никому не нужен, учитывая, что C11 спустя 6 лет после выхода полностью реализован только в одном компиляторе - Clang/LLVM
> Где можно ознакомиться с обещаниями?
Знакомство осуществляется копанием тут: http://www.open-std.org/jtc1/sc22/wg14/
> новый стандарт никому не нужен
Многие считают по-другому. Я, например, атрибутов жду. И где-то в 21-22 году стандарт должен выйти, а к 25-26 можно будет даже начинать ими пользоваться, лол.
>>099155
Выкинь впизду дефайны, сделай структуру, описывающую имя (если нужно) и параметры файла (размерность, или хуй знает, что там у тебя), сделай массив таких структур. В рантайме в цикле иди по массиву, открывай и обрабатывай в соответствии с указанными параметрами каждый файл.
Это вариант, но я не хотел так делать из-за "раздутия"исходного кода.
Каждый файл -- некоторый ОГРОМНЫЙ функционал. В нынешней тестовой версии самый большой из них занимает 270 страниц двенадцатого вордовского текста и нихуя не работает работает, но в ожидании ответа я успею умереть, самый маленький -- страниц 20.
Скорее всего для ускорения придется дописывать некоторую вспомогательную ерунду, из-за которой каждый файл еще вдвое увеличится в объеме.
Получится даже не "Война и мир", а какая-то ебучая Британника.
Попробуй русским языком более полно описать то, чего ты хочешь. Никакого раздутия исходного кода быть не может. Либо у тебя массив с параметрами, либо массив указателей на параметры или колбеки (а параметры и вспомогательные функции в отдельных файлах). Никакие дефайны там не нужны. Ну разве что для создания похожих элементов массива.
Я тебя кажется понял. Извини за предыдущий дурацкий комментарий.
for (unsigned int i = 0; i < strlen(valinstr); i++) {
if ((i == dot) && (i>0)) {
continue;
}
else {
printf("i = %d\n", i);
dig = TO_DIGIT(valinstr);
val += TO_DEC(dig, powerint);
powerint--;
}
}
В данном фрагменте кода видно, что dot = 1;
В цикле, в условии if сказано:
if ((i == dot) && (i>0)) {
continue;
}
То есть, когда i == 1, то должна быть следующая итерация цикла, т.е. i == 2. В дальнейшем уже постоянно должно выполняться условие else.
В консоли должно выводиться:
i = 0
i = 2
i = 3
И так далее...
Однако, в действительности, я вижу
i = 0
i = 1
i = 2
i = 3
Т.е. i = 1 не должно выводиться, так как итерация цикла c i == 1 пропускается с помощью continue.
Подскажите, в чем проблема
for (unsigned int i = 0; i < strlen(valinstr); i++) {
if ((i == dot) && (i>0)) {
continue;
}
else {
printf("i = %d\n", i);
dig = TO_DIGIT(valinstr);
val += TO_DEC(dig, powerint);
powerint--;
}
}
В данном фрагменте кода видно, что dot = 1;
В цикле, в условии if сказано:
if ((i == dot) && (i>0)) {
continue;
}
То есть, когда i == 1, то должна быть следующая итерация цикла, т.е. i == 2. В дальнейшем уже постоянно должно выполняться условие else.
В консоли должно выводиться:
i = 0
i = 2
i = 3
И так далее...
Однако, в действительности, я вижу
i = 0
i = 1
i = 2
i = 3
Т.е. i = 1 не должно выводиться, так как итерация цикла c i == 1 пропускается с помощью continue.
Подскажите, в чем проблема
dot = 1;
for (unsigned int i = 0; i < strlen(valinstr); i++) {
if ((i == dot) && (i>0)) {
continue;
}
else {
printf("i = %d\n", i);
dig = TO_DIGIT(valinstr);
val += TO_DEC(dig, powerint);
powerint--;
}
}
В данном фрагменте кода видно, что dot = 1;
В цикле, в условии if сказано:
if ((i == dot) && (i>0)) {
continue;
}
То есть, когда i == 1, то должна быть следующая итерация цикла, т.е. i == 2. В дальнейшем уже постоянно должно выполняться условие else.
В консоли должно выводиться:
i = 0
i = 2
i = 3
И так далее...
Однако, в действительности, я вижу
i = 0
i = 1
i = 2
i = 3
Т.е. i = 1 не должно выводиться, так как итерация цикла c i == 1 пропускается с помощью continue.
Подскажите, в чем проблема
dot = 1;
for (unsigned int i = 0; i < strlen(valinstr); i++) {
if ((i == dot) && (i>0)) {
continue;
}
else {
printf("i = %d\n", i);
dig = TO_DIGIT(valinstr);
val += TO_DEC(dig, powerint);
powerint--;
}
}
В данном фрагменте кода видно, что dot = 1;
В цикле, в условии if сказано:
if ((i == dot) && (i>0)) {
continue;
}
То есть, когда i == 1, то должна быть следующая итерация цикла, т.е. i == 2. В дальнейшем уже постоянно должно выполняться условие else.
В консоли должно выводиться:
i = 0
i = 2
i = 3
И так далее...
Однако, в действительности, я вижу
i = 0
i = 1
i = 2
i = 3
Т.е. i = 1 не должно выводиться, так как итерация цикла c i == 1 пропускается с помощью continue.
Подскажите, в чем проблема
Хочу написать диспетчер задач для своего проекта в МКК. Просто микрик, я там сделал простецкое меню на указателях, и большая часть всего на костылях.
Тоесть функцию которая могла бы реагировать на разные события, и периодически сама добавляла те, которые должны быть опрошены по таймеру. Я конечно нашел нужные мне, уже сделанные, проекты на аврфрикс, под названием микроменю. Но я даже не могу построить модель этого в голове. Там кучи новых созданных структур, каким-то образом динамически подключаемые таймеры, обработчики событий, очереди, и все это обильно смазано огромным слоем указателей и переназначений. Я попросту нихуя не пойму, а коментарии только в заголовочном файле, сами функции почти не описаны.
В коде вроде бы все норм. Добавить в printf по else вывод dot. Может быть, ты его где-то повреждаешь, хуй знает.
Да, действительно. В том фрагменте кода, который я привел, должно быть все норм. То есть реализовал эту часть как отдельную программу - все норм работает. Тогда если не найду ошибку в фулл коде, то скину сюда
Начни с создания очереди сообщений в первом потоке (и единственном).
Про кваку и дум не надо, тогда ещё динозавры по земле ходили.
Сам уже давно не увлекаюсь этим, но в студенческие годы пилил свой 3Д двиган.
Во-первых, выблядки из негрософта сделали D3D API на С++.
Во-вторых, некоторые и до сих пор видел пилят на С.
В-третьих, так принято в геймдеве.
В-четвертых, у многих и не только гейдевелов промыты мозги о всесильности и охуенности ОО подхода.
В-пятых, ОО подход действительно в геймдеве может успешно применяться.
В-шестых, никто не запрещает писать в Си стайле на С++ и пользоваться только самым необходимым из С++.
В-седьмых, просто куча либ и двиганов уже написана на С++ и он тащится как ебаное легаси.
Вот, например, все мы знаем, что тип int занимает 4 байта = 32 бита. Следовательно, для unsigned int диапазон будет [0, +4 294 967 295], так как (2^32)-1 = 4 294 967 295. А для signed int диапазон значений равен [-2 147 483 648, +2 147 483 647].
Так вот, float занимает 4 байта, а double - 8. Но опять же, повторю свой вопрос: какой диапазон значений в целой и дробной части будет для каждого из них?
> выблядки из негрософта сделали D3D API на С++
Лож-пиздеж. DirectX использует COM, а COM в Си отлично работает. Во-первых, тебе никто не мешает делать pDirect3DDevice->lpVtbl->DoSomething(pDirect3DDevice, ...), во-вторых, специально для тебя в DirectX до сих пор включают макросы типа IDirect3DDevice_DoSomething.
> так принято в геймдеве
Ложь-пиздежь. Существует дохуя игр, написанных на Си. Иногда со вкраплениями C++. Иногда на C++ в Си-стиле (даже без классов). Да, большинство таких игр выпущено до 2005, но они есть.
> ОО подход действительно в геймдеве может успешно применяться
Ты можешь пилить объекты на структурках и быть счастливым.
Все твои выпады - полная хуйня.
Ладно, давай разберем тобою написанное.
1. Использовать уебищные костыли, когда можно нативно писать более менее нормально на С++ - бессмысленно и тупо.
2. Без пруфоф ты сам знаешь кто. Более того, это вообще ничего не значит. В геймдеве принято писать на С++ - это факт. Для пруфоф можешь зайти на любой геймдев форум.
3. Можешь. Я и не спорю. Только учитывая все то, вышеперечисленное, пишут те же объекты на С++.
>В геймдеве принято писать на С++ - это факт
они там впще ебанулись. нпхуй на конпелируемых языках писать что то кроме движка?
Так никто и не пишет.
Вся игровая механика и логика пишется на скриптовых языках типа луа или яваскрипта.
> какой диапазон значений в целой и дробной части будет для каждого из них
float как бы намекает, что это тебе не fixed-point, поэтому размеры целой и дробной части не фиксированы, и зависят исключительно от положения десятичной точки. В float тебя должны интересовать размеры мантиссы и экспоненты.
В 32-битных числах (float) на мантиссу выделено 23 бита (плюс один неявный), т.е., ты можешь без потерь представить все целые в диапазоне от 20 до 224 (дальше уже ты сможешь представить только некоторые целые), знак отдельно, на экспоненту, соответственно, остается 8 бит, но два значения забиты под специальные состояния, поэтому экспонента может быть от -126 до +127. В 64-битных (double) размер мантиссы и экспоненты 52+1 и 11 соответственно. Максимальные и минимальные значения можешь посчитать примерно как 2минимальная или максимальная экспонента, плюс существуют еще денормализованные значения с плавающей точкой для представления очень маленьких чисел.
>>099542
> Использовать уебищные костыли, когда можно нативно
Твой нативный код развернется абсолютно в те же инструкции, что и сишный. Не вижу никаких костылей: COM - это ничего больше, чем просто указатели на функции, а указатели на функции в Си широко используются.
> Для пруфоф можешь зайти на любой геймдев форум
Зашел, там юнити с додиезами и JS. Составил впечатление, что геймдев - это додиез. Правильно?
хм, интересно, в сбертехе все на явке новое же пишется..
Ну, например, обход директорий в файловой системе): функция обработает файлы в указанной директории, и, если в директории есть дочерние директории, вызовет себя же для их обработки, иначе НЕ вызовет, и эта ветка рекурсии закончится. Очевидно, что момент, когда вложенных директорий не будет, когда-нибудь обязательно настанет на самом деле, не совсем правда: есть всякие символические ссылки, которые могут ссылаться куда-нибудь выше текущей папки, и программа зависнет, если не знает об их существовании.
> когда вложенных директорий не будет
if (child == NULL) return
а по ссылкам в линупсе не ходютъ
void func(int i) { ... }
...
func((int)var);
------------------------
float var = 5.0;
void func() { int i = (int)var; ... }
...
func();
Будет ли разница в скорости выполнения?
Что общего и в чём различие языков C++, Visual C++ и C#, кроме названий?
>Что общего и в чём различие языков C++, Visual C++ и C#, кроме названий?
>пидарасы
>пидарасы
>пидарасы
С двойкой все понятно: 2 / 2 = 1, то есть 1 и 1 будет.
Тройка: 3 / 2 = 1.5, а после каста к инту 1, то есть будет 1 и 1, а должно быть 2 и 1, или 1 и 2.
Думаю задача ясна. Необходимо самое быстродейственное решение.
Это понятно, а ещё?
типа если память заканчивается то реаллок еще скока-то
Тебе куда-нибудь в менеджед языки. В Си ты решаешь вопросы памяти, язык за тебя ничего делать не будет. И тем более он никак не может узнать, что у тебя "память заканчивается". А вот сам ты можешь сделать функцию типа array_put, которая и будет заниматься мемори-менеджментом, если очередной элемент/элементы ей положить будет некуда.
Есть частные/частичные решения: например, в винде ты можешь зарезервировать большой кусок адресного пространства (память не тратится почти), в конец своего массива ставить страницу с PAGE_GUARD, отлавливать исключения и выделять еще памяти. Но это извращение с очень узкими юзкейсами.
Это можно сделать, например, через связный список, выделяя память для узлов по мере надобности. При malloc еще нужно делать проверку на NULL, чтобы программа нормально завершилась при исчерпании памяти компа.
Данные о работниках хранятся в некоторой структуре. Одно из полей структуры имеет тип enum { ENGINEER, MANAGER, CEO} , размер структуры - size, а смещение поля enum относительно начала структуры равно off. Напишите функцию void apply_manager (void employees, int n, size_t size, size_t off, void (apply)(void*)) , которая по массиву сотрудников employees с кол-вом элементов n вызывает переданную в качестве параметра функцию apply , для каждого эл-та массива, описывающего сотрудника-менеджера. Элемент массива имеет тип описанной структуры, параметром функции apply является указатель на структуру.
- пишешь функцию, в ней цикл
- гугли, как передать функции указатель на другую функцию
- в цикле вызываешь другую функцию по указателю на неё
Имеет. Наличие автоматического освобождения памяти зависит от конкретной ОС. Да и норм пацаны тебя будут считать жаба-макакой, который пишет говнокод.
Скорость и управляемость С и кое-какие инструменты для построения абстракций (классы, темплейты/стл) для ускорения разработки и структурирования больших объёмов кода. Типа на двух стульях усидеть пытаются.
int main () {
double value = 57.250000;
char val_str [100];
sprintf (val_str, "%f", value);
printf ("dlina stroki = %d\n", strlen (val_str));
return 0;
}
То есть, имеется число типа double. Перевожу его в строку с помощью функции sprintf. У меня, соответственно, переводится все это число, поэтому, когда я вывожу длину строки, то получаю dlina stroki = 9. Однако мне нужно сделать так, чтобы функция sprintf переводила в строку не 57.250000, а 57.25. Тогда будет dlina stroki = 5. Т.е. мне нужно сделать так, чтобы в строку переводились только значащие цифры, без лишних нулей в дробной части. Как это можно сделать? Писать отдельную функцию для удаления лишних нулей из строки не хочется.
>>101109
Делать free() при выходе - это распространенная плохая практика: при free() куче приходится вытаскивать из свопа всякие давно забытые служебные данные, обрабатывать их, реорганизовывать кучу и делать множество других ненужных вещей, поэтому программа, выделяющая много небольших блоков памяти, будет тормозить при выходе, если делать "правильную" очистку. В то же время, если free() при выходе не делать, ОС может просто пометить соответствующие страницы памяти как пустые и завершить программу мгновенно.
Алсо, если у тебя короткоживущий процесс, который запускают для обработки чего-нибудь, есть смысл вообще никогда не делать free() для небольших блоков памяти, а когда обработка закончится - ОС за тобой приберет.
>>101136
Простой способ: используй %g, укажи точность побольше (%.20g). Сложный способ: используй %g, вытащи из double экспоненту и посчитай, какая нужна точность, чтобы оно не переключилось на %e. Ну или нули обрезай, да.
> g — форматирует число с плавающей запятой в десятичной или десятичной экспоненциальной форме в зависимости от значения и точности
http://ru.cppreference.com/w/cpp/io/c/fprintf
>будет тормозить при выходе
С-с
ей богу, такая проблема. для больших программ более важно исполнение, а не запуск/терминейт.
а с боковой стороны, это ещё одна возможность проверить правильность своего кода.
Да-да, всегда очень сложно заставить себя переосмыслить что-то, вдолбленное на этапе обучения как best-practice.
да-да, так сложно заставить себя перестать компенсировать в интернете на незнакомых людях.
А куда он денется?
Если у кого-то есть время, пожалуйста, гляньте, скажите, что можно улучшить в плане памяти. То есть, в каких местах можно поработать с динамическим выделением памяти. А то я просто написал массивы, типа, char array[100]. Чтобы строка уж точно влезла. Так ведь неправильно делать? Нужно как-то через malloc? Я просто с этим еще толком не разбирался. Поэтому буду благодарен, если кто-то приведет хотя бы 1-2 примера переписанных строк моего исходника.
P.S. Если в коде почти ничего не понятно - могу закомментить его. Только попросите.
глядя на твой код, память это последнее, о чём тебе надо беспокоиться
Можно поконкретнее? В основной части программы идет только проверка наличия точки в записи числа, а затем уже вызов нужных функций для перевода. Что подразумевается под словом "простыни"?
вроде не плохо , я сам тоже учу си , а про malloc
int a // указатель на будущий массив
n = 10// кол-во эл в массиве
a =(int )malloc(nsizeof(int)); //выдляем памяти на 10 элементов по 4байта для каждой переменной типа int
for(size_t i=0; i<10;i++)
(a+i) =rand();
Не понял смысл 3-ей строки. Там nsizeof? Нельзя же просто так переменную n перед функцией sizeof написать
Он умножение забыл, очевидно же. Но лучше приучиться делать malloc(n ∗ sizeof(∗a)), тогда, если вдруг захочется какой-нибудь long long в массиве хранить, не придется мучительно искать, где ты забыл поправить sizeof.
Хорошо. А как мы в этой строке a =(int )malloc(nsizeof(int)); преобразуем память в указатель? Вот, выделили мы 40 байт памяти. Как в указатель на int она конвертируется?
Там звездочки проебались. Хотя вроде итак понятно
Я не понял. Причем тут %g? И как преобразовывать руками?
Повторюсь: допустим есть переменная double value.
И у меня написано
value = 15(1/16)+15(1/256);
printf ("value = %f\n", value);
Вывод будет 0.996094
Как получить 0.99609375?
Повторюсь: укажи блять точность! А %g у тебя или %f - не имеет значения.
printf ("value = %.72f\n", value);
А, понял, спасибо. Хотя странно, что это не делается автоматически. А сколько максимально может быть цифр в дробной части?
И еще, вот указал я точность %.72f. Он мне вывел 72 цифры после точки. Т.е. 0.9960937500000000000... Как сделать так, чтобы выводило только то количество цифр в дробной части, которые будут значащими. То есть если value = 0.1, то будет выводить 0.1, а если value = 0.11111111111, то будет выводить 0.11111111111
Находи остатки от деления на 10^x, где x-порядок интересующего разряда (целое).
И пока они не ноль, выводи остаток, умноженный на 10^-x, приведённый к целому типу)0000)))00000
Аааа, спасибо. Да это я и спрашивал. Но там был вопрос немного в другом - как от ненужных нулей избавиться. Поэтому просто написал %g вместо %f. Однако сегодня столкнулся с проблемой того, что если в дробной части больше 6 цифр, то %g так же, как и %f, округляет до 6 цифр после запятой. Сейчас еще раз перечитал тот пост и сделал по первому способу. (Т.е., например %.100g). Тогда у меня все работает, как надо. Спасибо еще раз, и сорян, если помучал вас тут вопросами
Спасибо, но подсказали еще получше альтернативный способ. %.100g
>Если в коде почти ничего не понятно
, значит его надо переписать, раз даже у написавшего его тебя появляются такие мысли.
Ну, я не знаю, как выглядят большие проекты. Но если посидеть минут 30 над моим исходником, то можно все понять
Ну это на самом деле костыльный способ, потому что текстовое представление double может быть очень длинным (denormals, да и просто большие числа). Наслаждайся: https://ideone.com/JyE5Qp
Ох лол, ты больших проектов не видел. Больше читай исходников, набирайся опыта, как пишут другие.
да, я понимаю, что способ костыльный. Но ведь если double будет очень длинным. (очень маленькое число, как в твоем примере), то можно просто написать %.10000000000g. Мы ведь от этого ничего не потеряем? Ну, если число будет маленьким, то лишние нули он уберет, а если число будет очень маленьким (много цифр в дробной части), то оно все равно влезет в такой диапазон.
вопрос снят
почему sizeof(char) =1 byte, а sizeof(указатель на char) =4 byte& И вопрос как система понимает язык программирования что мы определяем переменную типа int и называем ее i ,так вот как это i связано с реальной памятью и что можно почитать на этот счет
> почему sizeof(char) =1 byte, а sizeof(указатель на char) =4 byte
Потому что один байт может принимать всего 256 значений, поэтому если указатель занимает один байт - он может адресовать лишь 256 байтов памяти. Если тебе нужно 4 гига, тебе понадобится больше байтов в указателе, чтобы хранить больше знеачений.
> система понимает язык программирования что мы определяем переменную типа int и называем ее i
Никак. Информация о типах по большей части теряется на этапе компиляции (остаются размеры), имена тоже теряются, вместо них компилятор выбирает позицию в памяти (или позицию относительно начала кадра стека), чтобы хранить переменную.
> что можно почитать на этот счет
"Код" Петцольда, потом Танненбаум, если осилишь.
>почему sizeof(char) =1 byte
По стандарту. Вообще sizeof возвращает не в байтах, а в char-х, потому sizeof(char) всегда 1. Размер указателя диктуется архитектурой процессора.
char, по сути, это минимальный адресуемый кусок памяти. Название не очень удачное, но что поделать.
> И вопрос как система понимает язык программирования что мы определяем переменную типа int и называем ее i ,так вот как это i связано с реальной памятью и что можно почитать на этот счет
Компилятор компилирует машинный код, который содержит понятные для компьютера "инструкции". Если интересно что дальше читай Таненбаум "Архитектура компьютера".
>почему sizeof(char) =1 byte, а sizeof(указатель на char) =4 byte&
Тебя наверное смущает, что нет смысле передавать в функцию указатель на char, если тебя интересует только значение этого char'a? Ну да, не имеет, но указатели используются не только для экономии на копировании при передаче в функцию. Иногда, например, в функции нужно поменять в памяти значение char'a, не возвращая его из функции, тогда передают указатель на него. Но чаще указатель на char это указатель на начало большого куска памяти, т.е. на целую кучу этих char'ов, которые идут непрерывно в памяти, начиная с переданного указателя. Например, так указатели на строки передают.
Тогда почему инициализация указателей NULL'ом считается нормальным действием? Ведь в адресе 0 могут хранится какие-то данные. Например, часть переменной. С тем же успехом можно инициализировать указатели значением 3211351, вместо NULL
> Ведь в адресе 0 могут хранится какие-то данные
Не могут (запрещено стандартом). В винде, например, специально из-за этой особенности сишечки запрещает выделять первые 4к виртуальной памяти.
> С тем же успехом можно инициализировать указатели значением 3211351, вместо NULL
Можно. Но проверять на ноль дешевле, чем на 3211351.
> запрещает выделять первые 4к виртуальной памяти
А что значит "4к". 4Кб? Сорян за возможно глупый вопрос.
>Можно
Тогда уж нельзя. Ведь если в 0 точно не может быть никаких данных, то по адресу 3211351 они могут быть
Хотя было бы странно запрещать выделять целые 4Кб памяти - слишком много. Но я все равно не понял, что подразумевается под "4к"
>Тогда почему инициализация указателей NULL'ом считается нормальным действием?
Как раз потому что указателя NULL = 0 быть не может и это можно использовать как признак, что данных нет, например. В то время как другая хуитка - это, в зависимости от архитектуры - может быть вполне нормальным адресом.
int *p;
int main () {
p = malloc(40);
return 0;
}
В этом коде видно, что мы выделили блок памяти в куче размером 40 байт, и (как написано в интернете) функция malloc возвращает адрес на начало этого блока указателю p. То есть, если так можно выразиться, указатель лишь знает адрес первого байта (или бита?) всего этого блока, верно? Но в указателе, вернее, в адресе, который в нем хранится, нет никакой инфы о том, когда этот блок заканчивается, так?
Только на первый байт. (Языком стандарта будет точнее сказать, что на первый char.)
> То есть, если так можно выразиться, указатель лишь знает адрес первого байта (или бита?) всего этого блока, верно?
Верно. Не бита, на минимальный адресуемый кусок памяти на твоей машине, которым по стандарту является char. Обычно это 1 байт.
> Но в указателе, вернее, в адресе, который в нем хранится, нет никакой инфы о том, когда этот блок заканчивается, так?
Да, так. Так что размер блока нужно либо хранить отдельно, либо помечать в конце блока памяти его конец (так делается со строками, например, в конце ставится '\0', он же 0).
Если указатель хранит адрес только на первый байт всего блока, то как тогда функция free() высвобождает всю выделенную память блока? Возьмем опять же такой код и добавим free
int *p;
int main () {
p = malloc(40);
free(p);
p = NULL;
return 0;
}
Как ф-ия free понимает, что ей нужно освободить 40 байт памяти, а не 1? Ведь p содержит адрес только на начало первого байта всего блока.
Это проблемы ОС, она хранит инфу о том что кому выделено, из кода эту инфу в большинстве случаев получить нельзя (потому что управление памятью нетривиальная задача, разные ОС решают её по разаному).
Хорошо, спасибо
> Это проблемы ОС, она хранит инфу о том что кому выделено
В данном случае, это проблемы стандартный либы, в которой malloc и free реализованы, ОС тут ни при чём.
Ну строго говоря да, ты прав, наверное. Конкретно тут libc рулит, не зазглядывал в сорс. libc сорт оф ассоциирую с самой ОС.
Тебе это знать не положено.
В K&R есть одна из реализаций malloc.
У неё есть размеры выделенных кусков кучи, указатели на начала, она ещё пытается интеллектуально выделять
Куча (heap) устроена как двусвязный список.
Если вычесть из твоего указателя 8 или 16 байт, нетрудно найти заголовок области в куче. А оттуда получить указатели на предыдущую/следующую области.
Алсо, там ещё и флажки есть.
Да на каком-нибудь микроконтроллере и сейчас можно найти подобное без проблем. Вполне себе нормальное решение, если на скорость поиска свободных блоков и на фрагментацию похуй.
...
int @p;
func(p);
printf("%d\n", @p) // -421423441 (мусор)
В данном случае функция "func" работает с локальной копией указателя, правильно? А передать в функцию сам указатель нельзя?
О как круто! Спасибо.
Я хотел еще один вопрос задать, на счет закомментированного кода по ссылке, но в ideone даже так не работает, нолик выдает. Почему?
https://ideone.com/esDAHP
На хосте такой код прекрасно работает, а вот закоментированный - сегфолтит. Тот же вопрос, почему?
Очень путаюсь в указателях.
А хотя я все понял. Ты же мне и так дал ответ - указатель на указатель.
https://ideone.com/0kJObR Нормально? На хосте функционирует прекрасно, хотя тут почему-то все равно не работает.
int i = 5;
✡p = &i;
в ✡p теперь указатель на кусок памяти, аллоцированный на стеке в функции. После того как функция выполнилась её память уже может содержать что угодно. В общем это ошибка так писать код. На ideone стек зануляется видимо, потому и выводит 0.
Самое близкое по смыслу это было бы выделить память в функции:
void func(int ✡✡pp) // переименовал, чтобы было понятно, что это указатель на указатель, меньше путаться будешь
{
int ✡i = malloc(sizeof(int)); // выделяем память
✡pp = &i;
}
int main(void)
{
int ✡p;
func(&p);
printf("p: %d\n", ✡p);
free(p); // освобождаем
return 0;
}
Закомментированный код сегфолит, потому что ты передаешь ✡gp в функцию (printf("gp:%d\n", ✡gp);), что означает "взять значение по указателю gp и передать это значение в функцию", дальше компилятор без спроса приводит типы и интепретирует это значение как указатель на указатель. Тут может упасть аж в двух местах, если gp действительно куда-то указывает (gp != 0), то упадёт при попытке доступа на запись в этот кусок памяти (если, конечно, не случилось чудо и твой передайнный в функу int не нумерует какой-то твой кусок памяти, в этом случае прочитаются какие-то левые данные). Если gp = 0 (что вполне возможно для глобальных переменных, не помню точно зануляются ли глобальные переменные по стандарту), то упадёт прямо при вызове функции, т.к. ты пытаешься нулевой указатель разыменовать (это термин такой, "разыменовать указатель — получить значение из памяти, куда указывает указатель").
int i = 5;
✡p = &i;
в ✡p теперь указатель на кусок памяти, аллоцированный на стеке в функции. После того как функция выполнилась её память уже может содержать что угодно. В общем это ошибка так писать код. На ideone стек зануляется видимо, потому и выводит 0.
Самое близкое по смыслу это было бы выделить память в функции:
void func(int ✡✡pp) // переименовал, чтобы было понятно, что это указатель на указатель, меньше путаться будешь
{
int ✡i = malloc(sizeof(int)); // выделяем память
✡pp = &i;
}
int main(void)
{
int ✡p;
func(&p);
printf("p: %d\n", ✡p);
free(p); // освобождаем
return 0;
}
Закомментированный код сегфолит, потому что ты передаешь ✡gp в функцию (printf("gp:%d\n", ✡gp);), что означает "взять значение по указателю gp и передать это значение в функцию", дальше компилятор без спроса приводит типы и интепретирует это значение как указатель на указатель. Тут может упасть аж в двух местах, если gp действительно куда-то указывает (gp != 0), то упадёт при попытке доступа на запись в этот кусок памяти (если, конечно, не случилось чудо и твой передайнный в функу int не нумерует какой-то твой кусок памяти, в этом случае прочитаются какие-то левые данные). Если gp = 0 (что вполне возможно для глобальных переменных, не помню точно зануляются ли глобальные переменные по стандарту), то упадёт прямо при вызове функции, т.к. ты пытаешься нулевой указатель разыменовать (это термин такой, "разыменовать указатель — получить значение из памяти, куда указывает указатель").
>✡pp = &i;
Надо только ✡pp = i; вот так, раз i теперь не int, а указатель на int.
оередной быстрофикс
void func(int ✡✡pp) // переименовал, чтобы было понятно, что это указатель на указатель, меньше путаться будешь
{
int ✡i = malloc(sizeof(int)); // выделяем память
✡i = 5;
✡pp = &i;
}
Точнее вот так, извините за спам. :(
void func(int ✡✡pp) // переименовал, чтобы было понятно, что это указатель на указатель, меньше путаться будешь
{
int ✡i = malloc(sizeof(int)); // выделяем память
✡i = 5;
✡pp = i;
}
последний фикс, обещаю
Ну в целом да, только free забыл, не забывай про free, а то память терять будешь.
Ну и лишний код (я так понимаю ты просто играешься для понимания):
int ✡✡p;
p = &gp;
func(&*p);
можно поменять на
int ✡p;
func(&p);
и обойтись без gp.
Нет, мне именно с gp нужно. Пытаюсь на простом примере понять, как сделать нечто похожее в основном программе. В принципе понял.
У меня там именно гора указателей на указатели, указывающие на указатели на указатели, указывающие на указатели.
Вот как раз еще один вопрос в связи с этим. Я в таких дебрях не понимаю ничего.
Есть указатель на указатель - var1, который указывает на var2 - тоже указатель на указатель, который указывает на var3 - обычный указатель на int.
Как мне обращаясь к var1 проверить NULL ли var3 или не NULL?
Просто if(var1 == NULL), как я понимаю, не то выдает.
Всё ясно, ещё раз спасибо. Схоронил себе пикчу, буду поглядывать.
А Си уже скоро ВСЁ? Всё-таки есть Rust, GO или хотя бы C++.. Может не стоит его даже учить?
Не скоро.
Плюс стоит учить, даже если не будешь активно писать на нём, чтобы понять как современные компьютеры и ОС работают (указатели, стек, куча, cache & locality).
Как обратиться к переменной "i" через "var"? Которая в функции. Компилятор говорит, что тип "type_ *" не структура, нельзя к нему мол через "->".
-> автоматический разыменовывает указатель, а . нет
typedef struct {
int i;
} type_;
int main(int argc, char const *argv[])
{
type_ t;
type_✡ pt = &t;
// это всё одно и то же
t.i = 6;
pt->i = 3;
(&t)->i = 1;
return 0;
}
И у тебя код упадёт как пофиксишь ->. Потому что ты определил указатель на структуру, но этот указатель никуда не указывает. Надо или определять структуру на стеке (как я сделал выше) или выделить самому память через malloc (+free не забудь): type_ ✡var = malloc(sizeof(type_))
Ваще почитай книжки из шапки или ты чёто хочешь руками починить просто?
Погоди, ты же на вопрос не ответил. К var->i в мейне я обратиться могу, а к вот к var->i в "func" - нет, потому что в "func" var это указатель на указатель, в мейне же var - просто указатель. Или я что-то недопонял?
> Потому что ты определил указатель на структуру, но этот указатель никуда не указывает.
Это понятно, по-быстрому примерчик написал, не учёл. У меня код не компилируется, в этом проблема.
> Ваще почитай книжки из шапки
А где именно в полной мере объясняется про работу с указателями? Базовый уровень, так скажем, мне понятен, но как только ситуация становится относительно сложной, вроде той что на пикче выше, как я теряюсь. Появилась вот структура и мне совершенно непонятно как с ней работать в контексте указателей.
>К var->i в мейне я обратиться могу, а к вот к var->i в "func" - нет, потому что в "func" var это указатель на указатель, в мейне же var - просто указатель.
Зделай в func из указателя на указатель просто указатель и сможешь обратиться.
Но в таком случае в func отправится локальная копия указателя, а не сам указатель. Разве нет?
Путаюсь очень, извини.
Именно это я и хотел услышать, спасибо.
Но мне все равно не понятно как именно нужно указатели в функции передавать.
Как я понимаю этот >>103990 код не работал из-за того, что я манипулировал с памятью непосредственно во вторичной функции "func". Если бы в мейне, сразу после объявления "int @p" я сделал "= malloc(sizeof(int));" и отправил в func уже инициализированный указатель, то все бы успешно ему присвоилось, потому что память эта выделена в мейне, в основной программе.
То есть, в принципе, можно обойтись без указателей на указатели - обычные указатели использовать. Но считается ли это хорошим стилем? Может лучше приучить себя использовать указатели на указатели везде, где этого требует подразумеваемая логика?
Указатели на указатели используются если в функции нужно выделить память. Такой стиль некоторые ругают и говорят, что пары malloc+free лучше держать на одном уровне в коде. Ну некоторым функции выделять память норм и много есть таких API. Я лично сильного мнения по этому вопросу не имею, не пишу на С особо. Почитай книжки по Сишечке, вполне возможно в каких-то этот вопрос обсуждается.
Ну и вот линк глянь: https://stackoverflow.com/questions/13442375/best-practice-for-allocating-memory-for-use-by-a-function-malloc-inside-or-out
Есть свои плюсы и минусы в обоих подходах. Например если функция выделяет память, то в main не надо знать размер данных заранее и т.п.
> То есть, в принципе, можно обойтись без указателей на указатели - обычные указатели использовать. Но считается ли это хорошим стилем?
При чём тут стиль? Это зависит от того, что тебе нужно. Если тебе надо, чтобы функция вернула указатель, то какие проблемы. Алсо, она может вернуть его через return, а не через аргументы, и тебе не надо передавать указатель на указатель.
Можно использовать оба подхода в одной функции. Если переданный указатель указывает на NULL, то память аллоцируется. Если не NULL, то не алллоцируется. Так getline() работает, например. https://linux.die.net/man/3/getline
Я знаю как она здесь устроена, видел исходные тексты.
Только что с собеседования, типа им нужен спецiалист со знанием C++11.
Ага, счас... начали с устройства энторнетов и эthернетов, дошли до вычислений на списках, и тут я им видимо понравился и они объявили, что «C++11» это типа замануха была. ЧИСТЫЙ СИ И ТОЛЬКО ОН и какие-то свои стандарты кодирования.
Ну, я с готовностью согласился.
устройства интернетов это сети и дальше? Кст поздравляю надеюсь работа понравится
Да, первый том Ричарда Стивенса и всё то, что уровнем выше.
Написал я
int max;
max = int(pow (2, sizeof(int)8)-1);
printf("max = %d\n", max);
Но при возведении двойки в восьмую степень идет переполнение типа на единицу. Соответственно, если даже потом делаю -1, все равно вижу мусор в результате. Возможно ли высчитать максимальное значение int, используя переменную signed int?
И еще, попробовал сделать через unsigned int, а именно:
unsigned int max;
max = unsigned int(pow (2, sizeof(int)8)-1);
printf("max = %d\n", max);
Казалось бы, простая задача в 3 строки, но при практическом выполнении возникают трудности
не знаю что ты там написал. пользуйся сдвигами да и всё. 1L<<31 | (1L<<31)-1L
>знаковый
а, или тогда я не правильно выдал. это у меня из каких-то макросов... я там ещё проверяю множественными сдвигами разрядность типов...
Я ошибся с первой частью. Так норм работает, переполнения нет.
int max;
max = int((pow(2, sizeof(int)8-1) - 1));
Однако, все же остался вопрос. Почему в таком коде получаю просто 0 в консоли?
unsigned int max;
max = unsigned int(pow(2, sizeof(int) 8));
С побитовыми сдвигами еще не разбирался. Понимаю, что принцип несложный, но даже сам оператор << вижу впервые.
Лол, спасибо. Так тоже прикольно. Не знал, что можно printf'ить тип.
Не компилится, потому что двач не отображает символ звездочки (умножение) в постах. Вот фул тогда https://pastebin.com/8Xht7fU4
> Не компилится, потому что двач не отображает символ звездочки (умножение) в постах.
Nope. Я спалил звёздочку. Не в ней была проблема.
https://pastebin.com/LUT7fzhw
Методом тыка обнаружил, что правильно преобразовать типы в Си надо так: (int)(a), а не int(a). Потому что в таком случае int(a) компилятор ожидает декларирования новой переменной, отсюда и ошибки.
Нет, серьезно. -117 в двоичную систему я перевести могу. Но что значит дополнительный код?
При записи числа в дополнительном коде старший разряд является знаковым.
сказать где я это нашел?
Ты не совсем прав.
Чтобы число записать в дополнительном коде надо все его биты инвертировать и прибавить единицу. Учите основы аноны, это важно.
вобщем почитал, вопрос снимается.
>Если указатель хранит адрес только на первый байт всего блока, то как тогда функция free() высвобождает всю выделенную память блока? Возьмем опять же такой код и добавим free
>int *p;
>int main () {
>p = malloc(40);
>free(p);
>p = NULL;
>return 0;
>}
>Как ф-ия free понимает, что ей нужно освободить 40 байт памяти, а не 1? Ведь p содержит адрес только на начало первого байта всего блока.
https://github.com/lattera/glibc/blob/master/malloc/malloc.c
слишком многа букаф, ниасилил
Тут чуваки поясняют за мультифайловое программирование (в главе 2.2). Их код у меня не компилится ибо файл с main'ом не видит функции, которые он вызывает. Я конечно мог бы объявить функции в том же файле с main'ом, а реализацию уже в другой, но почему у меня их код не работает? или он и не должен?
https://kt48.wordpress.com/2015/03/03/basic-tutorial-on-json-glib-for-tizen/
С файлом из гайда все парсится, а с моим не работает. Выдает
Json-CRITICAL : json_object_get_object_member: assertion 'JSON_NODE_HOLDS_OBJECT (node) || JSON_NODE_HOLDS_NULL (node)' failed
Что не так то?
Ну тебе же написали: ты вызываешь json_object_get_object_member() на том, что не является JSON-объектом (на массиве, например) или вообще пихаешь туда NULL.
Действительно там массив, только не пойму чо делать если внутрь массива напиханы объекты.
Разобрался.
Писал в школе проги на паскале, решил вкатиться в си, поставил code::blocks и mingw. Охуел с того, что нельзя запускать отладчик для файлов, только для проекта. Насколько понял, в проекте есть только один сурс(в котором, собсна, и находится единственная main), в который подключаются функции, описанные в куче хедеров.
Я правильно понял, или как? Мне что, каждое упражнение из K&R в отдельный хедер ну или в один писать функцией, а его в main.c подключать, а там инициализировать свои проги в виде функций? Или а каждую прогу уровня "подсчитайте строки" новый проект создавать? Что за бред?
Короче, разъясните дауну, шо це проект, и как с ним работать.
> Насколько понял, в проекте есть только один сурс
Ты неправильно понял. В проекте может быть сколько угодно исходников и сколько угодно хедеров. Но одна main(), да. В любом из этих исходников. Еще у проекта есть куча настроек (директории, ключи компилятору, подключаемые либы), поэтому многие IDE и хотят проект для компиляции.
> Мне что, каждое упражнение из K&R в отдельный хедер
В K&R большинство упражнений не требует нескольких файлов, поэтому и декларации можешь делать не в хедере, а вверху файла. Если тебе лениво создавать один проект на программу, можешь создавать каждый раз новый .c-файл, класть его в проект, а старый удалять из проекта (можешь придумать кучу вариций: ничего не удалять, а делать #if (EXERCISE==1) ... #endif вокруг функций упражнения, и, соответствено, где нибудь выше делать #define EXERCISE 1; можешь даже диспетчер упражнений наговнокодить, который будет вызывать exerciseN_main, можешь просто такие мелкие вещи компилять из командной строки).
char prefix = malloc(512);
пишет:
malloc(): memory corruption: 0x0000561162c24df0
Aborted
Да есть звездочка, это макаба сожрала.
на самом деле бесит это, все эти проекты, лишние файлы - сам когда-то ебался с кодблоксом. и естественно переход на емакс всё решил по итогу.
но теперь я не очень понимаю нахуя мейкфайлы, иногда сборка такая сложная, что проще шелл скрипт прописать. хотя я так и не изучил структуру мейкфайлов... просто набрасываю в одной опции строки с командами да и всё.
> просто набрасываю в одной опции строки с командами да и всё
Ну вот когда тебе заебется безусловно перекомпилировать все файлы в большом проекте при изменении какой-нибудь ни на что не влияющей константы, ты осилишь makefiles или cmake, гарантирую. А насчет мелочи соглашусь, проще сделать cc *.c и не думать.
> вылетает на строчке
> malloc
Смотреть, кто повредил кучу ДО этого вызова. Очень помогает gcc или clang с ключиком -fsanitize=address.
потому что он что, проверят тамстемпы перед компиляцией? что в принципе не мешает сделать на шелле, муторно, да. но дело же не в этом, не всегда сборка это создание файлов. например тесты, или когда тебе нужно что-то генерировать через свои же программы - тупо же хранить бинарники - то есть нужно если их нет, скомпилировать их, а потом заиспользовать.
может это и через мекфайл можно - не знаю, не вижу смысла, возможно пока.
Какая именно отладочная информация? Можно поточнее? И что подразумевается под флагами оптимизации?
А если серьезно?
давно я такой платины не видел
>Что пишут на си?
В СНГ почти ничего. Забудь о Си, как о языке, на котором ты будешь зарабатывать деньги.
Подскажите, как на шиндовсе компилировать программы, написанные с посторонними библиотеками?
В вижуал студии все тривиально было: добавляем .lib и .h в проект, .dll в папку проекта, профит.
Погуглил, написано с флагом -I/-L можно указывать путь к библиотеке, но ничего не работает:
- если не изменять библиотечные хедеры, ругается на <уголки> и просит "кавычки"
- Если поставить в библиотечных хедерах кавычки, то появляются "unresolved external symbol"-ы.
Как сделать правильно?
> Как сделать правильно?
Именно так, как ты описал. Должно работать. На пике пример: в C:\library лежат хедеры и сама либа libfoo. Если задать пути через -I и -L, то все компилируется, ни на какие кавычки не ругается. Если у тебя проблемы, добавь шлангу ключ -v и смотри, что конкретно идет не так.
Бля, наебался, в общем если #include с <угловыми скобками> все тоже норм, никаких предупреждений (да и откуда им взяться?).
стрелочки, зеленая где щас, красная некст степ, как за 1 сажек исчезло стока буковок, там же тока условие цикла
Там полноценный цикл с пустым телом (точку с запятой в конце видишь? - это тело).
ок, указатель по шагает вперед, пока не натыкается на массив1, какая строка после етого из массива2 вычетает массив1
Дословно повторил написанное тобою, получил:
C:\gsl>clang -Igsl -Lgsl gsl_sf_bessel.h
clang.exe: warning: argument unused during compilation: '-Lgsl' [-Wunused-command-line-argument]
gsl_sf_bessel.h:36:10: fatal error: 'gsl/gsl_mode.h' file not found
#include <gsl/gsl_mode.h>
Зато совет добавить ключик -v помог. Я догадался засунуть хедеры в одну из папок списка "#include <...> search starts here:" (думаю, решение оправдано, потенциально это очень важные хедеры и они будут использоваться в различных проектах не реже stdio).
Теперь возникает лишь ошибка линковщика, который не может найти .либ и .длл.
Я читал, что у переходящих с вижуал студии на консольные программы людей могут случаться ожоги ануса. Но даже не догадывался, что они будут столь болезненны.
> C:\gsl>clang -Igsl -Lgsl gsl_sf_bessel.h
Т.е., ты пытался в пути к инклудам добавить текущую папку? Тогда надо было -I. или -IC:/gsl (да, винда умеет в прямые слеши).
А я опять в глаза ебусь. В общем, смотри, у тебя либа хотела, чтобы ее инклудили как #include <gsl/whatever.h>, т.е., в пути к инклудам тебе нужно было добавить не текущую, а родительскую папку (допустим, C:/), тогда оно бы отлично открыло C:/gsl/gsl_mode.h.
Я так и сделал. Проблемы с хедерами решены, нужно линковщику рассказать про либ и длл.
А вообще, мне сказали, чтобы я не занимался этой ерундой, использовал интеловский компилятор и из дополнительных библиотек MKL и опенмп. Якобы лучше этого уже нет. Возможно, MKL в самом деле прекрасно оптимизирована, но библиотеки гну имеют гораздо более качественные мануалы и проще в использовании (сравниваю нелинейную оптимизацию в мкл и в пакете gnu nlopt).
Спасибо за помощь.
struct opa
{
int n;
};
а что-то типа
define struct
{
int n;
} opa;
ест без проблем. Сразу извиняюсь за разметку.
Это нормально. В Си, в отличие от крестов, имена (теги) структур и enum-ов не являются именами типов. Т.е.: struct opa { int foo; }; typedef double opa; вполне валидный код, после этого struct opa var1; создаст структуру, а opa var2; - переменную с плавающей точкой. А вот когда ты делаешь typedef (в том числе и typedef struct), ты создаешь именно имя для типа. Можешь совместить typedef и определение структуры (typedef struct opa { ... } opa ), тогда сможешь создавать переменные и через struct opa v1, и просто через opa v2;.
Понял, спасибо.
я не понял, почему у тебя gcc не съедает твоё определение структуры. Что ты вообще имеешь в виду под "не съедает"? Не компилится? Вроде всё валидно.
char s[] = { "str1", "str2"}; - то нужно обращаться через индекс, как к массиву.
Так вообще не собирается:
char s = { "test", "t"};
И почему тогда argv можно обявлять как argv и argv[]?
> И почему тогда argv можно обявлять как
Потому что массив в аргументах функции неявно преобразуется к указателю на первый элемент. У тебя не аргументы, поэтому разница есть. Можешь сделать так (C11): char ∗∗s = (char ∗[]) { "foo", "bar", "baz" }; или просто отдельно сделать массив и присвоить его отдельному указателю.
Это что-то вроде:
type items[count]; ?
Или иначе?
https://godbolt.org/g/ZVSUsh
У тебя код кстати не правильный - в ахптимизированной функции у тебя матрица умножается как column major, а во второй функции - как row major.
Угу, поправив косяк >>109183
и заменив Ofast на Os получил в итоге
https://godbolt.org/g/UhR5kD
1к1
Но все равно моя жопа продолжает полыхать, какого хера кококмпилятор с кококооптимизационными ключами -O2 и -O3 генерит какую то длинную хуету (вариант с -O3 вообще в 4 раза медленнее работает чем с интринсиками), а с ключом -Os оптимизирует, хотя по идее он должен говноассемблер генерить лишь бы был маленький.
>какого хера кококмпилятор с кококооптимизационными ключами -O2 и -O3 генерит какую то длинную хуету
Называется loop unrolling
> какого хера кококмпилятор с кококооптимизационными ключами -O2 и -O3 генерит какую то длинную хуету
Потому что пытается оптимизироваться, избавляясь от циклов и вызовов функций?
[code]#include <stdio.h>
#include <stdlib.h>
int main() {
int A = 0, Num = 312, i = 0;
srand(58);
Num = 0 + rand() %1000;
printf("enter num\r\n");
scanf("%d\n",&A);
for (;;) {
if (A > Num) {
printf("Your number is bigger then %d\r\n", Num);
}
if (A < Num){
printf("Your number is lesser then %d\r\n", Num);
}
if (A == Num){
printf("You win!");
return 0;
}
}
}[/code]
[code]#include <stdio.h>
#include <stdlib.h>
int main() {
int A = 0, Num = 312, i = 0;
srand(58);
Num = 0 + rand() %1000;
printf("enter num\r\n");
scanf("%d\n",&A);
for (;;) {
if (A > Num) {
printf("Your number is bigger then %d\r\n", Num);
}
if (A < Num){
printf("Your number is lesser then %d\r\n", Num);
}
if (A == Num){
printf("You win!");
return 0;
}
}
}[/code]
for (int i = 0; i < 5; i++) {
printf("%d\n", d);
}
На выводе получаю:
8
0
0
0
0
Разве весь массив не должен инициализироваться цифрой 8? Почему только первый элемент массива 8, а остальные нули?
#include <...> search starts here:
/usr/lib/gcc/x86_64-linux-gnu/6/include
/usr/local/include
/usr/lib/gcc/x86_64-linux-gnu/6/include-fixed
/usr/include/x86_64-linux-gnu
/usr/include
/usr/lib/gcc/x86_64-linux-gnu/6/include - здесь лежат .h файлы, но какие-то не те, которые я использую в своих хеллоуворлдах
/usr/local/include - пустая
/usr/lib/gcc/x86_64-linux-gnu/6/include-fixed - то же самое, что и /usr/lib/gcc/x86_64-linux-gnu/6/include
/usr/include/x86_64-linux-gnu - много заголовочных файлов, в том числе папка sys, файлы которой я использовал, когда изучал сокеты
/usr/include - тоже много заголовочных, судя по названиям, это стандартная библиотека
Везде заголовочные, но где реализация? Вот у меня установлена libc6 (гнушная реализация), с помощью dpkg -L, я нашёл её расположение, но там одни .so файлы, это и есть она? По названиям файлов я бы не сказал, что это она. Скачал сорсы на официальном сайте gnu.org/s/libc , там всё красиво и понятно - куча .c файлов, заходи, изучай, всё понятно.
Читал K&R, Прату. Всё равно плаваю в этих вопросах, для меня всякие библиотеки, которые я использую, - это магия. Знаю, что этим занимается линкер, и всё. Ситуацию усугубляет то, что в gnu/linux я новичок.
1) Где реализация, откуда линкер подтягивает реализацию стандартной библиотеки? Неужели это те .so файлы? Ну не похожие названия и всё!
2) Когда я пилил хеллоуворлд на сокетах, использовал заголовочные файлы из директории sys/. Это ведь не часть стандартной библиотеки. Я правильно нагуглил, что это C POSIX library?
Нет, не должен. Если ты хоть как-то инициализируешь составной объект (тот же массив или структуру), то те части, которым инициализаторов не хватило, заполняются нулями. Можешь об этом думать наоборот так: при инициализации объект сначала заполняется нулями, а потом в него втыкаются инициализированные значения. Это нормально и удобно. А если хочешь заполнить массив каким-то значением, отличным от нуля - заполняй в цикле.
>>109266
scanf() твоя проблема. Во-первых, перед началом матчинга числовых спецификаторов scanf() сам пропускает все пробельные (isspace()) символы. Во-вторых, когда scanf() видит ЛЮБОЙ пробельный символ (в том числе и \n) в форматной строке вне спецификатора (как у тебя), это заставляет его пропустить ВСЕ пробельные символы, начиная с текущей позиции ввода (вообще всё, что isspace()!) до тех пор, пока не найдется какой-то не-пробел.
Ты вводишь 10 и нажимаешь Enter: scanf() видит %d, читает 10, видит в форматной строке \n, начинает пропускать пробельные символы: \r (если у тебя винда), \n, дальше ты пока ничего не ввел, а не-пробел так и не найден. И scanf() ждет, пока ты введешь еще что-нибудь. Ты вводишь 20, scanf() видит не-пробел и возвращает прочитанную 10. Такие дела. Выкинь нахуй \n вообще, потому что см. выше "во-первых".
Спасибо. Заработало
Тебе нужны libc.a и/или libc.so. .a - это архивы объектных файлов (потыкай в них командой ar: ar t libc.a), они содержат уже скомпилированный код и используются для статической линковки - линкер ищет символы (имена внешних переменных и функций) в указанных тобой объектниках, а если там они не найдутся, ищет в либах. Если в одной из либ имя найдется, он берет из либы соответствующий .o и помещает его содержимое в программу. .so - это примерно то же самое, но это динамические библиотеки (shared object), они не вставляются в твою программу, а загружаются при ее загрузке. После этого происходит "позднее связывание" - точно так же в сошках ищутся символы, а ссылки из твоей программы на эти символы правятся так, чтобы они указывали на функции или переменные из сошки. Использование .so не почти не влияют на размер программы, зато позволяет авторам какого-нибудь дырявого openssl латать свой говнокод, не заставляя тебя перекомпилировать твою программу. Ну и память экономится за счет того, что программы не таскают в своем теле каждая свою копию либы, а либа просто грузится в память и совместно используется всеми зависящими от нее программами.
> Я правильно нагуглил, что это C POSIX library?
Функции, работающие с сокетами - обертки вокруг системных вызовов, и, насколько я помню, частью POSIX не являются. Но это все сорта одного говна.
> 1) Где реализация, откуда линкер подтягивает реализацию стандартной библиотеки? Неужели это те .so файлы? Ну не похожие названия и всё!
Натрави на свой скомпилированный бинарник ldd и он тебе популярно напишет с какими либами он слинкован.
> 2) Когда я пилил хеллоуворлд на сокетах, использовал заголовочные файлы из директории sys/. Это ведь не часть стандартной библиотеки. Я правильно нагуглил, что это C POSIX library?
Если ты говоришь о системных вызовах (секция под номером 2 в man'е), то они реализованы в ядре. Обёртки же системных вызовов всё равно реализованы в стандартной библиотеке.
>>109327
Спасибо вам большое! Стало гораздо понятнее всё. Открыл .so в mc - как раз там видно имена всех функций из стандартной либы.
Ещё один вопрос остался - если моя программа использует .so, то получается клиент тоже должен его иметь. Соответственно, мне к моей программе нужно приложить в том числе и все .so файлы на случай, если клиент скачает, скажем, её с моего сайта? А если её захотят залить в репозиторий, то мейнтейнер скорее всего выкинет этот .so и просто пропишет зависимость к пакету с этим .so (если он уже есть в репозитории, конечно)?
Да, на этот случай в линуксах есть пакетный менеджер. Распространять бинарные сборки тоже лучше в форме пакетов. Что же касается мейнтейнера, то он в любом случае будет собирать твою программу из исходников, поэтому пиши в ридми (или сразу в .configure, или в CMakeLists.txt, или чем ты там собираешь), что нужно для компиляции. Вот если будешь писать и под винду тоже, тогда да, придется положить соответствующие DLL в комплект бинарной сборки.
Я так понимаю это олимпиадка какая-то, нахуй взялся если не хочешь думать? Сам решай
В основном эмбед+иногда драйвера под линух. Но вообще нужно понимать, что си - это все же не для фриланса, потому что во втором десятилетии 21 века на нем (кроме поддержки легасни) пишут как правило связанное с железками/компоненты ядра/части бэкэндов всяких высоконагруженных хуевин, опять же связанных с прямым взаимодействием с ядром. И все это, как ты сам понимаешь, в основном связано с хлебной узкоспециализированной должностью "Ублажителя машин" и "Казановы байтов" в какой-либо конторе.
Так что си - это или случайно (чудом 2 раза подряд) найти вакансию/фрилансовый заказ на поддержку легасни (в отечественных реалиях - скорее всего это будет древнее говно мамонта под дос), либо подавать резюме в разные конторы, связанные с железками. Вакансий мало и как правило текучка там небольшая.
Ещё раз спасибо!
>связанное с железками/компоненты ядра/части бэкэндов всяких высоконагруженных хуевин
А десктопные приложение на Си - исключение? Вот GTK же на Си
Чому тогда в Гейропках си второй по популярности язык после жавы? Кругом ембедед и модули ядра?
Потому что я долбоеб и открыл первый попавшийся список. Прочитал описание -- под "популярностью" подразумевается число пограммистов, владеющих данной технологией.
example
this is me
Мне нужно считывать строки, начиная со второй, до конца файла.
Т.е. я написал цикл
while (!feof(in)) {
...
}
Вопрос: как мне заставить функцию feof игнорировать первую строку? Т.е. начинать проверку на конец файла сразу со второй строки и до конца файла. Я так понимаю, что нужно просто указатель in сдвинуть на начало второй строки. Как это можно сделать? Какие вообще есть решения?
P.S. Пока в голову пришло только то, что я должен считать длину первой строки и изменять указатель in на in+strlen(первая строка), или вроде того.
feof() так не работает. feof() позволяет лишь отличить ошибку от конца файла, когда какой-нибудь fgetc() и fgets() сфэйлится. После того, как оно сфэйлится, не до. Мжешь сделать так: https://ideone.com/76kW9W
Хорошо. Но в твоем куске кода, как я понял, символы перевода строк \n и символ EOF запишутся в buffer. Так ведь?
> Вопрос: как мне заставить функцию feof игнорировать первую строку?
Тебе обязательно для этого использовать feof? Что тебе мешает считать первую строку и самому проигнорировать её?
если я считываю первую строку через fscanf(in, "%s", str), то указатель in смещается на '\n'? И смещается глобально для всех функций? То есть, если я потом напишу fgets(str2, 100, in), то в str 2 поместится символ '\n'?
Если буду считывать через fgets(str, 100, in), то в str запишется "корова\n". То есть, помимо самого слова, запишется еще и символ перехода на строку. А мне нужно чистое слово. Удалять '\n' потом через str[strlen(str)] = '\0'? Немного костыльно.
Потому, что чистый!
>>Удалять '\n' потом через str[strlen(str)] = '\0'
Удалять '\n' потом через str[strlen(str)-1] = '\0'
быстрофикс
Не считывай строки через scanf(). У scanf() ебнутая логика, и ты обязательно напорешься на какую-нибудь херню. Например, если ты просто >>109737 делаешь scanf(%s), то ты считаешь не строку, а слово, похеришь последовательности пробелов, пустые строки и тому подобные вещи. Не выделывайся, используй fgets и обрезай с конца пробелы. Например, простой фукнцией вида: ptr = string + strlen(s) - 1; while (ptr > string && (ptr[0] == '\r' || ptr[0] == '\n')) { --ptr; } ptr[0] = '\0';
Хорошо, понял. Спасибо всем, кто отписал, я разобрался
EOF - не символ, а специальное значение-индикатор, которое специально сделали вне диапазона символов. getchar() может возвращать EOF, но это не char, а (int) -1, т.е., 0xffffffff на 32-битных машинах. fgets() вообще возвращает указатель, а не символ, и уж конечно не пишет никаких EOF в buffer - если в потоке остались символы, она запишет в буфер эти символы, а если не остались - вернет NULL.
Не путай сишный EOF с DOS-овым символом с кодом 26 (0x1a). Под виндой или досом сишную либу приучили считать символ EOF индикатором конца потока, если поток в текстовом режиме, но в строку он не попадает.
https://technet.microsoft.com/ru-ru/library/bb896653.aspx
https://technet.microsoft.com/ru-ru/library/bb896645.aspx
через эти смотри, а не через mmc.
Подскажите, есть какие-то либы для GNU/Linux, которые бы позволяли мониторить/управлять демонами/сервисами? Может есть какой-то слой, который позволяет управлять демонами/сервисами?
Сейчас колхожу через системные вызовы с последующим парсингом. В гугле забанили. Благодарю заранее.
libsystemd? Ессно, если systmed юзается. Я, правда, её ни разу не использовал, не знаю, предоставляет ли она возможность мониторинга/контроля сервисов.
fgets() сама по себе костыльна. Хорошо, что в POSIX есть божественный getline().
Если твоя система работает на systemd, что очень вероятно, то работаешь с ним по протоколу DBus через systemd-шную же библиотеку sd-bus. Сделать через нее можно абсолютно все. Проблема одна: dbus сам по себе угребищен и требует перестройки мозга, и если вдруг тебе попадется функция с динамическими параметрами (variadic), ты просто рехнешься их рекурсивно парсить километровыми свитчами. Причем в коде systemd все именно так.
У меня был такой опыт, только с плюсовой оберткой поверх sd-bus, так с позиции послезнания я бы сделал работу с systemd через dbus на скриптовом языке типа lua.
> Причем в коде systemd все именно так.
код шиштемд это вообще какой-то тихий ужас, на первый взгляд, по крайней мере
нет, с чего ты взял
тот, который пишу я, очевидно же
Ты говоришь о том, что все объявленные функции надо обязательно вызывать в main? Как ты пришёл к такому выводу? Если ты не знал, то функции можно вызывать из любых других функций, не только из main.
Потому что VOID!
Перейти к следующему заданию. В кеижках бывают опечатки. Листинг может быть не полный в тексте может приводилось что надо было самому написать, чтобы заработал пример
Что значит "не происходит нихуя"? конкретизируй проблему.
Не используй функции с суффиксом _s. Не используй их, сука или поставь Visual Studio, там они есть.
> strcpy не робит
С чего бы вдруг? Тебе нужно ограничение по размеру? Сделай snprintf(dest, dest_length, "%s", src).
И давно у нас в glibc реализован C11/Annex K?
string.h подключено
Стенли Липпман и даже не думай начинать с кого-то ещё! Он даёт одиннадцатые плюсы сразу же, защищённые указатели, списки и хеш-таблицы (это всё спрашивают на собеседованиях сейчас).
> одиннадцатые плюсы
Какой год на дворе, видел? А вообще, вам в крестотред >>1110566 (OP) || >>1099142 (OP)
Ты дебил? Спросили про кресты, а не про Си, кресты 11 учить не имеет смысла.
abc
То перестановки:
abc
acb
bac
bca
cab
cba
То есть, что думаете по поводу реализации перестановок? Может я странный, но я не вижу почти никакой логики в перестановке эелементов. Вернее, я не вижу способа воспроизвести алгоритм перестановки. Программу написать не проблема. Но хотелось бы понять, какой у перестановки алгоритм, чтобо делать это даже на обычном листочке с ручкой
Пиздец, я миллион ошибок в тексте сделал, у меня 6 утра, сорян
не, хуйня, каждый символ двигается влево
Вот решил вкатиться в сишечку и уже дошёл до указателей на функции. Чё посоветуешь почитать? Желательно такое, что бы много примеров с хорошими комментами. Хочу раскурить эту тему так, что бы аж торкнуло.
А почему не в прикрепленный тренд?
Рекурсией:
1. Перестановку из одноэлементного множества как-нибудь придумаешь.
2. Предположим, что мы получили все перестановки множества из (n-1) элемента. Тогда для получения всех перестановок из n элементов мы должны для каждого элемента зафиксировать его на первом месте, а потом дописать к нему все возможные перестановки длинной (n-1)
Литература в шапке.
Как осилишь, попробуй запилить численное интегрирование либо решатель оду 1 порядка (Рунге-Кутта, например). В обоих случаях придется передавать функцию по ссылке.
А что скажешь про это?
learnc.info
Нуб не испортит вкус и стиль после изучения этих материалов?
>если объявляем указатель на указатель char , то сколько памяти нужно выделить под первый указатель?
char huitka = malloc(sizeof(char)quantity);
массив указателей
Почему?
мощь
внезапно, во все что в линуксе относится к программному обеспечению "домашних" обычных пользователей
у проектов кед, гнома, крысы сотни программ, не требующих особых знаний в системном программировании, но написанных на си и требующих поддержки и доработок
бля, чел ты учишся в охуенном месте, а курс по сишке один из самых важных для кодера на первых курсах..
и не хочешь делать сам..
а я понял. но главная это что, лев-верх - низ-прав? а что такое диагональная матрица?
Я думаю, очепятка. Имелось в виду "квадратная"
И, да, лив-верх-низ-прав. На главной диагонали индексы у элементов повторяются: a11, a22, ..., ann
а ну ясно.
блин, мож пойти старый журнал хакер пролистать, я недавно смотрел, там есть задачки по C. в основном за безопасность, и ведущий колонки сам не умеет писать на C, но забавно.
может запостить вам сюда парочку.
Ты мне скажи, как мне Pi вычислить.
Пилить длинную арифметику я не буду, ибо придётся пилить "высоко" её, я низко ниасилю. Время впустую.
Соответсна, мне нужны алгоритмы, которые находят n-ую цифру числа Pi, не находя предыдущих.
Просто по цифре находить и выписывать.
Так и pthreads легко накрутить.
Сказано найти 10^ цифр - делишь на 4 потока, и каждый поток ищет и в файл с оффсетом записывает.
Из подходящих алгоритмов пока нашёл только формуллу Беллара. Но тут я встал в ступор, ибо она
>позволяет вычислить n-й разряд числа пи в двоичном представлении.
> в двоичном представлении
> двоичном
> 10000101111 00100000 10000110010 00100000 10001000001 10001000010 10001000011 10000111111 10000111110 10001000000 10000110101 00001010
https://pastebin.com/xRpeYXfK
>>111200
никогда об этом не думал. а арифметику я написал.
в сымсле на асемблеере? так тоже писал, но забил - деление меня одолело. написал нормально, смотрел выхлоп - не удовлетворился... потом начал считать в калькуляторе, то что я собрался считать этим, в итоге забухал и забил на всё.
>потом начал считать в калькуляторе
в смысле, перспективы огорчили - много получилось. потом понял что не правильно считаю комбинации, а как считать правильно - это нужно читать умные книги.
нахуй тебе его вычислять, наркоман бипедальный? берешь файл с вычисленным числом и все.
и ты будешь постоянно вычислять пи вместо того, что бы брать из памяти уже вычисленный? оптимизация уровня /po
без разницы
Ну так:
> Why didn't you use a GPU (Graphics Processing Unit) ?
> The Pi computation algorithm I used is I/O bound, so the extra processing power of the GPU would not help much. What really matters is the speed of the hard disks. The question would be different if the computation could be done in RAM, but it is currently too expensive, at least for me !
падажди, Pi это нормальное Пи которое уже вычислили до 2,7 трлн знаков после запятой, или это какое то пидерскоблокчайновское Пи?
Нормальное
Так мне 6060 дней считать, так что всё нормально
Щас бы в говно правки делать. Пример хорошего проекта на си это пэхапе.
>Write your program from the top down
>Recall that you’re assuming your program will be read by someone. It makes logical sense for themain functions to appear first and support functions to appear later. A programmer can easily get to the core algorithm and read on further if necessary to get the details. The opposite method (and one generally encouraged by the Pascal school) forces the programmer to have to wade through the details firstt.
Дальнейших пояснений не приводится. Поясните, пожалуйста, что тут имеется в виду.
Это классические СОВЕТЫ НОВИЧКУ - любительские, авторские методики улучшения качества кода, как правило хуевые. Игнорируй.
Есть два подхода к говнокодингу: от общего к частному или наоборот. В первом случае ты городишь архитектуру, и потом реализуешь все более мелкие части. Во втором - пишешь сначала те части, которые выполняют реальную работу, а потом склеиваешь их до тех пор, пока не получится программа. Ни один из подходов не лучше другого (начнешь с архитектуры - поймешь, что архитектура была говном, когда увидишь количество костылей в реализации, а начнешь с реализации - получишь линукс кое-как работающее, склеенное соплями говно). В обоих случаях программе нужна минимум одна итерация рефакторинга. И лучше сразу осознать, это нормально.
Ну вот в остальном и читай. А это потом сам поймешь, в чем неправильно.
А по рефакторингу что почитать можно?
Не поймите неправильно, просто надоело писать говнокод.
Почитай хорошо написанные исходники.
Тебе по рефакторингу или по написанию качественного кода?
Ну это... компилируешь с -ggdb, говоришь gdb programname, run, оно тебе показывает строчку, на которой вылетело. А уж почему конкретно падает - разбираться тебе (info stack и select frame N, info locals и info args, print arrayname[1] * 2 + 3 и т. д.).
Разыменовывай указатель. Сссылки и стековые переменные не разыменовываются.
Второй момент - к членам структуры по не разыменованному указателю - через стрелку, но к разыменованному - через точку.
Третий момент, следи за приоритетом операторов, распечатай табличку и приклей к системнику.
Ставь скобки, чтобы сделать приоритет операторов таким, какой тебе нужен.
Не забывай явно приводить типы, и помни о жопоболи от подобной хуйни.
Можно комбинировать - первый проход делать на этапе проектирования и придумывания алгоритмов и типов данных (например в голове или в тетради), а затем хуячить второй этап, покрывая каждую итерацию тестами.
Си хорощ тем, потому что сразу ставит вопрос, "а что ты сука именно хочешь сделать". В этом плане ООП развращает, потому что провоцирует выключать мозг и писать на автопилоте шаблоны абстракций генераторов абстракций, часть из которых на выходе пойдет на удаление, часть на рефакторинг, а часть выродится в ебанутую архитектуру, которая потом попорти нервов. Си же напротив - вот тебе функции, вот тебе твои типы данных, инкапсуляция на уровне систем и слова static. Вот чего реально не хватает - так это перегрузки функций и операторов для структур. Был бы тогда вообще идеальный язык
> Вот чего реально не хватает - так это перегрузки функций и операторов для структур.
На самом деле нет. В Хаскелле тоже нет перегрузок функций - и ничего, живем. А вот динамического полиморфизма в C нет, это да.
#include <stdio.h>
#include <string.h>
int main() {
FILE "звездочка"in = fopen("input.txt", "r");
FILE "звездочка"out = fopen("output.txt", "w");
char a[100];
fread(a, 1, 100, in);
printf("length = %u\n", strlen(a));
fclose(in);
fclose(out);
return 0;
}
В файле in находится слово:
example
Запускаю программу. Получаю length = 7. (как и должно быть) Но иногда при запуске получаю length = 9. То почти каждый запуск программы дает разный результат: 7 или 9. Почему происходит такое неопределенное поведение? Откуда он берет еще 2 лишних символа?
тебе fread возвращает кол-во считанных итемов, зачем strlen?
А в массиве у тебя помимо example куча мусора, там вообще может что угодно выдать, ибо strlen работает до \0
А, понял, fread значит не добавляет автоматически нуль-терминатор в массив. Отсюда и разные результаты strlen'ом.
А если в файле есть такой текст:
random
example
На самом деле, он выглядит так:
random\n\0
exampleEOF
или вот так:
random\0\n
exampleEOF
В файле может быть что угодно. Напишешь нули - будут нули. Собственно, в каких-нибудь объектных файлах таблица имен хранится как foo\0bar\0baz\0\0 для удобства парсинга сями.
Хорошо, спасибо.
#define TYPE int
#include "implementation.h" // Реализация использует TYPE вместо типа.
#undef TYPE
А также генерация кода макросами:
#define MAKE_FUNC(T) bool read_##T(T *dest) { ... }
MAKE_FUNC(uint32_t)
MAKE_FUNC(char)
MAKE_FUNC(uint32_t)
#undef MAKE_FUNC
А также _Generic в C11 для матчинга типов.
stroka=stroka.Replace("\r\n", "\n");
Написал программу, а мне все испортила ебучая винда, которая, как оказалось, ставит не просто \n при переводе строки, а еще и предварительно \r. Теперь, чтобы не переписывать программу из-за такого замечательного нюанса, думаю просто заменить все \r\n на \n. Как это сделать максимально быстро? И как сделать вообще? Текстовый файл весит 140Мб.
Ну это же программа уровня хелловорлда.
FILE ∗fpin = fopen("input.txt", "rb"),∗fpout = fopen("output.txt", "wb");
for (int c; (c = fgetc(fpin)) != EOF; ) if (c != '\r') fputc(c, fpout);
fclose(fpin); fclose(fpout);
Обработку ошибок сам. Если будешь читать не посимвольно, а кусками побольше, то будет заметно быстрее. Впрочем, на один раз и так пойдет.
В смысле кусками побольше? Мне в любом случае нужно либо символьно прогонять. Если кусками брать, то разницы не будет - все равно циклом каждый символ проверять
Я бы рад sed'ом все сделать. Но это нужно реализовать в самой программе. Есть идеи еще? В крестах же есть способ
> все равно циклом каждый символ проверять
Один fread и один fwrite + цикл vs. много fgetc/fputc + цикл. Первое заметно быстрее хотя бы из-за отсутствия контроля ошибок и накладных расходов на вызов функций (и тех функций, которые fgetc/fputc вызывают внутри себя).
>>112966
Так если у тебя не готовый файл, а именно программа, которая его генерирует, ты это... добавь "b" в fopen, и на винде не будет специального поведения для \n и \x2a.
У меня именно готовый файл. Но в самой программе хотел заменить в этом готовом файле \r\n на \n, чтобы программа работала так, как задумывалось. Вариант с fread'ом fwrite'ом все-таки не подойдет. Для текстовика 140Мб займет лишние несколько секунд.
pcre библиотека тебе в помощь, либо читай файл построчно и вырезай символ перевода каретки.
Ты посоветуй flex ему сразу, чего мелочиться? А может, фреймворк какой есть? Убрать \r - это же так сложно!
>>1112990 (OP)
>>1112990 (OP)
>>1112990 (OP)
>>1112990 (OP)
Уважаемый жабоеб, да будет тебе известно, что FILE в Си по умолчанию уже буферизированный. У нас тут разговоры о том, что чтение из буфера посимвольно может быть медленнее, чем чтение поблочно. Тебе про накладные расходы на вызов функций не понять, у тебя весь язык - сплошные накладные расходы на все.
Да. Например, в glibc fgetc сводится к блокировкам и потом к чтению из буфера в _IO_getc_unlocked:
https://github.com/lattera/glibc/blob/a2f34833b1042d5d8eeb263b4cf4caaea138c4ad/libio/libio.h#L413
У Microsoft аналогично. Да, буферизацию можно отключить через setvbuf, но по умолчанию для файлов она есть.
Да, был не прав, спутал с read(), лет 10 прошло с тех пор, когда спускался так низко.
Вы видите копию треда, сохраненную 30 января 2018 года.
Скачать тред: только с превью, с превью и прикрепленными файлами.
Второй вариант может долго скачиваться. Файлы будут только в живых или недавно утонувших тредах. Подробнее
Если вам полезен архив М.Двача, пожертвуйте на оплату сервера.