Spolek OpenAlt zve příznivce otevřených řešení a přístupu na 211. sraz, který proběhne v pátek 19. září od 18:00 ve Studentském klubu U Kachničky na Fakultě informačních technologií Vysokého učení technického na adrese Božetěchova 2/1. Na srazu proběhne přednáška Jiřího Eischmanna o nové verzi prostředí GNOME 49. Nemáte-li možnost se zúčastnit osobně, přednáškový blok bude opět streamován živě na server VHSky.cz a následně i zpřístupněn záznam.
Microsoft se vyhnul pokutě od Evropské komise za zneužívání svého dominantního postavení na trhu v souvislosti s aplikací Teams. S komisí se dohodl na závazcích, které slíbil splnit. Unijní exekutivě se nelíbilo, že firma svazuje svůj nástroj pro chatování a videohovory Teams se sadou kancelářských programů Office. Microsoft nyní slíbil jasné oddělení aplikace od kancelářských nástrojů, jako jsou Word, Excel a Outlook. Na Microsoft si
… více »Samba (Wikipedie), svobodná implementace SMB a Active Directory, byla vydána ve verzi 4.23.0. Počínaje verzí Samba 4.23 jsou unixová rozšíření SMB3 ve výchozím nastavení povolena. Přidána byla podpora SMB3 přes QUIC. Nová utilita smb_prometheus_endpoint exportuje metriky ve formátu Prometheus.
Správcovský tým repozitáře F-Droid pro Android sdílí doporučení, jak řešit žádosti o odstranění nelegálního obsahu. Základem je mít nastavené formální procesy, vyhrazenou e-mailovou adresu a být transparentní. Zdůrazňují také důležitost volby jurisdikce (F-Droid je v Nizozemsku).
Byly publikovány informace o další zranitelnosti v procesorech. Nejnovější zranitelnost byla pojmenována VMScape (CVE-2025-40300, GitHub) a v upstream Linuxech je již opravena. Jedná se o variantu Spectre. KVM host může číst data z uživatelského prostoru hypervizoru, např. QEMU.
V červenci loňského roku organizace Apache Software Foundation (ASF) oznámila, že se částečně přestane dopouštět kulturní apropriace a změní své logo. Dnes bylo nové logo představeno. "Indiánské pírko" bylo nahrazeno dubovým listem a text Apache Software Foundation zkratkou ASF. Slovo Apache se bude "zatím" dál používat. Oficiální název organizace zůstává Apache Software Foundation, stejně jako názvy projektů, například Apache HTTP Server.
Byla vydána (𝕏) srpnová aktualizace aneb nová verze 1.104 editoru zdrojových kódů Visual Studio Code (Wikipedie). Přehled novinek i s náhledy a videi v poznámkách k vydání. Ve verzi 1.104 vyjde také VSCodium, tj. komunitní sestavení Visual Studia Code bez telemetrie a licenčních podmínek Microsoftu.
Spotify spustilo přehrávání v bezztrátové kvalitě. V předplatném Spotify Premium.
Spoluzakladatel a předseda správní rady americké softwarové společnosti Oracle Larry Ellison vystřídal spoluzakladatele automobilky Tesla a dalších firem Elona Muska na postu nejbohatšího člověka světa. Hodnota Ellisonova majetku díky dnešnímu prudkému posílení ceny akcií Oraclu odpoledne vykazovala nárůst o více než 100 miliard dolarů a dosáhla 393 miliard USD (zhruba 8,2 bilionu Kč). Hodnota Muskova majetku činila zhruba 385 miliard dolarů.
Bylo vydáno Eclipse IDE 2025-09 aneb Eclipse 4.37. Představení novinek tohoto integrovaného vývojového prostředí také na YouTube.
void test1(std::string_view str) { }môžeme ju zavolať s hodnotou typu const char* ktorá sa automaticky skonvertuje na std::string_view:
test1("Lorem ipsum");tiež ju môžme zavolať s std::stringom:
using namespace std::literals::string_literals; //skový literál pre std::string test1("Lorem ipsum"s);implicitná konverzia na std::string_view funguje keď máme zadefinovaný konkrétny typ charu. Keď si ale definujeme generickú funkciu (šablónu) pre akýkoľvek typ charu:
template<typename C = wchar_t> void generic_test(std::basic_string_view<C> str) { }tak nám funguje toto:
generic_test(std::string_view("123"));aj toto:
generic_test(std::wstring_view(L"123"));ale už nám nefunguje implicitná konverzia z iného typu, ak pri tom chceme automaticky "dopočítať" typ charu:
generic_test(L"123"); // chyba - konverzia z const wchar_t* generic_test("123"); // chyba - konverzia z const char* generic_test("123"s); // chyba - konverzia z std::stringsamozrejme ak ten typ rovno uvedieme tak všetko funguje ok:
generic_test<wchar_t>(L"123"); // ok - konverzia z const wchar_t* generic_test<char>("123"); // ok - konverzia z const char* generic_test<wchar_t>(L"123"s); // ok - konverzia z std::wstringAle to je zbytočne otravné písanie. Existuje na tento problém nejaké riešenie? Z iných jazykov som zvyknutý neuvádzať generické parametre, ako to neni nevyhnutné (zlepšuje mi to čitateľnosť kódu) no popritom by som rád využil bohaté možnosti implicitnej konverzie, ktoré C++ ponúka.
Řešení dotazu:
Obecně nemá překladač jak určit šablonu, ale jsou metody jak překladači pomoci, aby se nemusel udávat konkrétní typ.
#include <string_view>
#include <string>
using namespace std::literals;
template<typename Char>
void generic_test([[maybe_unused]]std::basic_string_view<Char> str){}
// make funkce pro c-string
template<typename Char>
std::basic_string_view<Char, std::char_traits<Char>> make_view(const Char* str) {
return {str};
}
// make funkce pro base_string
template<typename Char, typename Traits, typename Allocator>
std::basic_string_view<Char, Traits> make_view(const std::basic_string<Char, Traits, Allocator>& str) {
return {str};
}
// deduction guide
namespace std {
template<typename Char, class Traits>
basic_string_view(const std::basic_string<Char, Traits>&) -> basic_string_view<Char, Traits>;
}
int main() {
// make funkce
generic_test(make_view(L"123"));
generic_test(make_view("123"));
generic_test(make_view("123"s));
// deduction guides
generic_test(std::basic_string_view{L"123"});
generic_test(std::basic_string_view{"123"});
generic_test(std::basic_string_view{"123"s});
// sv literal
generic_test(L"123"sv);
generic_test("123"sv);
return 0;
};
PS.: Zdroják vkládám jen jako automaticky převedný text do html, protože <pre> tag mi zde nepovoluje znaky < a >.
Tím jsi chtěl obecenstvu sdělit, že nemáš nainstalovaný sed
? Jinak tuhle poznámku fakt nechápu.
Nevím co je na mém příspěvku nepochopitelného.Slovo přepisovat.
Výborně. Těší mě, že sis dohledal význam toho slova, který jsi (zjevně) dosud nechápal.
A teď už jistě víš, že jsi to slovo používal nesprávně a že v tomto případě není potřeba nic přepisovat.
sed -e 's/</\</g' -e 's/>/\>/g' FILE.cpp
Ještě &
; je dobré nahradit (i když to není tak důležité). Jenom kdyby někdo měl náhodou třeba proměnnou mdash
a statement pointer = —
…
kdybyste to oldoj rači vopravily to formátování ;D
sem to přesedila ajeto :D ;D
#include <string_view> #include <string> using namespace std::literals; template<typename Char> void generic_test([[maybe_unused]]std::basic_string_view<Char> str){} // make funkce pro c-string template<typename Char> std::basic_string_view<Char, std::char_traits<Char>> make_view(const Char* str) { return {str}; } // make funkce pro base_string template<typename Char, typename Traits, typename Allocator> std::basic_string_view<Char, Traits> make_view(const std::basic_string<Char, Traits, Allocator>& str) { return {str}; } // deduction guide namespace std { template<typename Char, class Traits> basic_string_view(const std::basic_string<Char, Traits>&) -> basic_string_view<Char, Traits>; } int main() { // make funkce generic_test(make_view(L"123")); generic_test(make_view("123")); generic_test(make_view("123"s)); // deduction guides generic_test(std::basic_string_view{L"123"}); generic_test(std::basic_string_view{"123"}); generic_test(std::basic_string_view{"123"s}); // sv literal generic_test(L"123"sv); generic_test("123"sv); return 0; };
#include <string> #include <string_view> #include <type_traits> #include <iostream> using namespace std::literals; template <typename CharT> void prn(const std::basic_string_view<CharT> &); template <> void prn(const std::basic_string_view<char> &sv) { std::cout << "(char)" << sv << std::endl; } template <> void prn(const std::basic_string_view<wchar_t> &sv) { std::wcout << "(wchar_t)" << sv << std::endl; } template <typename CharT> void generic_test(const std::basic_string_view<CharT> &sw) { std::cout << "string_view -> "; prn(sw); } template <typename T> void generic_test(T str) { std::cout << "literal/char_ptr -> "; using C = typename std::remove_cv<typename std::remove_pointer<typename std::decay<T>::type>::type>::type; std::basic_string_view<C> sw{str}; generic_test<C>(sw); } template <typename C, typename T, typename A> void generic_test(const std::basic_string<C, T, A> &str) { std::cout << "basic_string -> "; std::basic_string_view<C> sw{str}; generic_test<C>(sw); } int main() { generic_test("abc"); generic_test(L"abc"); generic_test("abc"s); generic_test(L"abc"s); char a[4] = "abc"; generic_test(a); wchar_t wa[4] = L"abc"; generic_test(wa); std::string s = "abc"; generic_test(s); std::wstring ws = L"abc"; generic_test(ws); generic_test(s.c_str()); generic_test(ws.c_str()); generic_test("abc"sv); generic_test(L"abc"sv); return 0; }
Konverze znakové sady je v následujících příkladech sice pouhý technický detail nesouvisející s dotazem, nicméně i tak jsem chtěl upozornit na fakt, že vstup / výstup s wchar_t
a char
najednou v jednom programu je docela nepříjemný problém (bez vhodných (kni)hoven pro konverzi znakové sady atd.).
Například zápis do std::wcout
a std::cout
se nesmí vzájemně kombinovat, protože to vede k nedefinovanému chování. Pročež jediný způsob, jak vyzkoušet úzké i široké stringy najednou, je převést všechno na společnou reprezentaci. Protože to nebylo předmětem dotazu, zprasil jsem tuto část implementace naprosto libovolně.
V obou následujících příkladech je potřeba kompilátoru napovědět, v každém jinak:
#include <codecvt> #include <iostream> #include <iterator> #include <locale> #include <string> #include <string_view> #include <type_traits> #include <utility> namespace { constexpr char SOURCE_LOCALE[]{"cs_CZ.UTF-8"}; constexpr char OUTPUT_LOCALE[]{"cs_CZ.UTF-8"}; using namespace std::string_literals; template <typename Container> using Element = std::remove_const_t< std::remove_reference_t<decltype(*std::begin(std::declval<Container&>()))>>; struct Cvt : public std::codecvt_byname<wchar_t, char, std::mbstate_t> { public: Cvt() : std::codecvt_byname<wchar_t, char, std::mbstate_t>(SOURCE_LOCALE) {} ~Cvt() = default; }; void generic_test(std::basic_string_view<wchar_t> str) { std::wcout << L"wchar_t: " << str << std::endl; } void generic_test(std::basic_string_view<char> str) { std::wstring_convert<Cvt, wchar_t> convert; // deprecated! std::wcout << L" char: " << convert.from_bytes({str.begin(), str.end()}) << std::endl; } } // namespace namespace std { template <typename Container> basic_string_view(Container &&) -> basic_string_view<Element<Container>>; template <typename Char, size_t Size> basic_string_view(Char(&&)[Size]) -> basic_string_view<Char>; } // namespace std int main() { std::ios_base::sync_with_stdio(false); // nebo std::setlocale(...); std::wcout.imbue(std::locale(OUTPUT_LOCALE)); generic_test(L"123"); generic_test("123"); generic_test("123"s); generic_test(L"ěščřžýáíéďťňóúů"); generic_test(std::wstring{L"ěščřžýáíéďťňóúů"}); generic_test(u8"ěščřžýáíéďťňóúů"); generic_test(u8"ěščřžýáíéďťňóúů"s); }
#include <codecvt> #include <iostream> #include <iterator> #include <locale> #include <string> #include <string_view> #include <type_traits> #include <utility> namespace { constexpr char SOURCE_LOCALE[]{"cs_CZ.UTF-8"}; constexpr char OUTPUT_LOCALE[]{"cs_CZ.UTF-8"}; using namespace std::string_literals; struct Cvt : public std::codecvt_byname<wchar_t, char, std::mbstate_t> { public: Cvt() : std::codecvt_byname<wchar_t, char, std::mbstate_t>(SOURCE_LOCALE) {} ~Cvt() = default; }; template <typename Container> using Element = std::remove_const_t< std::remove_reference_t<decltype(*std::begin(std::declval<Container&>()))>>; template <template <typename Char, typename... Args> class View, typename Char, typename... Args, typename IsWide> void generic_test_impl(View<Args...> str, IsWide); template <template <typename Char, typename... Args> class View, typename Char, typename... Args> void generic_test_impl(View<Char, Args...> str, std::enable_if_t<(sizeof(Char) > 1)>* = nullptr) { std::wcout << L"wchar_t: " << str << std::endl; } template <template <typename Char, typename... Args> class View, typename Char, typename... Args> void generic_test_impl(View<Char, Args...> str, std::enable_if_t<(sizeof(Char) == 1)>* = nullptr) { std::wstring_convert<Cvt, wchar_t> convert; // deprecated! std::wcout << L" char: " << convert.from_bytes({str.begin(), str.end()}) << std::endl; } template <typename StrType> void generic_test(StrType&& str) { generic_test_impl( std::basic_string_view<Element<StrType>>{std::forward<StrType>(str)}); } } // namespace int main() { std::ios_base::sync_with_stdio(false); // nebo std::setlocale(...); std::wcout.imbue(std::locale(OUTPUT_LOCALE)); generic_test(L"123"); generic_test("123"); generic_test("123"s); generic_test(L"ěščřžýáíéďťňóúů"); generic_test(std::wstring{L"ěščřžýáíéďťňóúů"}); generic_test(u8"ěščřžýáíéďťňóúů"); generic_test(u8"ěščřžýáíéďťňóúů"s); }
#include <codecvt> #include <iostream> #include <iterator> #include <locale> #include <string> #include <string_view> #include <type_traits> #include <utility> namespace { constexpr char SOURCE_LOCALE[]{"cs_CZ.UTF-8"}; constexpr char OUTPUT_LOCALE[]{"cs_CZ.UTF-8"}; using namespace std::string_literals; struct Cvt : public std::codecvt_byname<wchar_t, char, std::mbstate_t> { public: Cvt() : std::codecvt_byname<wchar_t, char, std::mbstate_t>(SOURCE_LOCALE) {} ~Cvt() = default; }; template <typename Container> using Element = std::remove_const_t< std::remove_reference_t<decltype(*std::begin(std::declval<Container&>()))>>; template <typename Char, typename... Args> struct generic_test { template <typename IsWide = std::bool_constant<(sizeof(Char) > 1)>> generic_test(std::basic_string_view<Char, Args...> str, IsWide is_wide = IsWide{}) { generic_test_impl(str, is_wide); } private: static void generic_test_impl(std::basic_string_view<Char, Args...> str, std::true_type) { std::wcout << L"wchar_t: " << str << std::endl; } static void generic_test_impl(std::basic_string_view<Char, Args...> str, std::false_type) { std::wstring_convert<Cvt, wchar_t> convert; // deprecated! std::wcout << L" char: " << convert.from_bytes({str.begin(), str.end()}) << std::endl; } }; template <typename Container> generic_test(Container &&) -> generic_test<Element<Container>>; template <typename Char, size_t Size> generic_test(Char(&&)[Size]) -> generic_test<Char>; template <typename Char> generic_test(const Char*) -> generic_test<Char>; } // namespace int main() { std::ios_base::sync_with_stdio(false); // nebo std::setlocale(...); std::wcout.imbue(std::locale(OUTPUT_LOCALE)); generic_test(L"123"); generic_test("123"); generic_test("123"s); generic_test(L"ěščřžýáíéďťňóúů"); generic_test(std::wstring{L"ěščřžýáíéďťňóúů"}); generic_test(u8"ěščřžýáíéďťňóúů"); generic_test(u8"ěščřžýáíéďťňóúů"s); }
Rozumim.
Abych jen neremcal, osobne bych to slepil asi takhle:
template<typename T> void generic_test(std::basic_string_view<T> str) { std::cout << "tady se neco deje\n"; } template<typename T> void generic_test(T* t) { generic_test(std::basic_string_view<T> (t)); } template<typename T> void generic_test(std::basic_string<T> s) { generic_test(s.data()); }
klasicky overload.
Zalezi ale, co se ma stat s str uvnitr te funkce; v C++ neni nejaky genericky std::cout, napriklad. Je otazka, jestli stoji za to ten typ nesjednotit (kdyz pouzivas vsude wchar_t).
Jen pamatuj, vic templatu neznamena vic do hloubky.
Pri volani funkce je povolena pouze jedna implicitni konverze, ty se snazis o dve, a proto to nefunguje.
Není nutné sveřepě aplikovat omezení platná do C++14 v roce 2020. Pokud někdo divoké implicitní konverze potřebuje (nebo si myslí, že je potřebuje), může použít deduction guides. (Například já takové konverze nepotřebuju, ale chci je. Jako tenkrát v té reklamě ve stylu a potřebujete vůbec tento vůz.)
…naucis se leda prasit…
Leda? Prasení je mimořádně důležitá dovednost.
Tiskni
Sdílej: