Před 32 lety, 6. června 1993, byl spuštěn první český WWW server (ještě pod TLD .cs), pro potřeby fyziků zabývajících se problematikou vysokých energií.
Střílečku Borderlands 2 lze v rámci výprodeje série Borderlands na Steamu získat zdarma napořád, když aktivaci provedete do 8. června 19:00.
Byla vydána nová verze 2.22 svobodného video editoru Flowblade (GitHub, Wikipedie). Přehled novinek v poznámkách k vydání. Videoukázky funkcí Flowblade na Vimeu. Instalovat lze také z Flathubu.
Canonical Launchpad vypíná systém správy verzí Bazaar. Vývojáři mohou své repozitáře do 1. září přemigrovat na Git.
Byla vydána nová verze 2.53.21 svobodného multiplatformního balíku internetových aplikací SeaMonkey (Wikipedie). Přehled novinek v poznámkách k vydání.
Petici za povinné zveřejnění zdrojových kódů softwaru použitých ve veřejné správě lze podepsat na ePetice.
Na Indiegogo byla spuštěna kampaň na podporu linuxového telefonu Liberux NEXX s osmijádrovým procesorem Rockchip RK3588S, 32 GB LPDDR4x RAM a 6.34″ 2400×1080 OLED displejem. Cena telefonu je 1 310 eur.
Miro Hrončok vyhrál volby do Fedora Council. Mezi sedmi kandidáty, kteří se ucházeli o dvě křesla, nakonec získal nejvíce hlasů - 1089. Česká komunita má tak po delší době opět zástupce v nejvyšším orgánu Fedory.
Redox OS (Wikipedie), tj. mikrokernelový unixový operační systém naprogramovaný v programovacím jazyce Rust, nově podporuje X11 a GTK 3.
Dnes po celém světě startuje prodej herní konzole Nintendo Switch 2.
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: