IBM kupuje společnost HashiCorp (Terraform, Packer, Vault, Boundary, Consul, Nomad, Waypoint, Vagrant, …) za 6,4 miliardy dolarů, tj. 35 dolarů za akcii.
Byl vydán TrueNAS SCALE 24.04 “Dragonfish”. Přehled novinek této open source storage platformy postavené na Debianu v poznámkách k vydání.
Oznámeny byly nové Raspberry Pi Compute Module 4S. Vedle původní 1 GB varianty jsou nově k dispozici také varianty s 2 GB, 4 GB a 8 GB paměti. Compute Modules 4S mají na rozdíl od Compute Module 4 tvar a velikost Compute Module 3+ a předchozích. Lze tak provést snadný upgrade.
Po roce vývoje od vydání verze 1.24.0 byla vydána nová stabilní verze 1.26.0 webového serveru a reverzní proxy nginx (Wikipedie). Nová verze přináší řadu novinek. Podrobný přehled v souboru CHANGES-1.26.
Byla vydána nová verze 6.2 živé linuxové distribuce Tails (The Amnesic Incognito Live System), jež klade důraz na ochranu soukromí uživatelů a anonymitu. Přehled změn v příslušném seznamu. Tor Browser byl povýšen na verzi 13.0.14.
Byla vydána nová verze 30.0.0 frameworku pro vývoj multiplatformních desktopových aplikací pomocí JavaScriptu, HTML a CSS Electron (Wikipedie, GitHub). Chromium bylo aktualizováno na verzi 124.0.6367.49, V8 na verzi 12.4 a Node.js na verzi 20.11.1. Electron byl původně vyvíjen pro editor Atom pod názvem Atom Shell. Dnes je na Electronu postavena celá řada dalších aplikací.
Byla vydána nová verze 9.0.0 otevřeného emulátoru procesorů a virtualizačního nástroje QEMU (Wikipedie). Přispělo 220 vývojářů. Provedeno bylo více než 2 700 commitů. Přehled úprav a nových vlastností v seznamu změn.
Evropský parlament dnes přijal směrnici týkající se tzv. práva spotřebitele na opravu. Poslanci ji podpořili 584 hlasy (3 bylo proti a 14 se zdrželo hlasování). Směrnice ujasňuje povinnosti výrobců opravovat zboží a motivovat spotřebitele k tomu, aby si výrobky nechávali opravit a prodloužili tak jejich životnost.
Bylo oznámeno (cs) vydání Fedora Linuxu 40. Přehled novinek ve Fedora Workstation 40 a Fedora KDE 40 na stránkách Fedora Magazinu. Současně byl oznámen notebook Slimbook Fedora 2.
ČTK (Česká tisková kancelář) upozorňuje (X), že na jejím zpravodajském webu České noviny byly dnes dopoledne neznámým útočníkem umístěny dva smyšlené texty, které nepocházejí z její produkce. Jde o text s titulkem „BIS zabránila pokusu o atentát na nově zvoleného slovenského prezidenta Petra Pelligriniho“ a o údajné mimořádné prohlášení ministra Lipavského k témuž. Tyto dezinformace byly útočníky zveřejněny i s příslušnými notifikacemi v mobilní aplikaci Českých novin. ČTK ve svém zpravodajském servisu žádnou informaci v tomto znění nevydala.
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: