Создание строки в C (СИ)

Меня не интересуют проблемы, которые возникают у всяких балаболов.

Супермен среди нас. Документируете каждую особенность использования и перечитываете после n-месячных перерывов? Или просто ничего никогда не забываете?

Или просто ничего никогда не пишете?

fxd.

Какая разница с какой алгоритмической скоростью исполняется функция, которая не работает?

И что это меняет? Ты опровергаешь то, что std::string может быть быстрее char* тем, что std::string может использовать string.h? Логика тебе чужда, я смотрю.

Как всегда, я получаю полный неадекват. Но я опять же, поясню.

Что писал данный пациент?

В стандартном C-api практически все операции со строками предполагают пробег по ним в поисках завершающего '\0'.

И если std::string - есть обёртка над C-api, то данный пациент написал ахинею, ведь тогда на нём нельзя было реализовать std::string.

В большинстве или нет, зависит от данных и набора операций. Но хорошо хоть не во всех. Уже прогресс. Скоро начнёшь понимать, что выйгрыш в некоторых операциях - тоже выйгрыш.

А в остальных операциях, где оно сливает в хлам - ты их не учитываешь?

Ты пойми разницу, что я не сравниваю си-строки и твой std::string. Я сравниваю именно комплекс возможностей, который даёт мне char * и std::string. С чего ты решил, что если мне нужно записать длину, то я её не запишу?

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

Молодец, ты поймал этих колхозников https://github.com/antirez/sds/blob/master/sds.c#L784 . Ну ничего, 2к звёзд есть и это главное.

И да, как я уже говорил - у меня нет никаких ограничений. Если мне нужна длина - я её сделаю.

Ну и что это за бред? Причём тут противоречия, ограничения и мощность?

В том, балабол, что в отличии от твоего колхоза - char * не ограничен убогим хиповым аллокатором. Я могу сделать (char[48]){}, а ты не можешь. Т.е. то, что для sso - для меня то, что всегда есть у меня. При этом моё sso не ограничено этим примитивным колхозом.

Тебе русским языком сказано, что на 64-битах для мелких строк, std::string, благодаря sso, будет быстрее, чем выделение памяти на куче. Что тут можно было не понять?

А кто тебе сказал, что память кто-то будет выделять «на куче»? И кто тебе сказал, что у меня твоя «куча»?

А некоторые алгоритмы, благодаря известному размеру, можно оптимизировать.

Тебе это не поможет, ведь любая оптимизация от тебя потребует char *.

Царь не осилил raii и string_view. Но мнение имеет. Впрочем как обычно.

Зачем мне какой-то балабол вещает о том, что я что-то осилил. Ты хочешь со мною посоревноваться в осиляторстве?

И опять же, убогие потуги уровня «не осилил» и ничего по существу. При этом, балабол настолько невменяем, что сам же назвал раии дерьмом, сам же дал string_view, который есть прямое свидетельства ущербности raii, ведь это строка без владения, как и char *.

Твой ultrafast_высер() кусок говна, неприменимый в адекватных проектах. Оставь его себе и больше не выкладывай.

Меня мало интересуют колхозники, их проекты и их мнение.

Супермен среди нас. Документируете каждую особенность использования и перечитываете после n-месячных перерывов?

Зачем мне что-то перечитывать? Понимание на то и понимание, что я знаю как оно работает, а значит знаю все особенности ВСЕГДА. Особенно когда ты с этим работаешь - ты не забудешь никогда и ничего, даже самые мелкие нюансы.

Я уже несколько лет не видел malloc(), а до этого видел его пару раз, но я помню как он работает. Я пошел и глянул на исходники и увидел необходимые нюансы. Так это и работает.

А если ты ничего не понимаешь и зубришь только api, то у тебя проблемы. И это именно твои проблемы, даже если таких большинство.

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

Но это всё неважно, балаболы не понимают базовых вещей, а именно. Любое универсальное решение - есть объединение множества специализированных.

И когда им показывают это специализированное - они орут «оно не универсальное», а с чего оно должно им быть? «его можно сломать», дак всё можно сломать, и?

Вообщем, надо понять, что все эти потуги балаболов - есть ничто иное, как мазы. Им нечего сказать, вот они и пытаются ретраслировать дефолтные заклинания, которые ничего не стоят и ничего не значат.

Есть что возразить?

Пока мне достаточно если С строки будут быстрее std::string :)

Мило=) Ты же понимаешь, что строки на с++ могут оказаться быстрее строк на си.

Сложно для понимания == медленно. Очевидно же =)

И если std::string - есть обёртка над C-api, то данный пациент написал ахинею, ведь тогда на нём нельзя было реализовать std::string.

Я надеюсь, что у тебя в голове была какая-то мысль. Но выразить её в хоть сколько-нибудь внятной форме у тебя не вышло. Попробуй ещё раз.

А в остальных операциях, где оно сливает в хлам - ты их не учитываешь?

Это в каких например?

Ты пойми разницу, что я не сравниваю си-строки и твой std::string.

Я понимаю, что ты любишь поговорить о чём-то своём. Но это твоё никому не интересно. Разговор шёл о том, что

Во многих случаях std::string будет быстрее char*, как раз из-за наличия размера

И о том, что вместо char* лучше использовать пару указатель/размер.

То, что ты готов таскать размер отдельно от строки, вместо того, чтобы завести нормальные строки и пользоваться ими - вообще никого не интересует.

В том, балабол, что в отличии от твоего колхоза - char * не ограничен убогим хиповым аллокатором. Я могу сделать (char[48]){}

Если максимальный размер заранее известен, и я не хочу переаллокаций, я сделаю reserve(). Аллокация будет, но одна.

а ты не можешь.

Если же мне зачем-то нужен буфер именно на стёке, то я возьму char[48], но только в этом сомнительном случае.

Но как ты не понимаешь, sso даёт профит, даже если длина строки заранее не известна. Ты, конечно, можешь заявить, что можешь запилить своё sso с большим буфером, и возможно, даже сможешь запилить что-нибудь кривенькое. Но вменяемым людям это не нужно.

балабол

на 64-битах для мелких строк, std::string, благодаря sso, будет быстрее, чем выделение памяти на куче.

Тебе изначально говорили про char* в куче. Так что балабол у нас один - ты.

А кто тебе сказал, что память кто-то будет выделять «на куче»?

Внезапно, ТС выделял память на куче. Впрочем, то, что ты влез в разговор ничего не поняв, не удивляет.

Тебе это не поможет, ведь любая оптимизация от тебя потребует char *.

Ну во-первых, char* в std::string есть. Во-вторых, эти оптимизации за меня уже сделаны разработчиками libstdc++ и прочих реализаций.

Зачем мне какой-то балабол вещает о том, что я что-то осилил.

Ты читать то научись. Тебе говорят о том, что ты не осилил.

И опять же, убогие потуги уровня «не осилил» и ничего по существу.

Комментировать высер, не содержащий существа, можно только не по существу, ввиду отсутствия последнего.

что сам же назвал раии дерьмом

Приснилось? Пруфца подкинь, ты же ведь не балабол какой-нибудь?

сам же дал string_view, который есть прямое свидетельства ущербности raii

Ну я и говорю, ты не осилил raii. Молодец, что лишний раз подвердил.

Как всегда, я получаю полный неадекват.

А ты попробуй сперва думать, а потом писать.

Так это не мнение, дурачок, это факт, твой говнокод просто не работает.

char* buf = malloc(MAX_BUF_SIZE);
...
fgets(buf, MAX_BUF_SIZE, file);
process_string(buf);
...
free(buf);

Причём тупость решения тем выраженнее, что примерно того же эффекта можно было бы добиться простейшей структуркой, причём не пришлось бы вызывать strlen, завязываться на формат чанков в хипе, и никто бы не перепутал строки с быстрым стрленом с обычными нуль-терминируемыми, типизация была бы на твоей стороне. Но нет, ты сэкономишь 16 байтов и сделаешь через зад.

О боже, колхозник, что ты пытаешься нести. Твоя потуга попросту не имеет смысла, ведь во-первых - такое дерьмо пишут только в колхозе, а меня оно интересовать не должно. У тебя итак есть длинна строки, да и ты всегда можешь сделать realloc(), колхозник.

Кстати, колхозник, что ты будешь делать, если длинна данных больше буфера? Сядешь в лужу?

Причём тупость решения тем выраженнее, что примерно того же эффекта можно было бы добиться простейшей структуркой, причём не пришлось бы вызывать strlen

Обожаю эти мазы от поломоев. У колхозника горит седалище из-за того, что он не осилил, но он пытается мазаться и искать оправдания.

и никто бы не перепутал строки с быстрым стрленом с обычными нуль-терминируемыми, типизация была бы на твоей стороне. Но нет, ты сэкономишь 16 байтов и сделаешь через зад.

Как я понимаю, колхозник, ты называешь это: https://github.com/antirez/sds/blob/master/sds.h#L42 - дерьмом, ну ничего. Иди напиши это в issues.

Вообще, резюмирую. Если колхозник хочет рассказывать о чём-то, то пусть рассказывает это всем, в частности - sds. Почему он об этом не рассказывает? О том, что «типизация не на их стороне»?

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

MAX_BUF_SIZE выбран с запасом,

Вот оно.

Я могу сделать (char[48]){}, а ты не можешь.

Тоже мне, бином Ньютона: ({struct string hd; char buf[48];}){}

Я надеюсь, что у тебя в голове была какая-то мысль. Но выразить её в хоть сколько-нибудь внятной форме у тебя не вышло. Попробуй ещё раз.

Слив засчитан.

Это в каких например?

Во всех, которые ты реализуешь поверх std::string. Если тебе нужно рассказать о базовых операциях, то любое расширение строки, особенно больших строк. Ведь в колхозном stl нет реаллока.

С шансом 99% для операция, которых нет в char_trits - там полная жопа. Мне лень это бенчить, но первая же ссылка в гугле: http://0x80.pl/notesen/2016-10-08-slow-std-string-find.html

Я понимаю, что ты любишь поговорить о чём-то своём. Но это твоё никому не интересно. Разговор шёл о том, что

Да ты совсем поехавший, если ты говорил о:

И о том, что вместо char* лучше использовать пару указатель/размер.

То почему ты не написал это? Почему ты начал вещать об std::string?

То, что ты готов таскать размер отдельно от строки, вместо того, чтобы завести нормальные строки и пользоваться ими - вообще никого не интересует.

Мнение балаболов о том, что мне надо, а что не надо таскать - меня не интересует.

Если максимальный размер заранее известен, и я не хочу переаллокаций, я сделаю reserve(). Аллокация будет, но одна.

Эти мазы балаболов.

А я не сделаю аллокаций, представляешь? А 0 < 1, вот ведь новость, да?

Но как ты не понимаешь, sso даёт профит, даже если длина строки заранее не известна.

И? Это решение так же даёт профит в случае, когда длина строки не известна. С чего ты решил, что в (char[48]){} нельзя записать 10байт? В них можно записать и 40байт, а вот в твоих колхоз нельзя. Можно записать и 100байт, а вот в твой колхоз нельзя.

Понимаешь, балаболка, в чём разница? Твоё убожество работает только в кейсах менее в районе 20байт, а у меня работает всегда. А ты со своим sso на строках в 32байта сядешь в лужу, а я нет.

Ты, конечно, можешь заявить, что можешь запилить своё sso с большим буфером, и возможно, даже сможешь запилить что-нибудь кривенькое. Но вменяемым людям это не нужно.

Мнение лсных колхозников меня не интересует.

Тебе изначально говорили про char* в куче. Так что балабол у нас один - ты.

И? Меня это должно волновать? Выделение в кучи - это ограничение твоего колхозного std::string, а не char *. С чего ты, балабол, накладываешь на него это ограничения? В очередной раз сел в лужу.

Внезапно, ТС выделял память на куче. Впрочем, то, что ты влез в разговор ничего не поняв, не удивляет.

Ты отвечал мне, а не ТС"у.

Да и ты врёшь, трепло.

Пока мне достаточно если С строки будут быстрее std::string :)
Во многих случаях std::string будет быстрее char*, как раз из-за наличия размера.

Где тут что-то про кучу? Ой, опять обделался и наврал, бывает.

Ну во-первых, char* в std::string есть. Во-вторых, эти оптимизации за меня уже сделаны разработчиками libstdc++ и прочих реализаций.

Я тебе это и написал, что ты будешь использовать char *, а не обходить колхоз-стрку через [] + len. Не сделаны, колхозник. И сделаны они разработчиками glibc - ты перепутал.

Если все операции над строками в твоём мире ограничены парой операций из char_traits, то у меня для тебя плохие новости. Хотя что ещё можно ожидать от скриптуха-балабола.

Комментировать высер, не содержащий существа, можно только не по существу, ввиду отсутствия последнего.

Дак это твой высер не содержит ничего. Тебе сказали, что string_view - это антипод raii, а значит раишное дерьмом не состоятельно.

Приснилось? Пруфца подкинь, ты же ведь не балабол какой-нибудь?

Ну и вообще, std::string может заметно отличаться по скорости от char*, только если его бездумно копируют или создают на каждый чих.

А это самый дефолтный кейс для raii-параши. Именно поэтому, ты и показал решение - не раишная строка, ты не назвал решение в рамках raii - почему? Потому что ты трелпо.

Ну я и говорю, ты не осилил raii. Молодец, что лишний раз подвердил.

Опять же, ничего по существу. Ответить нечего - неси ахиню про «не осилил».

А ты попробуй сперва думать, а потом писать.

Ну расскажи мне, о чём надо подумать? О чём я не подумал. Давай.

Тоже мне, бином Ньютона: ({struct string hd; char buf[48];}){}

и? Что это? К чему это?

Я могу сделать (char[48]){}, а ты не можешь.

Тоже мне, бином Ньютона: ({struct string hd; char buf[48];}){}

и? Что это? К чему это?

Там процитировано. Если не понял цитаты - сходи по ссылке на предыдущий пост.

У тебя итак есть длинна строки, да и ты всегда можешь сделать realloc(), колхозник.

Припекло? Ну ОК, продолжим. Итак, ты делаешь реаллок... зачем? Вот прочитал ты строку тем же fgetsом, размер прочитанного не знаешь, вызываешь обычный strlen, получаешь длину, делаешь реаллок, т.е. копируешь всё посимвольно... не проще, кстати, стрдуп вызвать? Ну ладно, как скажешь, реаллок так реаллок. Кэши засрёшь, хип фрагментируешь, но зато у тебя после всего этого будет твой фастстрлен быстро работать :).

Теперь другая фигня, предположим тебе нужно строку самому форматировать. И, чтоб в конец дописывать, нужно либо размер фактической строки где-то хранить, либо стрлен. Хорошо что у тебя быстрый стрлен, верно? Вот только чтоб он работал память под строку нельзя с запасом выделять, будешь реаллок дёргать на каждый чих.

А теперь представь, что строки у тебя временные. Вот так, в цикле читаешь, обрабатываешь и дальше следующая. Никто в здравом уме подобную строку выделять/освобождать не будет, либо фиксированный буфер некоторого достаточного размера, либо растущий буфер, но в любом случае буфер используется повторно. И опять твоя мегафункция неработоспособна.

Кстати, колхозник, что ты будешь делать, если длинна данных больше буфера? Сядешь в лужу?

Вопрос вообще нерелевантный. Что угодно. fgets в этом смысле безопасен, так что можно хоть обрезать строку, хоть переаллокейтить буфер, хоть вызвать abort.

Обожаю эти мазы от поломоев. У колхозника горит седалище из-за того, что он не осилил, но он пытается мазаться и искать оправдания.

Ну что ты, всё совсем наоборот. Один пионер узнал, как работает хип и придумал шикарную идею. «Мама, смотри как я умею». Потом ему объяснили, что идея дурацкая. Что если уж действительно хочется чего-то подобного, то можно было бы сделать хотя бы отчасти по-человечески. На этом бы и закончить, но тогда же получится простое решение, без подвыподверта, нечем будет хвастаться. Нет, так нельзя, поэтому ради спасения идеи экономии десятка тактов на стрлене пошли мегарешения типа реаллока буфера на каждый чих.

Как я понимаю, колхозник, ты называешь это: https://github.com/antirez/sds/blob/master/sds.h#L42 - дерьмом, ну ничего. Иди напиши это в issues.

Во, побежал прятаться за авторитетами :).

Что тут сказать. SDS на самом деле дерьмоватое решение. Но это результат компромисса и автор хотя бы чуток постарался снизить ущерб, он создал видимость нового типа, чтоб вся обработка шла его собственными функциями. Он поступил глупо, его «преобразование» типа из sds в char* происходит безопасно только в одну сторону и на стороне кода, который знает об sds, так что он мог бы с таким же успехом сидеть не на typedef char* sds, а на указателе на свою структуру, а преобразование в char* делать функцией. А теперь сравним с твоим решением. Во-первых, в SDS, так же как и в том, которое я предположил, хранится length и capacity отдельно, так что не нужно ничего вычислять, все данные тут. Во-вторых, sds не завязан на реализацию хипа, данные о размере блока эта библиотека заполняет сама. В-третьих, вся работа с sds реализована своими функциями, а не как у тебя, костыль char*, который для работоспособности ещё и накладывает дополнительные ограничения, нигде не документированные.

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

Припекло? Ну ОК, продолжим. Итак, ты делаешь реаллок... зачем? Вот прочитал ты строку тем же fgetsом, размер прочитанного не знаешь, вызываешь обычный strlen, получаешь длину, делаешь реаллок, т.е. копируешь всё посимвольно... не проще, кстати, стрдуп вызвать?

т.е. копируешь всё посимвольно...

Неверно. Мало того, что никто не копирует «посимвольно», дак к тому же реаллок не обязательно что-то копирует, а так же - можно затюнить его так, что он вообще ничего копировать не будет. Большие строки он вообще НИКОГДА не копирует.

Вопрос вообще нерелевантный. Что угодно. fgets в этом смысле безопасен, так что можно хоть обрезать строку, хоть переаллокейтить буфер, хоть вызвать abort.

Неверно. Ты определил внешний инвариант, а я то же могу определить внешний инвариант «длинна строки должна быть равно длине аллоцированной памяти», у тебя ведь такой же условие.

Ну что ты, всё совсем наоборот. Один пионер узнал, как работает хип и придумал шикарную идею.

Ламерок, пионер именно ты, ведь ты ничего не сделал и ничего не смог. Почему ты не сделал то же самое?

И особенно смешно читает от нонейм-ламерка о том, что кто-то пионер. Хочешь со мною посоревноваться? Валяй, только не забудь подготовить запасные штанишки.

Потом ему объяснили, что идея дурацкая.

Нет, ты начал мазаться. Ситуация такая. Есть лсный нонейм, который осилил fgets() и прочее колхозные и убогие паттерны. Колхозник не может думать, не может решать задачи. Его потолок - комбинировать паттерны.

И вот, колхозник видит решение, которое работает. И понимает, что он никто и звать его никак. Надо срочно отмазаться, ведь я не бездарен - нет, я просто не хотел это делать потому, что идея дурацкая.

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

И когда ему покажешь решение на реаллоке - колхозник тебе будет орать «дак оно точно так же копирует». Типичный пример - крестовики. У них нет реаллока и они даже не понимают, почему realloc() != malloc() + memmove(). Я тебе даже больше скажу, 99% колхозников даже не осилят понять, зачем там нужен memmove().

Что если уж действительно хочется чего-то подобного, то можно было бы сделать хотя бы отчасти по-человечески.

Ну сделай, трепло.

На этом бы и закончить, но тогда же получится простое решение, без подвыподверта, нечем будет хвастаться. Нет, так нельзя, поэтому ради спасения идеи экономии десятка тактов на стрлене пошли мегарешения типа реаллока буфера на каждый чих.

Опять, как я обожаю рассуждения о тактах от колхозников. Ведь ты нихрена не понимаешь в тактах, зачем ты вообще пытается о чём-то рассуждать, кроме колхоза.

В это твоя проблема. Ты нихрена не понимаешь, нихрена не знаешь - все твои представления ограничены убогих колхозом, и когда кто-то тебе показывает что-то за гранью колхоза - ты начинаешь заспамливать его убогими отмазками вида «бла-бла, все сидят в колхозе, бла-бла - делай как в колхозе. В моём колхозе так не делают» и прочее.

Во, побежал прятаться за авторитетами :).

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

Но это результат компромисса и автор хотя бы чуток постарался снизить ущерб

Пошел отмазывать sds.

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

Неверно, балабол.

Как я могу засунуть в мою функцию левый char *, так я могу засунуть левый char * в это дерьмо. Результат будет ещё хуже.

Там процитировано. Если не понял цитаты - сходи по ссылке на предыдущий пост.

Т.е. ответить ты не можешь? Так и запишем. Предыдущий пост никакого отношения к твоим изваяниям не имеет, и смысл своих изваяний ты должен определять сам, а не переводить стрелки на левые посты.

Написал что-то осмысленное - пока мне смысл. Не можешь - его нет. Всё просто.

Я могу сделать (char[48]){}, а ты не можешь.

Тоже мне, бином Ньютона: ({struct string hd; char buf[48];}){}

и? Что это? К чему это?

Там процитировано.

Т.е. ответить ты не можешь?

Я ответил и привел контекст. Ты то ли прикидываешься, что не понял, то ли в самом деле тупишь

Предыдущий пост никакого отношения к твоим изваяниям не имеет

Ой, да неужели?

vcerloman> char * не ограничен убогим хиповым аллокатором. Я могу сделать (char[48]){}, а ты не можешь.

tailgunner> я могу сделать ({struct string hd; char buf[48];}){}

Я ска - смысла не, значит, его не. Всё про.

/fixed

Неверно. Мало того, что никто не копирует «посимвольно», дак к тому же реаллок не обязательно что-то копирует, а так же - можно затюнить его так, что он вообще ничего копировать не будет. Большие строки он вообще НИКОГДА не копирует.

Да-да, давай, затюнь. Теперь чтоб твой «ультрабыстрый» стрлен работал более-менее быстро требуется не только реаллоками размер строки равнять, но и ещё хип тюнить.

Неверно. Ты определил внешний инвариант, а я то же могу определить внешний инвариант «длинна строки должна быть равно длине аллоцированной памяти», у тебя ведь такой же условие.

дурачок, не используй слова, значение которых не понимаешь (и узнай наконец сколько «н» в слове «длина»). Фраза «твой говнокод выдаст неверный результат или даже будет переполнение буфера, если изначально буфер выделен существенно большего чем строка размера» никакого инварианта не устанавливает, это просто описание дыры твоего решения. Одной из дыр.

Ламерок, пионер именно ты, ведь ты ничего не сделал и ничего не смог. Почему ты не сделал то же самое?

Может потому что я не идиот? Кстати, ты слишком большого о себе мнения: я знаю принципы организации хипа сильно приблизительно, но как только ты заикнулся strlen за O(1) для строк на хипе, мысль о пионере, который решил посмотреть размер блока возникла моментально, и была отброшена как явно дурацкая. После того как ты показал код, с перебором вариантов, я понял, что тебе явно нужно сменить профессию. Если увидев такой код ты не сообразил, что ты что-то делаешь не так, то тебе уже ничто не поможет.

Есть лсный нонейм, который осилил fgets() и прочее колхозные и убогие паттерны. Колхозник не может думать, не может решать задачи. Его потолок - комбинировать паттерны.

Ээээ... слово «паттерн» тоже не используй, ты его тоже не понимаешь. Видишь ли, чувак, предположим ты на самом деле решатель задач. Вот перед тобой появилась задача, тебе захотелось быстрый стрлен. И ты готов даже к тому, чтоб твой стрлен ломался после str[0]='\0', типа такое делать никто не будет. И вот у тебя идея, просто посмотреть заголовок чанка. Ты начинаешь разбираться, видишь, что всё работает через жопу, но ты уже поженился на крутой идее и заменить этот бред на простейшее сохранение размера буфера и количества байт ты уже не можешь, тебе обязательно нужно чтоб через заголовок блока в хипе. Пускай твой кумир, автор SDS, считает незазорным сохранить данные, ты будешь продолжать биться лбом в стену, пока твой говнокод не заработает. Потом выйдет обновление либц или коллега заменит библиотеку для маллока или хотя бы тебе попадётся строка, зааллоченная внутри библиотечной функции и твоя программа посыпется. Так решил ли ты задачу? Ответ: нет. И даже убедившись, что решение говённое, ты продолжаешь упрямиться.

Ну сделай, трепло.

LOL, я тебе первым же сообщением человеческий вариант предложил. Вот, ты только что сам на кривоватый, но более-менее рабочий SDS ссылку давал. Всё лучше чем твоё «я кулхацкер»-решение.

Опять, как я обожаю рассуждения о тактах от колхозников. колхоза... колхозом... колхоз... колхозе...колхозе...колхозе.

«О боже, мою мегаидею раскритиковали... надо написать слово колхоз как можно большее число раз». Ирония в том, что слово «колхозить» в программировании используется как раз для обозначения кривых самодельных решений, работающих через пень колоду, типа твоего.

Нет, тепло. Я уже назвал это дерьмом.

Ты ещё и врунишка. Нет, клоун, ты попытался кинуть стрелы на, как тебе показалось, авторитетную либу и ты предложил мне пойти и высказать критику великому SDS, написать им исью.

Как я могу засунуть в мою функцию левый char *, так я могу засунуть левый char * в это дерьмо. Результат будет ещё хуже.

Ты можешь, не сомневаюсь. А вот хотя бы немного вменяемый человек на твоём месте посмотрит на тип sds и что-то заподозрит. Он ведь, в отличие от тебя, не гений, съевший собаку на хипе, он подумает, раз значение этой переменной создано некоей хитрой функцией и память также освобождается особым образом, наверное это не просто, возможно не стоит функциям, работающим с sds подсовывать левый char*.

А вот ты как раз наоборот, врываешься, гордо неся свою мегафункцию, ни разу не обмолвившись об ограничениях применимости, а когда на них указывают другие, тут же впадаешь в истерику, склоняя «колхоз» на разный лад.

Кстати, а с чего ты решил, что твоя говнофункция безопаснее чем SDS? Ты так же смотришь на байты перед указателем, там может быть что угодно, ты просто прибавляешь к указателю неизвестно что и лезешь туда обычным strlen'ом.

Ладно, последняя попытка обратиться к твоему разуму. Просто подумай. Чтоб твоя функция работала нормально, ты должен при аллокации/реаллокации запросить блок нужного размера, т.е. ты уже должен знать её длину. Но если ты уже знаешь длину, не проще ли эту длину просто сохранить? И тебе не надо завязываться на тонкости реализации хипа и тебе не придётся вызывать strlen на конце блока. Решение с сохранённым размером действительно O(1).

Обсудите идею такого аллокатора. C/С++ (комментарий)

Признаю себя виновным господин судья! Но при оценке тяжести моего проступка прошу учесть то, что я забочусь о детях, которые могут нас читать - они должны знать, что нормальные строки не требуют размещения в хипе.

ultrafast_strlen

   char *a;
   asprintf(&a, "%08123456d", 0);
   printf("%zu %zu\n", strlen(a), ultrafast_strlen(a));
   a[1] = 0;
   printf("%zu %zu\n", strlen(a), ultrafast_strlen(a));

$ ./a.out 
8123456 8123456
1 8123456
$ valgrind --log-file=/dev/null ./a.out 
8123456 18446744073709551592
1 18446744073709551592
$ 

Это не ultrafast_strlen(), это ultrauseless_crap().

нормальные строки

Что такое «нормальные строки» и почему они нужны? Всё равно будет использоваться какой-то свой велосипед. Проще засунуть своё чувство прекрасного куда-нибудь в pet-проект, и перестать тревожиться.

Что такое «нормальные строки»

Которые хранят свою длину.

Проще засунуть своё чувство прекрасного куда-нибудь в pet-проект, и перестать тревожиться.

Проще по сравнению с чем?

Зачем ты, ламерок, пришел сюда и пастишь мне ахинею? С чего меня должны волновать твои убогие потуги?

Хорошо, я тебя пощадил в прошлый раз и мне было лень, теперь не лень. Молодец.

Ладно, последняя попытка обратиться к твоему разуму. Просто подумай. Чтоб твоя функция работала нормально, ты должен при аллокации/реаллокации запросить блок нужного размера, т.е. ты уже должен знать её длину. Но если ты уже знаешь длину, не проще ли эту длину просто сохранить?

Я вот не могу понять, зачем ты пытаешься тулить мне свои детсадовские разъяснения?

Меня ничего из этого не волнует, я не использую «твои» колхозные строки и «твою» колхозную методологию в целом. Ты пытаешься придираться к чему-то, пытаясь мне показать свою осведомлённость? Ты никто. Рассуждал бы ты о чём-то полезном, но ты ведь трепло.

И тебе не надо завязываться на тонкости реализации хипа и тебе не придётся вызывать strlen на конце блока. Решение с сохранённым размером действительно O(1).

Как и моё. И у тебя нет решения с сохранённым размером - у тебя есть char *. Зачем ты пытаешься мне что-то рассказывать, меняя условия?

Давай я тебе расскажу в чём разница. Хорошо, сохранил ты свой колхоз - дальше что? Подобные потуги не работают без реализации множества обёрток над базовым строковым функционалом, написанием сотен врапперов на дефолтными интерфейсами на си-строках.

Ты не можешь просто так балаболить про «сохранить длину» - это ничего не даст.

Кстати, ото всех строк из внешнего контекста, срок из strdup, строк из старой лапши - ты ведь пойдёшь, и всё это переделаешь на свой колхоз, да?

Проще по сравнению с чем?

По сравнению с постоянными переживаниями оттого, что в текущем проекте строки не идеальны. Копируются? Лишний раз strlen вызывается? Да и пусть.

в С только строковые литералы. больше никаких строк там нет

Проще засунуть своё чувство прекрасного куда-нибудь в pet-проект, и перестать тревожиться.

Проще по сравнению с чем?

По сравнению с постоянными переживаниями оттого, что в текущем проекте строки не идеальны.

Эээ... впрочем, как скажешь.

Да-да, давай, затюнь. Теперь чтоб твой «ультрабыстрый» стрлен работал более-менее быстро требуется не только реаллоками размер строки равнять, но и ещё хип тюнить.

Типичный клоун убогий. Обделался с реаллоком - заигнорил это, продолжая нести какую-то ахинею. Хотя о чём я - ты уже обделался тогда, когда заигнорил длину буфера.

дурачок, не используй слова, значение которых не понимаешь (и узнай наконец сколько «н» в слове «длина»).

Ламерок малоразвитый, зачем ты мне что-то рассказываешь? Узнай.

Фраза «твой говнокод выдаст неверный результат или даже будет переполнение буфера, если изначально буфер выделен существенно большего чем строка размера» никакого инварианта не устанавливает, это просто описание дыры твоего решения. Одной из дыр.

Ламерок, я ведь для тебя, убогого, инвариант определил. Работает в том случае, если длина строки равна длине «аллоцированного куска». Собственно, как и твоя потуга, который работает в том случае, если длина строки не больше длины буфера.

Может потому что я не идиот?

Нет, потому что ты ламерок. Который вчера мыл полы, а сейчас решил мне вещать о чём-то.

Кстати, ты слишком большого о себе мнения: я знаю принципы организации хипа сильно приблизительно

Дак а нахрен ты мне, ламерок, что-то вещаешь? Иди в своё пхп и там что-то кому-то вещая.

но как только ты заикнулся strlen за O(1) для строк на хипе, мысль о пионере, который решил посмотреть размер блока возникла моментально, и была отброшена как явно дурацкая.

Ога.

После того как ты показал код, с перебором вариантов, я понял, что тебе явно нужно сменить профессию. Если увидев такой код ты не сообразил, что ты что-то делаешь не так, то тебе уже ничто не поможет.

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

Ээээ... слово «паттерн» тоже не используй, ты его тоже не понимаешь.

Ну расскажи мне, ламерок, где и почему я его не понимаю. Ты ведь сможешь?

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

Предположим.

Вот перед тобой появилась задача, тебе захотелось быстрый стрлен.

Мне не захотелось. Ты, убогий ламерок, пытаешься выдать этот strlen() за то, что я выдаю за какое-то достижение. Нет, убогий. Это даже близко не моё достижение - это мусор, правда твой потолок даже ниже этого мусора.

И ты готов даже к тому, чтоб твой стрлен ломался после str[0]='\0', типа такое делать никто не будет.

Меня не интересует кто-то, меня не интересует то, что ты и как будешь делать. Я делаю так как хочу, и так, как мне надо, а не тебе.

И вот у тебя идея, просто посмотреть заголовок чанка.

И?

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

Ты явно перепутал свои мечты и то, что вижу и я/то, что есть на самом деле.

Оно не работает через жопу, оно работает так как заявлялось, и в тех условиях, которые были заранее определены. Твои жалкие потуги менять условия - нелепы.

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

Он работает, а вот ты можешь только попёрдывать в лужу.

И эти клоунские «кумир - автор SDS», ога. Не волнуйся, те, на кого действуют подобные потуги - им они не нужны.

Потом выйдет обновление либц или коллега заменит библиотеку для маллока

Не выйдет, не волнуйся. Я не работаю в колхозе - меня это не интересует.

или хотя бы тебе попадётся строка, зааллоченная внутри библиотечной функции и твоя программа посыпется.

Кстати, а откуда они у тебя вообще возьмутся, ведь у тебя строки с длинной. Ты опять путаешься в показаниях, трепло.

Так решил ли ты задачу? Ответ: нет. И даже убедившись, что решение говённое, ты продолжаешь упрямиться.

Да. А вот ламерок пытается своей парой извилиной придумывать какие-то убогие отмазки, которые меня не интересуют и интересовать не должны.

LOL, я тебе первым же сообщением человеческий вариант предложил. Вот, ты только что сам на кривоватый, но более-менее рабочий SDS ссылку давал. Всё лучше чем твоё «я кулхацкер»-решение.

Ога, что ты там давал?

struct string {
   size_t capacity, length;
   char data[1];
};

int main() {
  
  struct string str = "123";
  
  puts(str);
}

main.c: In function ‘main’:
main.c:36:23: error: invalid initializer
   struct string str = "123";
                       ^~~~~
main.c:38:8: error: incompatible type for argument 1 of ‘puts’
   puts(str);

Что-то как-то не работает.

«О боже, мою мегаидею раскритиковали... надо написать слово колхоз как можно большее число раз». Ирония в том, что слово «колхозить» в программировании используется как раз для обозначения кривых самодельных решений, работающих через пень колоду, типа твоего.

Это не критика, это попытка малоразвитого ламерка показать свою осведомлённость. Неудачная.

Меня не волнует твои ирония, как и твоё слово «колхозить», которое я не употреблял.

Есть колхоз, в котором живут ламерки. Которые не знаю ни языка, ни матчасти, которые абсолютно бездарные и убогий нонеймы. Они живут в своём мире, мире убожества и неосиляторства. И постоянно пытаются свои колхозные представления навязать всем остальным.

У колхозника есть пару общих решений, о которых ему рассказали за партой. Вот он и пытается что-то вякать в сторону тех, тех решений, которые созданы, созданы под задачу. Ведь колхозник не может решать задачи.

Колхозник пишет так, как ему показали за партой, так, как ему скажет хозяин. Мнение раба, у которого нет выбора - меня не волнует.

А свойство любого раба - оправдывать своё положение, ассоциировать волю хозяина с волей своей. То же самое касается и неосиляторства. Естественно, что ты никогда не признаешь то, что ты что-то делаешь лишь потому, что тебе повелели - повелело общество, хозяин, ограничили твои способности/возможности.

А вот объясни, зачем мне слушать жертву стокгольмского синдрома о том, что и для кого хорошо. Ты жертва, которая полностью лишена воли, и которая просто не может думать за рамками. Рамками ограничений своих способностей, рамками, определёнными хозяином, партой и прочим. Осознай это.

Ты ещё и врунишка. Нет, клоун, ты попытался кинуть стрелы на, как тебе показалось, авторитетную либу и ты предложил мне пойти и высказать критику великому SDS, написать им исью.

Ога. Смотрим: Создание строки в C (СИ) (комментарий) сюда, и там ещё до этого. Показания ламерка явно не вяжутся с реальностью. Почему? На что это трепло рассчитывает? Что никто не пойдёт и не прочитает?

При этом, я уже всё объяснил. Ламерок начал мне вещать и искать проблемы, но при этом эти проблемы есть и в других решениях, которые «нормальные». Есть чем крыть у ламерка? Нет, он был полностью помножен на ноль.

Что-то ламерок зассал иди писать issues, начал оправдывать авторов. Почему? Запахло жареным седалищем?

Ты можешь, не сомневаюсь. А вот хотя бы немного вменяемый человек на твоём месте посмотрит на тип sds и что-то заподозрит. Он ведь, в отличие от тебя, не гений, съевший собаку на хипе, он подумает, раз значение этой переменной создано некоей хитрой функцией и память также освобождается особым образом, наверное это не просто, возможно не стоит функциям, работающим с sds подсовывать левый char*.

Хорошо, раз ты пошел юлить - учтём это.

А вот ты как раз наоборот, врываешься, гордо неся свою мегафункцию, ни разу не обмолвившись об ограничениях применимости, а когда на них указывают другие, тут же впадаешь в истерику, склоняя «колхоз» на разный лад.

Подожди, колхозник, у меня чётко определенны условия работы функции, как и они определены в SDS, но почему вдруг там нельзя сувать что угодно, а у меня можно?

Кстати, а с чего ты решил, что твоя говнофункция безопаснее чем SDS? Ты так же смотришь на байты перед указателем, там может быть что угодно, ты просто прибавляешь к указателю неизвестно что и лезешь туда обычным strlen'ом.

Заметим, как этот ламерок в контексте «твоя не лучше» называет одно говном, а другео нет. Ссытся ламерок? Ссытся. Такой смешной.

Дак всё же, sds, которого моя говнофункция не безопаснее, является ли говном, либо нет?

Я обещал учесть твои потуги, ну дак вот:

typedef char * ne_dlya_lamerkov_t;

static inline size_t ultrafast_strlen(ne_dlya_lamerkov_t str) {
  
  typedef union {
    size_t data;
      struct {
        size_t __flag0: 1;
        size_t is_mmaped: 1;
        size_t __flag2: 1;
        size_t size: 61;
      };
  } chunk_size_t;
  
  chunk_size_t chunk = {.data = *(size_t *)(str - 8)};
  
  size_t size = chunk.size << 3;
  size_t align = (chunk.is_mmaped ? 4096 : 16);
  size_t overhead = (chunk.is_mmaped ? 16 + 8 : 8);
  size_t end_pos = size - overhead; 
  size_t start_pos = (end_pos - align + 1);
  
  start_pos -= 1;
  
  start_pos = (start_pos < 10) ? 0 : start_pos;
  
  return start_pos + strlen(str + start_pos);
}

Теперь, насколько я понимаю - всё стало норм? Извини, я не особо разбираюсь в представлениях ламерков о том «как надо».

Я ответил и привел контекст. Ты то ли прикидываешься, что не понял, то ли в самом деле тупишь

Тебе задали два вопроса. «что это?»/«к чему это?» - ты ответил на них? Нет. Раз ты не можешь ответить, что свойственно для тебя, то я определяю это за шум.

Ой, да неужели?

Ну, и? Спастил ты - дальше что? Что из этого следует? Если ты написал какую-то ахинею в скобочках, то с чего вдруг она стала ответом, стала следовать из моего поста?

/fixed

Тебе нужно срочно провериться - ты неадекватен. Я такого уже давно не видел, но ничего. Неадекватность решать не мешает. С кого и что я с требую, если ты даже ответить на вопрос «что ты и зачем написал?» - не можешь.

Типичный клоун убогий. Обделался с реаллоком - заигнорил это, продолжая нести какую-то ахинею. Хотя о чём я - ты уже обделался тогда, когда заигнорил длину буфера.

«Ура, оппонент ничего не ответил на реаллок очень блоков памяти, он ничего не знает об использовании ммаппинга, значит можно сделать вид, будто проблемы нет!»

Ламерок, я ведь для тебя, убогого, инвариант определил. Работает в том случае, если длина строки равна длине «аллоцированного куска». Собственно, как и твоя потуга, который работает в том случае, если длина строки не больше длины буфера.

ЛОЛ. Чё ж ты когда его сюда запостил не написал, что твой говнокод работает только в случае и так далее? Ты ж так гордился, что даже не подумал об этом, верно? Про длину буфера убил. Да, моё решение не позволит вставить мегабайт текста в килобайтный буфер, есть такое ограничение. Беда-печаль.

Не выйдет, не волнуйся. Я не работаю в колхозе - меня это не интересует.

Ну предположим, ты реально говнокодишь на себя, и при каждом обновлении либц открываешь исходники и смотришь, не поменялась ли логика работы хипа. Но ты же запостил эту хрень сюда, для колхозников и ни словом ни обмолвился об опасностях такого метода. Пока колхозник тебе на это не указал. Что-то не сходится.

Кстати, а откуда они у тебя вообще возьмутся, ведь у тебя строки с длинной. Ты опять путаешься в показаниях, трепло.

Ты идиот? Впрочем почему я спрашиваю. Не поверишь, в рамках одной программы могут сосуществовать строки с длиной и нультерминированные. Можно в некоторых случаях создать строку с длиной, скопировав из нультерминированной.

Ога, что ты там давал?
..
Что-то как-то не работает.

В этом куске всё прекрасно. И то, что ты вывел ошибку компилятора, т.е. ты набрал очевидно некорректный код ради того, чтоб убедиться, что оно каким-то чудом не откомпилируется. И то, что ты, гений сишечки, увидев структуру вида «массив символов с префиксом» не допёр, что такое не создаётся в стеке. В стеке должен быть указатель на эту структуру. Но самое ржачное, конечно, то, что ты, увидев, как компилятор ругается не попытку некорректного присваивания, которое, если бы произошло, сломало бы нахрен всю программу, решил что это - недостаток реализации.

«Ура, оппонент ничего не ответил на реаллок очень блоков памяти, он ничего не знает об использовании ммаппинга, значит можно сделать вид, будто проблемы нет!»

Чего не ответил? Ты, трепло убогое, написал «копировать посимвольно» - обделался с первым и со вторым. Почему? потому что ламерок.

ЛОЛ. Чё ж ты когда его сюда запостил не написал, что твой говнокод работает только в случае и так далее?

Обожаю этих убогих поломоев, которые о чём-то пытаются рассуждать и кого-то ловить. Это так мило.

Я написал достаточно, при этом я пояснил как он работает и для чего. И что самое интересное, убогое малоразвитое чудовище, я написал этот код в ответ на просьбу, а тебе я вообще ничего, убогий, не показывал. И я ничего и не должен тебе, убогому, показывать и рассказывать.

Ну предположим, ты реально говнокодишь на себя, и при каждом обновлении либц открываешь исходники и смотришь, не поменялась ли логика работы хипа.

Опять ахинея. Они не могут поменяться, как они уже не менялись лет 20. Твои колхозные рассуждения о том, что там что-то поменяется - меня не волнует. Твоё дело полы мыть, а не о чём-то рассуждать. Не перепутай.

А если оно поменяется - я узнаю об этом, не беспокойся.

Но ты же запостил эту хрень сюда, для колхозников и ни словом ни обмолвился об опасностях такого метода.

Нет, ламерок. Я тебе ничего не постил, как и остальным колхозникам.

Пока колхозник тебе на это не указал. Что-то не сходится.

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

Ты идиот? Впрочем почему я спрашиваю. Не поверишь, в рамках одной программы могут сосуществовать строки с длиной и нультерминированные. Можно в некоторых случаях создать строку с длиной, скопировав из нультерминированной.

Колхозник, ты трепался про O(1). У тебя не будет O(1) без использования длины, а использование длины - множит на ноль половину libc. Ты написал мне эту половину либц?

В этом куске всё прекрасно. И то, что ты вывел ошибку компилятора, т.е. ты набрал очевидно некорректный код ради того, чтоб убедиться, что оно каким-то чудом не откомпилируется.

Ты мне сказал, что оно работает. Я поставил вместо char * - не работает. Почему?

И то, что ты, гений сишечки, увидев структуру вида «массив символов с префиксом» не допёр, что такое не создаётся в стеке. В стеке должен быть указатель на эту структуру.

Ой, ламерок, а с чего я должен допирать? Ведь ты не допёр, как использовать мою функцию. Ты об этом написал, как использовать твоё дерьмо? Нет.

Но самое ржачное, конечно, то, что ты, увидев, как компилятор ругается не попытку некорректного присваивания, которое, если бы произошло, сломало бы нахрен всю программу, решил что это - недостаток реализации.

Оно не работает. char * у меня работает, почему? Оказывается, что твой колхоз в стеке не работает - нахрен мне твой мусор, который не работает?

Оказывается, что у тебя есть какие-то ограничения, которые ты не описал? А выдавал, в отличии от меня, за полностью функциональное решение.

Хотя что с трепла ещё взять. Обделался в своих же потугах. Днище убогое.

Чего не ответил?

Кавычки в тексте обычно что-то значат. В данном случае они означали, что текст изображает тебя, ты обделался со своим реаллоком, а когда тебе указали, схватился как за соломинку за то, что иногда реаллок данные не копирует. Да, согласен, иногда не копирует. А иногда и копирует. Этого достаточно, клоун.

Они не могут поменяться, как они уже не менялись лет 20

В этом весь ты. Ни убавить, не прибавить. Полный идиот.

Колхозник, ты трепался про O(1). У тебя не будет O(1) без использования длины, а использование длины - множит на ноль половину libc. Ты написал мне эту половину либц?

Ээээ... Ты серьёзно вообще? Половина либц и в твоём и в моём случае будет работать с нультерминированным char*. И длину она будет считать strlen'ом. Обычным, не ультрафаст.

Ладно, раз ты тупой, поясню. В своём коде ты бы использовал kolhoz_str, который псевдоним указателю на приведённую тебе структуру. Когда тебе понадобился бы char*, ты вызвал бы функцию kolhoz_str_to_cstr, которая состояла бы из одной строчки «return arg? &arg->data: NULL;».

Оно не работает. char * у меня работает, почему?

Потому что ты - идиот? Не, серьёзно, ты ожидал возможности прозрачной замены одного типа на другой на сишечке? Может тебе в джаваскрипт податься? Кстати, если бы ты строковой литерал не пытался присвоить структурке, а взял бы да передал его в твою ультрафаст-функцию, то у тебя бы всё скомпилялось, но в рантайме всё бы грохнулось. Поэтому я тебе и объясняю, моё решение лучше чем SDS и, тем более, лучше чем твой говнокод.

Кавычки в тексте обычно что-то значат. В данном случае они означали, что текст изображает тебя, ты обделался со своим реаллоком, а когда тебе указали, схватился как за соломинку за то, что иногда реаллок данные не копирует. Да, согласен, иногда не копирует. А иногда и копирует. Этого достаточно, клоун.

Ну давай, трепло. Где именно схватился, за какую соломинку. Цитаты давай, трепло.

Ну давай, трепло. Где именно схватился, за какую соломинку. Цитаты давай, трепло

Ну пройди по цепочке цитат

Ведь длинна берётся именно из интернета.

А царь то ненастоящий. Оригинал то хоть и был троллем, но в теме соображал.

А царь то ненастоящий. Оригинал то хоть и был троллем, но в теме соображал.

Предыдущие инкарнации «соображали в теме» не лучше этой и и точно так же виляли. Царь вполне настоящий и скоро вернется.