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.
T-Mobile od 15. září zpřístupňuje RCS (Rich Communication Services) zprávy i pro iPhone.
Společnost ARM představila platformu Arm Lumex s Arm C1 CPU Cluster a Arm Mali G1-Ultra GPU pro vlajkové chytré telefony a počítače nové generace.
Unicode Consortium, nezisková organizace koordinující rozvoj standardu Unicode, oznámila vydání Unicode 17.0. Přidáno bylo 4 803 nových znaků. Celkově jich je 159 801. Přibylo 7 nových Emoji.
Apple představil (YouTube) telefony iPhone 17 Pro a iPhone 17 Pro Max, iPhone 17 a iPhone Air, sluchátka AirPods Pro 3 a hodinky Watch Series 11, Watch SE 3 a Watch Ultra 3.
Realtimová strategie Warzone 2100 (Wikipedie) byla vydána ve verzi 4.6.0. Podrobný přehled novinek, změn a oprav v ChangeLogu na GitHubu. Nejnovější verzi Warzone 2100 lze již instalovat také ze Snapcraftu a Flathubu.
Polské vývojářské studio CD Projekt Red publikovalo na Printables.com 3D modely z počítačové hry Cyberpunk 2077.
Organizátoři konference LinuxDays 2025 vydali program a zároveň otevřeli registrace. Akce se uskuteční 4. a 5. října na FIT ČVUT v pražských Dejvicích, kde vás čekají přednášky, workshopy, stánky a spousta šikovných lidí. Vstup na akci je zdarma.
Uživatelé komunikátoru Signal si mohou svá data přímo v Signalu bezpečně zálohovat a v případě rozbití nebo ztráty telefonu následně na novém telefonu obnovit. Zálohování posledních 45 dnů je zdarma. Nad 45 dnů je zpoplatněno částkou 1,99 dolaru měsíčně.
Server Groklaw, zaměřený na kauzy jako právní spory SCO týkající se Linuxu, skončil před 12 lety, resp. doména stále existuje, ale web obsahuje spam propagující hazardní hry. LWN.net proto v úvodníku připomíná důležitost zachovávání komunitních zdrojů a upozorňuje, že Internet Archive je také jen jeden.
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: