Почему язык Си такой классный?
А как вообще программировать на С и при этом не косячить, если компилятор проглатывает практически любой код, даже такой, который очевидно ошибочен?
Осторожно.
Как программировать на <любой язык нейм>, если компилятор проглатывает умножение на -2 там, где нужно было прибавить 3? Это же очевидная ошибка!
> .cpp
Во-первых, ты ошибся тредом. Во-вторых, тебе чистейшим английским языком написали, что в этих ваших крестах указатель на воид не кастуется в другие указатели автоматом (а в Си кастуется). Поэтому:
1) Не юзай маллок, у вас там завезли всякие векторы или new на худой конец.
2) Если уж юзаешь маллок, влепи каст к (char *).
Сичиач, разьясни мне зачем кармак запилил два отдельных аллокатора и чем hunk лучше чем zone?
https://github.com/id-Software/Quake-III-Arena/blob/master/code/qcommon/common.c#L1193
https://github.com/id-Software/Quake-III-Arena/blob/master/code/qcommon/common.c#L1193
>2) Если уж юзаешь маллок, влепи каст к (char *).
что енто значит? ет не плюсы, просто на сайте почему-то cpp не обращай внимание
значит переменная не в начале блока объявлена и это < c99
А почему sprintf сводит в ноль значение в переменной?
char a[2];
int b = 10;
sprintf(a, "%d", b);
printf("%d\n", b); // 0
Нахуй так делать? Может я где-то ошибаюсь?
Если заслать ему const, то всё нормально кстати. Но для меня это не решение.
char a[2];
int b = 10;
sprintf(a, "%d", b);
printf("%d\n", b); // 0
Нахуй так делать? Может я где-то ошибаюсь?
Если заслать ему const, то всё нормально кстати. Но для меня это не решение.
прост)
как же ты заебал, даун.
> прост)
Ещё и даунами кого-то называет.
Разобрался. Если объявить "b" перед "a", то будет ноль. Причём на ideone и в таком случае всё нормально, а вот у меня на комплюхтере не нормально.
clang 3.8.1-24
что, тож даун, очевидно что в младший байт его числа записался завершающий \0. компилируйте уже через gcc, там хоть чаще падать будет из за защиты стека.
хотя, это наверно от системы зависит... но я помню читал, на винде что-то же было подобное, может в vc.
Вот ведь вам делать же нечего, дорогие С-разработчики. Для вас даже создание строки на хипе - это уже проблема, в то время как все остальные об этом даже не задумываются. Вы хоть сами понимаете, как низко вы пали, со своим устаревшим на десятки лет языком программирования?
> хотя, это наверно от системы зависит... но я помню читал, на винде что-то же было подобное, может в vc.
Довен, у тебя массив утек, sprintf записал в a[2] терминирующий ноль следом за двумя цифрами, компилятор в стеке разместил b следом за массивом. И терминирующий ноль у тебя записался в b.
>хотя, это наверно от системы зависит
Да, довен, зависит. От endiannes процессора. На штеудах байты идут в памяти от младшего к старшему, на коком-нибудь PowerPC ты бы долго думал что у тебя все в порядке.
>Для вас даже создание строки на хипе - это уже проблема
Для тебя, довен, это действительно проблема.
> в то время как все остальные об этом даже не задумываются
Ога, core i7 с 64гб памяти будет достаточно каждому для запуска калькулятора, как же, слышали-слышали.
> Вы хоть сами понимаете, как низко вы пали, со своим устаревшим на десятки лет языком программирования?
шел бы ты отсюда, скриптушок. У нас тут эффективные программы, бекэнды, операционные системы и прочие высокоэффективные вещи пишут. Со своими дружками-скриптушками в другой тред иди пердолиться.
Hunk - это чтобы такой выделять-выделять, а затем прибить все разом. Для больших данных - карта там текстурки, модельки.
Zone - такой обычный велосипедный malloc повер большого куска уже выделенной при запуске памяти. Для всякой текучки. Я не понимаю чего там непонятного, по твоей ссылке там все очевидно на уровне хеллоуворлда.
тут даже читать не умеют. нахуй ты мне это всё написал - загадка истории.
> компилятор в стеке разместил b следом за массивом. И терминирующий ноль у тебя записался в b.
Да кстати, разумно, так оно и было.
-кун
> прост
> даун
> довен
Но это конечно совсем пиздец. Мочан во всей красе.
В этом и челлендж, руки и мозги должны быть, кто хочет просто писать говно для заработка бабосиков и думать, что он крут и 300к в секунду цель его жизни, то пусть топает в иные языки ну или просто в жопу.
> А как вообще программировать на С и при этом не косячить, если компилятор проглатывает практически любой код, даже такой, который очевидно ошибочен?
Сорцы линух кернела почитай, ну или там кваки iii кою тут вывесили.
посоветуйте что нибудь написать на си , знаю глупая просьба, но я сам учусь и по книгам надоело хочу написать что свое что, но знаю что, а то из-за соло обучения скоро депрессия сожрет
арифметику безграничной длины. сложение, вычитание, деление, умножение - соответственно и сдвиги.
Окей, если ты хочешь кодить на плюсах, как на Си по давно протухшим статьям, посмотри внимательно на свой же скриншот, тебе там компилятор волшебный ключик подсказал в скобочках.
Я только начинающий и столкнулся с проблемой, суть её представлена на скриншоте. Как видно, в результате нескольких арифметических операций число теряет своё значение. Я ожидал что уже после первого умножения число станет равным 122.000060. Та же проблема наблюдаются и при преобразовании типов.
Каким образом можно решить данную проблему? Использование только целочисленной арифметики, написание специальных функций или существуют особые ключи для компилятора?
Каким образом можно решить данную проблему? Использование только целочисленной арифметики, написание специальных функций или существуют особые ключи для компилятора?
> Каким образом можно решить данную проблему?
Округлять, менять методы вычисления, использовать типы с большей мантиссой (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.
Хочу реализовать уже наконец длинную арифметику на C.
В интернете встречал два подхода:
1. Лезть в байты, арифметические функции с нуля, так сказать, даже "+" нинужны.
2. Реализация, которая базируется на стандартных "+", "*".
Имеет ли смысл лезть в (1)? Или на (2) готовые функции на ассемблере всё равно опередят?
Если захочу в (1), то "Алгоритмические трюки для программистов" - то, что надо?
В интернете встречал два подхода:
1. Лезть в байты, арифметические функции с нуля, так сказать, даже "+" нинужны.
2. Реализация, которая базируется на стандартных "+", "*".
Имеет ли смысл лезть в (1)? Или на (2) готовые функции на ассемблере всё равно опередят?
Если захочу в (1), то "Алгоритмические трюки для программистов" - то, что надо?
> арифметические функции с нуля
Лолшто? Ты хочешь реализовывать побитовую арифметику софтом на ксорах и вручную перенос в каждый бит добавлять? Какой в этом практический смысл?
> Реализация, которая базируется на стандартных "+", "*".
Есть стандартный стул: берешь stdint.h, берешь какой-нибудь uint, работаешь, соответственно, со словами. Слова хранишь в массивах, little endian (слова, а не байты одного слова!), бегаешь по этим массивам быстро и комфортно.
А как я могу, допустим, поксорить элемент произвольной длины, если у меня есть указатель на него и его размер?
Алсо, есть что противопоставить NumPy в плане визуализации результатов экспериментов (графики, диаграммы)? Такая же удобность, конечно, не нужна, но чтобы хотя бы была возможность на экран вывести.
Он спрашивал длинную арифметику, это где флаг переполнения проверяют. Carry Flag то есть.
3. Запилить арифметику на BCD.
П.2 ты не сделаешь по причине отсутсвия доступа к флагам переполнения на чистых сях. Изи делается на ассемблере.
>П.2 ты не сделаешь по причине отсутсвия доступа к флагам переполнения на чистых сях.
Это не так. Как минимум можно просто считать старший разряд битом переноса.
>это где флаг переполнения проверяют
Нет, так поступают только говномесы. Использование флага C и инструкций adc не позволяет использовать векторные операции над массивом данных, которые выполняются мгновенно. Поэтому в одном разряде числа хранятся числа в таком диапазоне, чтобы переполнение не возникало. При этом флаг C не используется вообще, и число дробится на увеличенное число Chunk'ов (увеличено за счет уменьшения диапазона значений разрядов).
Иначе говоря, если число дробится на chunk'и по одному байту, то в этом байте используется не весь диапазон, а только 5 битов. При таком подходе переполнение не возникает вообще, и операция adc не нужна. Проблема здесь в том, что векторные операции отбрасывают флаг C.
А ещё я сосу хуи.
Ты, может, и сосешь, а я предпочитаю тянок.
А ведь, если подумать, я и сам непрочь соснуть хуйца. Такого сочного, жилистого, горячего.
Анонимус
Анонимус
> как я могу, допустим, поксорить
С чем поксорить? С другим подобным? Просто ксоришь побайтово или пословно, пока один из массивов не кончится.
Я про длинную арифметику и отвечал. Просто я так понял, он хочет по битам считать, и проверять флаг каждый бит. А можно по словам считать, и переполнением заниматься каждое слово.
А что в этом приятного?
напомните как инициализировать переменную как int и одновременно как char
union foo
{
int foo_int;
char foo_char;
}
И это твой тип новый.
спасибо
Мимо напомнило. Пилил руками транслятор, над каждой функцией в комментариях ставил соответсвующее правило на манер Exp = Term {('+' | '-') Term. В одном месте забыл про //, и нихуя сожрал всё, только много странных предупреждений выдал.
бамп
Очевидно, обмазываться разными инструментами, которые призваны облегчить жизнь C/C++ разработчика.
valgrind, clang-analyzer, pvs studio - вот это все
Есть ли разница между static и static inline функциями?
есть, первая ссылка в гугле: https://www.greenend.org.uk/rjk/tech/inline.html
Недавно наткнулся на волшебную тулзу - Process Hacker. Трейсит практически все что можно на венде, поэтому я узнал про такую штуку как сервисы типа драйверов.
Судя по всему именно сюда прописыват себя вся первоклассная малварь (на этапе работы), ибо найти эти сервисы можно только в реестре, либо с помощью той же тулзы.
У рихтера почти ничего нет про это, мс предлагает качать последнюю WDK и идти по туториалам.
Может тут сможет кто подсказать где искать материал?
писал только обычный сервис на крестах
Судя по всему именно сюда прописыват себя вся первоклассная малварь (на этапе работы), ибо найти эти сервисы можно только в реестре, либо с помощью той же тулзы.
У рихтера почти ничего нет про это, мс предлагает качать последнюю WDK и идти по туториалам.
Может тут сможет кто подсказать где искать материал?
писал только обычный сервис на крестах
>Недавно наткнулся на волшебную тулзу - Process Hacker. Трейсит практически все что можно на венде, поэтому я узнал про такую штуку как сервисы типа драйверов.
в сервисах не показывается?
Нет, в services.msc показывает только выделенное.
есть какая-нибудь вики/референс мануал с поиском, чтобы удобно было листать прямо во время кодинга?
Поступило предложение на вакансию в сбере, требуют знание чистого С, и С++ вдобавок. Но как я понимаю от С++ там только малая часть в основном это С с классами, что меня очень устраивает, и сразу говорит о высоком уровне разработчиков.
Кто в теме вообще по этой вакансии, там я как понял щас идет массовый набор?
Кто в теме вообще по этой вакансии, там я как понял щас идет массовый набор?
очевидный cppreference.com
Где можно достать тулчейн с компилятором gcc version 4.2.0 20070413 (prerelease) (CodeSourcery 2007q1-21. Marvell GCC-4.2.0 201111.12345)) для сборки ядра линукс 3.0.0 под ARM?
const int a = 1;
const int b = a * 2;
clang на маке компилирует, а msvc на вниде или gcc (4.8.4) на убунте ругаются на
>initializer element is not constant
Собственно, с какого перепугу он не константа-то? Как починить? static дела не меняет.
И ещё относительно связанный вопрос: как можно во время компиляции записать в константу результат (чистой) функции? Квадратный корень числа получить надо, поэтому вручную все действия расписай (через макро, например) не особо получится.
const int b = a * 2;
clang на маке компилирует, а msvc на вниде или gcc (4.8.4) на убунте ругаются на
>initializer element is not constant
Собственно, с какого перепугу он не константа-то? Как починить? static дела не меняет.
И ещё относительно связанный вопрос: как можно во время компиляции записать в константу результат (чистой) функции? Квадратный корень числа получить надо, поэтому вручную все действия расписай (через макро, например) не особо получится.
Попробуй повыставлять разные стандарты и расширения в компиляторах.
>с какого перепугу он не константа-то
Это лишнее, погуглил уже.
Короче говоря, могу я как-то произвести вычисления некоторые во время компиляции для статичных констант?
Попробуй constexpr.
Да я уже нашёл, что я не так понимал слово "constant" в ошибке, там именно constant expression нужен, стандарты/расширения не помогут, это clang "особенный".
А мы же, вроде, в си-треде, а не плюсах?
Точняк лол. Тогда макросы.
>Какой-то ебанутый вопрос.
Мы занимаемся реверсом прошивки. Модули ядра написаны под kernel 3.0.0, собранного под ARM.
И нам нужно собрать ядро версии 3.0.0 под ARM, чтобы запихать его и модули ядра в отлачик и по стеку вызовов определить, откуда вызывается очень интересная для нас функция и что в нее передается.
Ясно, т.е. вам нужно чтобы ABI той же версии было. Хуй знает, а эти CodeSourcery не дают доступ к исходникам своей бадяги? Можно было бы нужную версию скомпилировать.
> Может тут сможет кто подсказать где искать материал?
Zeal
Констант в Си почти нет. const задает тип доступа в рантайме, а не то, что принято считать константой в других языках (собственно, тебе и ругается, что ты инициализируешь одну переменную значением другой переменной, а инициализировать можно только константным выражением). Если не можешь что-то вычислить простой арифметикой в макросе - используй кодогенерацию или C++. На самом деле, любой уважающий себя компилятор и сам отлично свернет sqrt(константа) в вычисленное значение на этапе компиляции, но полагаться на это без проверки не стоит.
Да возьмите обычный ARM-ассемблер какой-нибудь fasm, точнее fasmarm умеет ассемблировать "поверх" файла, хукните свою интересную функцию прямо в бинарнике, сдампите обычным printk параметры и LR. Дел - на 20 минут, и никакой возни со сборкой.
Почему ебучий кланг прпоускает этот код тогда? (который const int b = a * 2;)
Потому что расширения. Можешь считать, что это баг.
Но даже с -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.
Они там что, охуели?
However, Clang is more strict than other popular compilers, and may reject incorrect code that other compilers allow.
Они там что, охуели?
А именно, у нас есть модуль supplies.ko с очень интересной функцией, которая получает данные, в формате которых нужно разобраться. Сейчас известно немногое: например, поля в дампе, где содержится чек-сумма. Мы хотим раскрутить эту функцию, чтобы узнать назначение всех полей в данных. Пока мы договорились до возможности все это дело проэмулировать, но для этого надо собрать ядро.
> Можешь описать подробнее?
Ну, если у тебя есть рабочая прошивка и железка:
Читаешь любую статью по хукам в Windows (их овердохуя). Делаешь то же самое в прошивке: ищешь пустое место (длинный ненужный текст, неиспользуемую функцию, можно даже "ненужную" функцию, их дохуя в ядре - втыкаешь возврат в начало, остальные байты твои) - будешь там хранить свой код. Воруешь из интересующей тебя функции несколько инструкций, на их место втыкаешь безусловный переход на свой код, твой код дампит все, что тебя интересует, под конец выполняет украденные инструкции и возвращается на следующую после украденной. Возможны варианты.
Пикрелейтед - подобный хук, дампивший RSA-ключи из одной софтины под WinCE прямо во время инициализации библиотеки, работающей с длинными числами. Вместо того, чтобы долго и мучительно искать два десятка ключей в каждой новой версии покриптованного бинарника, мы патчили программу по сигнатурам, и ключи самостоятельно укладывались штабелями в txt-файл рядом с ней.
Блин, не увидел сообщения. Ну у вас немного не тот случай, да. Можно заняться инструментированием по-крупному (не вручную). Правда, тут уже может оказаться быстрее собрать ядро.
>2017
>не использовать дефайны для регистров
Какие именно дефайны и зачем они в коде, написанном на скорую руку? Там даже GetProcAddress на каждый вызов заново делается, потому что возиться было лень. Алсо, это совсем не 2017, а скорее где-то 2009.
Открываешь такой через неделю код
@
Не понимаешь что там происходит
@
Удаляешь все нахуй
@
Делаешь заного
>True story
Аноны, при создании char-массива, т.е.
char array[5];
нуль-терминатор (\0) автоматически добавляется в последний элемент массива? Т.е. в a[4] уже записывается \0, как только я пишу char array[5]?
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 прерывает ввод аналогично пробелу?
Да, Enter, Tab - вообще всё, что isspace().
Хм, тогда почему в таком коде программа падает при после ввода строки? Ввожу однозначное или двузначное число, например, 5 или 14, нажимаю Enter, получаю виндовое сообщение об ошибке, типа, "Прекращена работа программы...".
int main () {
char b[3];
scanf_s ("%s", b);
printf ("%s\n", b);
return 0;
}
for(i = 0; i > var1 + var2; i++)
Компилятор вычислит значение "var1 + var2" один раз, или будет это делать в каждой итерации?
Будет ли правильным создать ещё одну переменную перед циклом, "var3 = var1 + var2;", и использовать её в условии?
Компилятор вычислит значение "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. Второй - максимальный размер.
Стандарту определяет "наблюдаемое поведение": выражение вычисляется каждый раз. Если ты не можешь никак увидеть, что реальное поведение как-то отличается (например, в твоем случае никаких побочных эффектов от вычисления выражения до цикла не будет), тогда компилятор может оптимизировать, а может и не оптимизировать. Можешь надеяться, что такое простое выражение он проглотит, но вот если у тебя там есть что-либо сложнее 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 в конец.
Алсо, тут я тебя тоже наебал. Второй аргумент с размером нужен только для спецификаторов %s %[] и %c. Никогда этим говном не пользовался.
>Их обещали выпилить из C2x
Кто обещал?
И когда этот стандарт выйдет?
> Кто обещал?
Комитет по стандартизации. Потому что это хуйня, интересная только Microsoft и попавшая в стандарт под ее давлением.
> И когда этот стандарт выйдет
С99 вышел в 1999. C11 вышел в 2011. Используй логику, чтобы понять, когда выйдет C2x.
аа, так вот почему у меня программа падала. Спасибо, тогда буду онли использовать scanf, вместо scanf_s. А можно еще за \0 пояснить? Что будет, если его не дописывать в конец массива? Ну, допустим буду заполнять через %c. Или это уже совсем другая тема и лучше сейчас этим не заморачиваться?
Котаны, у меня есть ~200 разных файлов следующего содержания:
#define FILE_(номер файла) (размерность массива)
int myfunc(double (звездочка)x, бла-бла)
{ бла-бла}
Также есть один на всех main-файл. Хотелось бы переписать его так, чтобы он по очереди запускал каждый из двухсот файлов, получал некоторый результат и записывал его в выходной файл (выходной файл тоже один на всех).
Как это можно сделать?
#define FILE_(номер файла) (размерность массива)
int myfunc(double (звездочка)x, бла-бла)
{ бла-бла}
Также есть один на всех main-файл. Хотелось бы переписать его так, чтобы он по очереди запускал каждый из двухсот файлов, получал некоторый результат и записывал его в выходной файл (выходной файл тоже один на всех).
Как это можно сделать?
>Комитет по стандартизации.
Где можно ознакомиться с обещаниями?
>С99 вышел в 1999. C11 вышел в 2011. Используй логику, чтобы понять, когда выйдет C2x.
C++0x тоже обещали в нулевых, а вышел он аж в 2001 году. Стандарт не принимают каждое десятилетие, а по мере необходимости. Си не особо живой язык, новый стандарт никому не нужен, учитывая, что C11 спустя 6 лет после выхода полностью реализован только в одном компиляторе - Clang/LLVM
>а вышел он аж в 2001 году
В 2011, конечно.
> Где можно ознакомиться с обещаниями?
Знакомство осуществляется копанием тут: http://www.open-std.org/jtc1/sc22/wg14/
> новый стандарт никому не нужен
Многие считают по-другому. Я, например, атрибутов жду. И где-то в 21-22 году стандарт должен выйти, а к 25-26 можно будет даже начинать ими пользоваться, лол.
Выкинь впизду дефайны, сделай структуру, описывающую имя (если нужно) и параметры файла (размерность, или хуй знает, что там у тебя), сделай массив таких структур. В рантайме в цикле иди по массиву, открывай и обрабатывай в соответствии с указанными параметрами каждый файл.
Это вариант, но я не хотел так делать из-за "раздутия"исходного кода.
Каждый файл -- некоторый ОГРОМНЫЙ функционал. В нынешней тестовой версии самый большой из них занимает 270 страниц двенадцатого вордовского текста и нихуя не работает работает, но в ожидании ответа я успею умереть, самый маленький -- страниц 20.
Скорее всего для ускорения придется дописывать некоторую вспомогательную ерунду, из-за которой каждый файл еще вдвое увеличится в объеме.
Получится даже не "Война и мир", а какая-то ебучая Британника.
Попробуй русским языком более полно описать то, чего ты хочешь. Никакого раздутия исходного кода быть не может. Либо у тебя массив с параметрами, либо массив указателей на параметры или колбеки (а параметры и вспомогательные функции в отдельных файлах). Никакие дефайны там не нужны. Ну разве что для создания похожих элементов массива.
Я тебя кажется понял. Извини за предыдущий дурацкий комментарий.
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.
Подскажите, в чем проблема
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 на С++.
Во-вторых, некоторые и до сих пор видел пилят на С.
В-третьих, так принято в геймдеве.
В-четвертых, у многих и не только гейдевелов промыты мозги о всесильности и охуенности ОО подхода.
В-пятых, ОО подход действительно в геймдеве может успешно применяться.
В-шестых, никто не запрещает писать в Си стайле на С++ и пользоваться только самым необходимым из С++.
В-седьмых, просто куча либ и двиганов уже написана на С++ и он тащится как ебаное легаси.
Аноны, какой диапазон для целой и дробной части у типов float и double?
Вот, например, все мы знаем, что тип 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. Но опять же, повторю свой вопрос: какой диапазон значений в целой и дробной части будет для каждого из них?
Вот, например, все мы знаем, что тип 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минимальная или максимальная экспонента, плюс существуют еще денормализованные значения с плавающей точкой для представления очень маленьких чисел.
> Использовать уебищные костыли, когда можно нативно
Твой нативный код развернется абсолютно в те же инструкции, что и сишный. Не вижу никаких костылей: COM - это ничего больше, чем просто указатели на функции, а указатели на функции в Си широко используются.
> Для пруфоф можешь зайти на любой геймдев форум
Зашел, там юнити с додиезами и JS. Составил впечатление, что геймдев - это додиез. Правильно?
> Не вижу никаких костылей
Твои проблемы.
>Правильно?
Нет.
Вообще не могу дупля отбить с этими рекурсиями. Они же должны как зеркало бесконечно отражаться, и виснуть в этих циклах. Как они вообще из них выходят?
хм, интересно, в сбертехе все на явке новое же пишется..
>и виснуть в этих циклах
и виснут
>Как они вообще из них выходя
по условию
А есть какой-нибудь простой пример реального использования?
Ну, например, обход директорий в файловой системе): функция обработает файлы в указанной директории, и, если в директории есть дочерние директории, вызовет себя же для их обработки, иначе НЕ вызовет, и эта ветка рекурсии закончится. Очевидно, что момент, когда вложенных директорий не будет, когда-нибудь обязательно настанет на самом деле, не совсем правда: есть всякие символические ссылки, которые могут ссылаться куда-нибудь выше текущей папки, и программа зависнет, если не знает об их существовании.
Теперь стало немного понятнее.
А промежуточные результаты оно в оперативку пинает?
> когда вложенных директорий не будет
if (child == NULL) return
а по ссылкам в линупсе не ходютъ
этому вот
float var = 5.0;
void func(int i) { ... }
...
func((int)var);
------------------------
float var = 5.0;
void func() { int i = (int)var; ... }
...
func();
Будет ли разница в скорости выполнения?
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#, кроме названий?
>Что общего и в чём различие языков C++, Visual C++ и C#, кроме названий?
>пидарасы
>пидарасы
>пидарасы
Как разделить число на два целочисленных значения?
С двойкой все понятно: 2 / 2 = 1, то есть 1 и 1 будет.
Тройка: 3 / 2 = 1.5, а после каста к инту 1, то есть будет 1 и 1, а должно быть 2 и 1, или 1 и 2.
Думаю задача ясна. Необходимо самое быстродейственное решение.
С двойкой все понятно: 2 / 2 = 1, то есть 1 и 1 будет.
Тройка: 3 / 2 = 1.5, а после каста к инту 1, то есть будет 1 и 1, а должно быть 2 и 1, или 1 и 2.
Думаю задача ясна. Необходимо самое быстродейственное решение.
Нет.
int n1 = (foo / 2);
int n2 = foo - n1;
Охуеть, правда?
> Охуеть, правда?
А то! Я бы условия хуячил. Спасибки.
>Охуеть, правда
ебать ты маг
Это понятно, а ещё?
подскажите конструкцию автоматического дополнительного выделения памяти при заполнении массива текстом
типа если память заканчивается то реаллок еще скока-то
типа если память заканчивается то реаллок еще скока-то
Тебе куда-нибудь в менеджед языки. В Си ты решаешь вопросы памяти, язык за тебя ничего делать не будет. И тем более он никак не может узнать, что у тебя "память заканчивается". А вот сам ты можешь сделать функцию типа array_put, которая и будет заниматься мемори-менеджментом, если очередной элемент/элементы ей положить будет некуда.
Есть частные/частичные решения: например, в винде ты можешь зарезервировать большой кусок адресного пространства (память не тратится почти), в конец своего массива ставить страницу с PAGE_GUARD, отлавливать исключения и выделять еще памяти. Но это извращение с очень узкими юзкейсами.
Это можно сделать, например, через связный список, выделяя память для узлов по мере надобности. При malloc еще нужно делать проверку на NULL, чтобы программа нормально завершилась при исчерпании памяти компа.
Сап /pr. Помоги сделать задачку (на чистом C).
Данные о работниках хранятся в некоторой структуре. Одно из полей структуры имеет тип 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 является указатель на структуру.
Данные о работниках хранятся в некоторой структуре. Одно из полей структуры имеет тип 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 является указатель на структуру.
> C++
Гавно
> Visual C++
Блевотина
> C#
НИНУЖЕН
- пишешь функцию, в ней цикл
- гугли, как передать функции указатель на другую функцию
- в цикле вызываешь другую функцию по указателю на неё
Вот это:
Ответ на это:
Ответ на это:
Имеет ли смысл делать free непосредственно перед выходом из программы? Или пусть ОС сама разбирается?
Имеет. Наличие автоматического освобождения памяти зависит от конкретной ОС. Да и норм пацаны тебя будут считать жаба-макакой, который пишет говнокод.
Скорость и управляемость С и кое-какие инструменты для построения абстракций (классы, темплейты/стл) для ускорения разработки и структурирования больших объёмов кода. Типа на двух стульях усидеть пытаются.
Аноны, пожалуйста, помогите. Вот пример кода:
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. Т.е. мне нужно сделать так, чтобы в строку переводились только значащие цифры, без лишних нулей в дробной части. Как это можно сделать? Писать отдельную функцию для удаления лишних нулей из строки не хочется.
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. Т.е. мне нужно сделать так, чтобы в строку переводились только значащие цифры, без лишних нулей в дробной части. Как это можно сделать? Писать отдельную функцию для удаления лишних нулей из строки не хочется.
Окей, спасибо.
У меня и не gcc, и я для питона расширение пишу, так что сомневаюсь, что это корректно работало бы.
Делать free() при выходе - это распространенная плохая практика: при free() куче приходится вытаскивать из свопа всякие давно забытые служебные данные, обрабатывать их, реорганизовывать кучу и делать множество других ненужных вещей, поэтому программа, выделяющая много небольших блоков памяти, будет тормозить при выходе, если делать "правильную" очистку. В то же время, если free() при выходе не делать, ОС может просто пометить соответствующие страницы памяти как пустые и завершить программу мгновенно.
Алсо, если у тебя короткоживущий процесс, который запускают для обработки чего-нибудь, есть смысл вообще никогда не делать free() для небольших блоков памяти, а когда обработка закончится - ОС за тобой приберет.
Простой способ: используй %g, укажи точность побольше (%.20g). Сложный способ: используй %g, вытащи из double экспоненту и посчитай, какая нужна точность, чтобы оно не переключилось на %e. Ну или нули обрезай, да.
> g — форматирует число с плавающей запятой в десятичной или десятичной экспоненциальной форме в зависимости от значения и точности
http://ru.cppreference.com/w/cpp/io/c/fprintf
>будет тормозить при выходе
С-с
ей богу, такая проблема. для больших программ более важно исполнение, а не запуск/терминейт.
а с боковой стороны, это ещё одна возможность проверить правильность своего кода.
Да-да, всегда очень сложно заставить себя переосмыслить что-то, вдолбленное на этапе обучения как best-practice.
да-да, так сложно заставить себя перестать компенсировать в интернете на незнакомых людях.
>при free() куче приходится вытаскивать из свопа
Где-то в 2k18 остался своп?
А куда он денется?
Хули оно в терминал срёт?
"&> /dev/null" же.
"&> /dev/null" же.
"2> /dev/null"
Вопрос снят.
Анончики, написал прогу по переводу из одной системы счисления в другую. Поддерживается диапазон систем счисления от 2 до 16. Максимально на ввод можно подавать строку из 13 символов. Вот исходник: https://github.com/Digitalvalues/num-sys/blob/master/source0
Если у кого-то есть время, пожалуйста, гляньте, скажите, что можно улучшить в плане памяти. То есть, в каких местах можно поработать с динамическим выделением памяти. А то я просто написал массивы, типа, char array[100]. Чтобы строка уж точно влезла. Так ведь неправильно делать? Нужно как-то через malloc? Я просто с этим еще толком не разбирался. Поэтому буду благодарен, если кто-то приведет хотя бы 1-2 примера переписанных строк моего исходника.
P.S. Если в коде почти ничего не понятно - могу закомментить его. Только попросите.
Если у кого-то есть время, пожалуйста, гляньте, скажите, что можно улучшить в плане памяти. То есть, в каких местах можно поработать с динамическим выделением памяти. А то я просто написал массивы, типа, 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 она конвертируется?
И еще вопрос: допустим, возьмем мою программу по переводу из одной системы счисления в другую. И попробуем перевести из 16 системы в 10 число 0.FF. Когда программа выполняется, я получаю ответ 0.996094. Хотя на самом деле должно быть 0.99609375. То есть в double типе после точки может быть только 6 цифр. Поэтому компилятор автоматически округляет 0.99609375 до 0.996094. Что делать? Как в дробной части можно получать больше, чем 6 цифр?
Там звездочки проебались. Хотя вроде итак понятно
Точность для %g указывай. Это ведь ты спрашивал? Или руками преобразовывай.
Я не понял. Причем тут %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. Мы ведь от этого ничего не потеряем? Ну, если число будет маленьким, то лишние нули он уберет, а если число будет очень маленьким (много цифр в дробной части), то оно все равно влезет в такой диапазон.
> %.10000000000g
4000 с хуем символов - это минимум, который по стандарту должен поддерживаться всеми. Для double хватит (длиннее, чем в не сделать), а вот для long double уже нет.
Подскажите, почему double x = 14.000000000000 конвертируется в 13, а не в 14, при записи int(x)?
вопрос снят
почему 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 в stdlib.h? Чекнул вики, но не совсем все понял. В вики сказано, что NULL - это целочисленное нулевое значение. Т.е. я спокойно могу написать свой собственный NULL? #define MYNULL 0 Будет ли это аналогично дефайну стандартного NULL?
да
Тогда почему инициализация указателей NULL'ом считается нормальным действием? Ведь в адресе 0 могут хранится какие-то данные. Например, часть переменной. С тем же успехом можно инициализировать указатели значением 3211351, вместо NULL
> Ведь в адресе 0 могут хранится какие-то данные
Не могут (запрещено стандартом). В винде, например, специально из-за этой особенности сишечки запрещает выделять первые 4к виртуальной памяти.
> С тем же успехом можно инициализировать указатели значением 3211351, вместо NULL
Можно. Но проверять на ноль дешевле, чем на 3211351.
> запрещает выделять первые 4к виртуальной памяти
А что значит "4к". 4Кб? Сорян за возможно глупый вопрос.
>Можно
Тогда уж нельзя. Ведь если в 0 точно не может быть никаких данных, то по адресу 3211351 они могут быть
Хотя было бы странно запрещать выделять целые 4Кб памяти - слишком много. Но я все равно не понял, что подразумевается под "4к"
NULL это не "нулевой адрес".
Да, стандарт разрешает и другие представления нулевого указателя, но в реальности оно практически везде ноль.
> слишком много
Лол, у тебя гигабайты на компе. 4 килобайта - это ровно страница. Управлять доступом к объектам размером меньше страницы нельзя.
Анончик, помоги закрыть предмет. Мне нужно написать алгоритм крускала через систему непересекающихся множеств. Я написал disjoint set, но не знаю как написать к нему крускала. Можешь помочь? Могу скинуть пару баксов на пейпал если поможешь дописать (или пару кусков битка)
>Тогда почему инициализация указателей NULL'ом считается нормальным действием?
Как раз потому что указателя NULL = 0 быть не может и это можно использовать как признак, что данных нет, например. В то время как другая хуитка - это, в зависимости от архитектуры - может быть вполне нормальным адресом.
Указатель содержит адрес только на первый байт блока памяти или на весь блок? Или же вообще на начало и конец блока?
int *p;
int main () {
p = malloc(40);
return 0;
}
В этом коде видно, что мы выделили блок памяти в куче размером 40 байт, и (как написано в интернете) функция malloc возвращает адрес на начало этого блока указателю p. То есть, если так можно выразиться, указатель лишь знает адрес первого байта (или бита?) всего этого блока, верно? Но в указателе, вернее, в адресе, который в нем хранится, нет никакой инфы о том, когда этот блок заканчивается, так?
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 байт, нетрудно найти заголовок области в куче. А оттуда получить указатели на предыдущую/следующую области.
Алсо, там ещё и флажки есть.
>Куча (heap) устроена как двусвязный список.
Ты нам из 70-х пишешь?
Да на каком-нибудь микроконтроллере и сейчас можно найти подобное без проблем. Вполне себе нормальное решение, если на скорость поиска свободных блоков и на фрагментацию похуй.
void func(int @p) { int i = 5; p = &i; }
...
int @p;
func(p);
printf("%d\n", @p) // -421423441 (мусор)
В данном случае функция "func" работает с локальной копией указателя, правильно? А передать в функцию сам указатель нельзя?
...
int @p;
func(p);
printf("%d\n", @p) // -421423441 (мусор)
В данном случае функция "func" работает с локальной копией указателя, правильно? А передать в функцию сам указатель нельзя?
Можно, передай указатель на указатель. void func(int p) ...
void func(int✡✡ p)
быстрофикс
-няша
О как круто! Спасибо.
Я хотел еще один вопрос задать, на счет закомментированного кода по ссылке, но в 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 (что вполне возможно для глобальных переменных, не помню точно зануляются ли глобальные переменные по стандарту), то упадёт прямо при вызове функции, т.к. ты пытаешься нулевой указатель разыменовать (это термин такой, "разыменовать указатель — получить значение из памяти, куда указывает указатель").
>✡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 нужно. Пытаюсь на простом примере понять, как сделать нечто похожее в основном программе. В принципе понял.
Тогда так:
func(&gp);
У меня там именно гора указателей на указатели, указывающие на указатели на указатели, указывающие на указатели.
Вот как раз еще один вопрос в связи с этим. Я в таких дебрях не понимаю ничего.
Есть указатель на указатель - var1, который указывает на var2 - тоже указатель на указатель, который указывает на var3 - обычный указатель на int.
Как мне обращаясь к var1 проверить NULL ли var3 или не NULL?
Просто if(var1 == NULL), как я понимаю, не то выдает.
Всё ясно, ещё раз спасибо. Схоронил себе пикчу, буду поглядывать.
А Си уже скоро ВСЁ? Всё-таки есть Rust, GO или хотя бы C++.. Может не стоит его даже учить?
Не скоро.
Плюс стоит учить, даже если не будешь активно писать на нём, чтобы понять как современные компьютеры и ОС работают (указатели, стек, куча, cache & locality).
Еще вопрос на счет указателей, не могу гуглу его сформулировать нормально.
Как обратиться к переменной "i" через "var"? Которая в функции. Компилятор говорит, что тип "type_ *" не структура, нельзя к нему мол через "->".
Как обратиться к переменной "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 отправится локальная копия указателя, а не сам указатель. Разве нет?
Путаюсь очень, извини.
Из-за очерёдности применения операторов. (✡var)-> сделай
Именно это я и хотел услышать, спасибо.
Но мне все равно не понятно как именно нужно указатели в функции передавать.
Как я понимаю этот код не работал из-за того, что я манипулировал с памятью непосредственно во вторичной функции "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, если sizeof(int) = 4?
Написал я
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 строки, но при практическом выполнении возникают трудности
Написал я
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'ить тип.
Все, разобрался со всей своей фигней. Сорян, что тупил, у меня уже поздно, да и ел мало сегодня. Через pow все-таки все удалось сделать. И signed и unsigned. Однако еще узнал, что можно сделать это через битовые сдвиги (почитаю про них) и просто printf нужного типа. Так что еще раз спасибо
>int((pow
Чё за int блядь? Это функция? У меня твоё говно не компилируется.
Не компилится, потому что двач не отображает символ звездочки (умножение) в постах. Вот фул тогда https://pastebin.com/8Xht7fU4
> Не компилится, потому что двач не отображает символ звездочки (умножение) в постах.
Nope. Я спалил звёздочку. Не в ней была проблема.
https://pastebin.com/LUT7fzhw
Не компилится, потому что это крестопарашный синтаксис, а не сишный.
Действительно, проверил в другом компиляторе (онли Си) там выдает ошибку.
Как тогда в Си писать преобразование в тип?
Методом тыка обнаружил, что правильно преобразовать типы в Си надо так: (int)(a), а не int(a). Потому что в таком случае int(a) компилятор ожидает декларирования новой переменной, отсюда и ошибки.
Есть задание: напишите двоичное представление числа -117 типа signed char в дополнительном коде. Что это значит и какое будет представление?
Ухади
Нет, серьезно. -117 в двоичную систему я перевести могу. Но что значит дополнительный код?
При записи числа в дополнительном коде старший разряд является знаковым.
сказать где я это нашел?
Ты не совсем прав.
Чтобы число записать в дополнительном коде надо все его биты инвертировать и прибавить единицу. Учите основы аноны, это важно.
>инвертировать и прибавить единицу.
зачем? хуйня какая то
00000001 - 11111110 -> 00000001
вобщем почитал, вопрос снимается.
>Если указатель хранит адрес только на первый байт всего блока, то как тогда функция 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
слишком многа букаф, ниасилил
os знает сколько байт по начальному адресу чанк занимает
>os знает
Да нихуя она не знает.
>Да нихуя она не знает
а кто память выделяет, а, мамка твоя?
http://www.opennet.ru/docs/RUS/zlp/002.html
Тут чуваки поясняют за мультифайловое программирование (в главе 2.2). Их код у меня не компилится ибо файл с main'ом не видит функции, которые он вызывает. Я конечно мог бы объявить функции в том же файле с main'ом, а реализацию уже в другой, но почему у меня их код не работает? или он и не должен?
Тут чуваки поясняют за мультифайловое программирование (в главе 2.2). Их код у меня не компилится ибо файл с main'ом не видит функции, которые он вызывает. Я конечно мог бы объявить функции в том же файле с main'ом, а реализацию уже в другой, но почему у меня их код не работает? или он и не должен?
Пытаюсь распарсить json по этому гайду
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
Что не так то?
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
Что не так то?
C99 требует прототип функций. Гайд старый, писался под C90
Олсо, мейк-файл там идиотский.
Ну тебе же написали: ты вызываешь json_object_get_object_member() на том, что не является JSON-объектом (на массиве, например) или вообще пихаешь туда NULL.
Действительно там массив, только не пойму чо делать если внутрь массива напиханы объекты.
json_node_get_array()
json_array_get_length()
json_array_get_element()
Разобрался.
Не туда пишу, наверное, но пох
Писал в школе проги на паскале, решил вкатиться в си, поставил code::blocks и mingw. Охуел с того, что нельзя запускать отладчик для файлов, только для проекта. Насколько понял, в проекте есть только один сурс(в котором, собсна, и находится единственная main), в который подключаются функции, описанные в куче хедеров.
Я правильно понял, или как? Мне что, каждое упражнение из K&R в отдельный хедер ну или в один писать функцией, а его в main.c подключать, а там инициализировать свои проги в виде функций? Или а каждую прогу уровня "подсчитайте строки" новый проект создавать? Что за бред?
Короче, разъясните дауну, шо це проект, и как с ним работать.
Писал в школе проги на паскале, решил вкатиться в си, поставил code::blocks и mingw. Охуел с того, что нельзя запускать отладчик для файлов, только для проекта. Насколько понял, в проекте есть только один сурс(в котором, собсна, и находится единственная main), в который подключаются функции, описанные в куче хедеров.
Я правильно понял, или как? Мне что, каждое упражнение из K&R в отдельный хедер ну или в один писать функцией, а его в main.c подключать, а там инициализировать свои проги в виде функций? Или а каждую прогу уровня "подсчитайте строки" новый проект создавать? Что за бред?
Короче, разъясните дауну, шо це проект, и как с ним работать.
> Насколько понял, в проекте есть только один сурс
Ты неправильно понял. В проекте может быть сколько угодно исходников и сколько угодно хедеров. Но одна main(), да. В любом из этих исходников. Еще у проекта есть куча настроек (директории, ключи компилятору, подключаемые либы), поэтому многие IDE и хотят проект для компиляции.
> Мне что, каждое упражнение из K&R в отдельный хедер
В K&R большинство упражнений не требует нескольких файлов, поэтому и декларации можешь делать не в хедере, а вверху файла. Если тебе лениво создавать один проект на программу, можешь создавать каждый раз новый .c-файл, класть его в проект, а старый удалять из проекта (можешь придумать кучу вариций: ничего не удалять, а делать #if (EXERCISE==1) ... #endif вокруг функций упражнения, и, соответствено, где нибудь выше делать #define EXERCISE 1; можешь даже диспетчер упражнений наговнокодить, который будет вызывать exerciseN_main, можешь просто такие мелкие вещи компилять из командной строки).
Добра тебе
ушёл курить структуру программы на си
а ещё он может не пользоваться IDE и его проблема исчезнет
Что делать, если вылетает на строчке
char prefix = malloc(512);
пишет:
malloc(): memory corruption: 0x0000561162c24df0
Aborted
char prefix = malloc(512);
пишет:
malloc(): memory corruption: 0x0000561162c24df0
Aborted
добавить звездочку
Да есть звездочка, это макаба сожрала.
на самом деле бесит это, все эти проекты, лишние файлы - сам когда-то ебался с кодблоксом. и естественно переход на емакс всё решил по итогу.
но теперь я не очень понимаю нахуя мейкфайлы, иногда сборка такая сложная, что проще шелл скрипт прописать. хотя я так и не изучил структуру мейкфайлов... просто набрасываю в одной опции строки с командами да и всё.
> просто набрасываю в одной опции строки с командами да и всё
Ну вот когда тебе заебется безусловно перекомпилировать все файлы в большом проекте при изменении какой-нибудь ни на что не влияющей константы, ты осилишь makefiles или cmake, гарантирую. А насчет мелочи соглашусь, проще сделать cc *.c и не думать.
> вылетает на строчке
> malloc
Смотреть, кто повредил кучу ДО этого вызова. Очень помогает gcc или clang с ключиком -fsanitize=address.
потому что он что, проверят тамстемпы перед компиляцией? что в принципе не мешает сделать на шелле, муторно, да. но дело же не в этом, не всегда сборка это создание файлов. например тесты, или когда тебе нужно что-то генерировать через свои же программы - тупо же хранить бинарники - то есть нужно если их нет, скомпилировать их, а потом заиспользовать.
может это и через мекфайл можно - не знаю, не вижу смысла, возможно пока.
Пожалуйста, пользуйтесь 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/%7Eats/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