Alyssa Rosenzweig se v příspěvku na svém blogu Vulkan 1.3 na M1 za 1 měsíc rozepsala o novém Vulkan 1.3 ovladači Honeykrisp pro Apple M1 splňujícím specifikaci Khronosu. Vychází z ovladače NVK pro GPU od Nvidie. V plánu je dále rozchodit DXVK a vkd3d-proton a tím pádem Direct3D, aby na Apple M1 s Asahi Linuxem běžely hry pro Microsoft Windows.
Byla vydána (𝕏) květnová aktualizace aneb nová verze 1.90 editoru zdrojových kódů Visual Studio Code (Wikipedie). Přehled novinek i s náhledy a animovanými gify v poznámkách k vydání. Ve verzi 1.90 vyjde také VSCodium, tj. komunitní sestavení Visual Studia Code bez telemetrie a licenčních podmínek Microsoftu.
Byla vydána (Mastodon, 𝕏) nová verze 2024.2 linuxové distribuce navržené pro digitální forenzní analýzu a penetrační testování Kali Linux (Wikipedie). Přehled novinek se seznamem nových nástrojů v oficiálním oznámení.
Počítačová hra Tetris slaví 40 let. Alexej Pažitnov dokončil první hratelnou verzi 6. června 1984. Mezitím vznikla celá řada variant. Například Peklo nebo Nebe. Loni měl premiéru film Tetris.
MicroPython (Wikipedie), tj. implementace Pythonu 3 optimalizovaná pro jednočipové počítače, byl vydán ve verzi 1.23.0. V přehledu novinek je vypíchnuta podpora dynamických USB zařízení nebo nové moduly openamp, tls a vfs.
Canonical vydal Ubuntu Core 24. Představení na YouTube. Nová verze Ubuntu Core vychází z Ubuntu 24.04 LTS a podporována bude 12 let. Ubuntu Core je určeno pro IoT (internet věcí) a vestavěné systémy.
Databáze DuckDB (Wikipedie) dospěla po 6 letech do verze 1.0.0.
Intel na veletrhu Computex 2024 představil (YouTube) mimo jiné procesory Lunar Lake a Xeon 6.
Na blogu Raspberry Pi byl představen Raspberry Pi AI Kit určený vlastníkům Raspberry Pi 5, kteří na něm chtějí experimentovat se světem neuronových sítí, umělé inteligence a strojového učení. Jedná se o spolupráci se společností Hailo. Cena AI Kitu je 70 dolarů.
Byla vydána nová verze 14.1 svobodného unixového operačního systému FreeBSD. Podrobný přehled novinek v poznámkách k vydání.
namespace { template<typename CharType = wchar_t> std::basic_istream<CharType>& operator>>(std::basic_istream<CharType>& inputStream, std::basic_string<CharType>& line) { std::getline(inputStream, line); return inputStream; } } template<typename CharType = char> auto ReadLines(std::wstring path) { auto inputStream = new std::ifstream(path); using iterator = std::istream_iterator<std::basic_string<CharType>>; auto begin = std::shared_ptr<iterator>( new iterator(*inputStream), [inputStream](auto* iterator) { delete iterator; delete inputStream; } ); return begin; }Je toto správne riešenie? Alebo na to idem zle? Lebo fungovať mi to funguje. Ak viete o niečom priamočiarejšom tak sem s tým. Ďakujem.
auto begin = ReadLines(L"c:\test\newFile21.txt"); for (auto it = *begin; it != std::istream_iterator<std::string>(); ++it) { std::cout << ":" << *it << "n"; }
#include <fstream> #include <iostream> #include <stdexcept> template <typename T> void read_lines(const std::string &path, T &&handler) { std::ifstream s{}; s.open(path); if (!s.is_open()) throw std::runtime_error{"Cannot open file"}; std::string str{}; while (std::getline(s, str).good()) handler(str); } int main() { try { read_lines("abc.txt", [](const std::string &s) { std::cout << s << std::endl; }); } catch (const std::runtime_error &ex) { std::cout << ex.what() << std::endl; } return 0; }
Začal bych od jednoduchého příkladu — implicitní iterace po slovech. To se zařídí třeba takhle:
#include <fstream> #include <iostream> #include <iterator> #include <string> namespace { template<typename C> struct ifstream_iterable { ifstream_iterable(const std::string &path) : stream_{path} {} auto begin() { return iterator{stream_}; } auto end() { return iterator{}; } private: typedef std::istream_iterator<std::basic_string<C>, C> iterator; std::basic_ifstream<C> stream_; }; } // namespace int main() { for (auto &w : ifstream_iterable<wchar_t>{"/proc/cpuinfo"}) std::wcout << w << std::endl; }
To bychom měli. Teď je otázka, jak z toho^^^ udělat iteraci po řádcích. Předně pár poznámek k tématu:
>>
je mírně špatně v mezích zákona, protože deklarace je hodně podobná této deklaraci v headeru <string>
, což sice na první pohled nevadí, ale na druhý pohled tam hraje roli až příliš mnoho složitých detailů kolem pravidel pro hledání identifikátorů. Drobná změna standardu a/nebo (kni)hovny může vést k tomu, že operátor se buď vůbec nepoužije, nebo začne být v konfliktu s operátory z (kni)hovny. Drobnou modifikací se mi podařilo vyrobit (proti)příklad, kdy clang++
i g++
kód přeloží bez varování, ale g++
„přetížený“ operátor použije, zatímco clang++
nikoliv.std::string
(což je sice technicky možné, ale z hlediska kompatibility a udržovatelnosti kódu je vhodné se takových nápadů vyvarovat)Co tedy podniknout? Třeba tohle:
#include <fstream> #include <iostream> #include <iterator> #include <string> #include <utility> namespace { template <typename C> struct line { std::basic_istream<C>& operator <<(std::basic_istream<C> &stream) { std::getline(stream, str_); return stream; } operator const std::basic_string<C>&() const & { return str_; } operator std::basic_string<C>&() & { return str_; } // zde se nepoužije operator std::basic_string<C>() && { return std::move(str_); } // -dtto- private: std::basic_string<C> str_; }; template <typename C> std::basic_istream<C>& operator >>(std::basic_istream<C> &stream, line<C> &str) { str << stream; return stream; } template<typename C> struct ifstream_iterable { ifstream_iterable(const std::string &path) : stream_{path} {} auto begin() { return iterator{stream_}; } auto end() { return iterator{}; } private: typedef std::istream_iterator<line<C>, C> iterator; std::basic_ifstream<C> stream_; }; } // namespace int main() { for (const std::wstring &l : ifstream_iterable<wchar_t>{"/proc/cpuinfo"}) std::wcout << l << std::endl; }
Tohle^^^ nedědí od základních typů, nevyvolává příliš mnoho nespecifikovaných rohových případů, nepoužívá kámoše a vystačí si s jednou třídou (dělnickou), kterou lze konvertovat na odpovídající string
. (Pro složitější konverze do jiného API si lze napsat deduction guides, ale to už je jiné téma. V této podobě se kód přeloží s C++ 14, 17 i 20, zatímco s deduction guides by vyžadoval minimálně C++17.)
Ještě závěrem dodám (a předejdu tak, doufám, některým komentářům), že někteří lidé mají utkvělou špatnou představu o sousloví return std::move(...);
— myslí si, že něco takového nedává smysl a že by to nemělo existovat. Samozřejmě se mýlí, jak jinak; tady jsou k tomu předdrobnosti i podrobnosti.
A když nad tím znova přemýšlím (což rozhodně nedělám často), čitelnější to bude bez toho nestandardního operátoru <<
, který nijak neinteraguje s (kni)hovnou a jenom všeho všudy mate čtenáře (včetně mě). Takže raději třeba takto:
#include <fstream> #include <iostream> #include <iterator> #include <string> #include <utility> namespace { template <typename C> struct line { operator const std::basic_string<C>&() const & { return str_; } operator std::basic_string<C>&() & { return str_; } operator std::basic_string<C>() && { return std::move(str_); } // nepoužito private: std::basic_string<C> str_; }; template <typename C> std::basic_istream<C>& operator >>(std::basic_istream<C> &stream, line<C> &str) { std::getline(stream, static_cast<std::basic_string<C>&>(str)); return stream; } template<typename C> struct ifstream_iterable { ifstream_iterable(const std::string &path) : stream_{path} {} auto begin() { return iterator{stream_}; } auto end() { return iterator{}; } private: typedef std::istream_iterator<line<C>, C> iterator; std::basic_ifstream<C> stream_; }; } // namespace int main() { for (const std::wstring &l : ifstream_iterable<wchar_t>{"/proc/cpuinfo"}) std::wcout << l << std::endl; }
Ale ak pri smartpointeroch používate deleter tak sa použitiu delete nevyhnete.
To je sice pravda, ale právě nadužívání dynamické alokace je u C++ poměrně častá chyba. Zrovna třeba statement delete iterator;
není dobrý nápad (a kdekoho přiměje zvednout obočí), protože iterátor má být (a většinou je) malý kousek dat (něco jako 16 B, dejme tomu), který se dá a má předávat všude hodnotou. (Samozřejmě kromě případu, kdy je potřeba z více míst měnit jeden iterátor, tj. mít něco jako dvouhvězdičkový pointer.)
Ještě bych poznamenal, jen tak pro úplnost, že příklad v dotazu by byl lepší s použitím std::unique_ptr
místo std::shared_ptr
. Zatímco std::unique_ptr
je jednoduchý zapouzdřený pointer, který vyjadřuje exkluzivní vlastnictví a vlastní z jednoho kontextu jeden kousek dat, std::shared_ptr
je složitá mašinerie s atomickým reference-countingem. Uvnitř v implementaci std::shared_ptr
neukazuje přímo na data, která spravuje, nýbrž na svou vlastní dynamickou strukturu, ve které má (kromě pointeru) také atomické počítadlo referencí a pár dalších vychytávek. (Dlužno navíc dodat, v souvislosti s atomickým počítadlem, že jedna atomická instrukce může stát čas srovnatelný s řádově tisícem sčítání.) Dá se říct, že std::shared_ptr
je v jistém smyslu thread-safe, byť s omezeními:
std::shared_ptr
, každou z jiného vlákna, lze používat paralelně zcela bez omezení.std::shared_ptr
několika vlákny (například rozumně atomické přiřazení toho sdíleného pointeru) ovšem samo od sebe atomické není; k tomu slouží specializace std::atomic<std::shared_ptr<...>>
.Zkrátka a dobře (nebo zdlouha a špatně, teď nevím),
std::unique_ptr
místo std::shared_ptr
, je to jasná volba, zejména z hlediska efektivity a jednoznačnosti vlastnictví objektů. Atomický reference-counting je potřebný jenom velmi zřídka, nikoliv zhusta.Tiskni Sdílej: