Dotaz: C++ implicitná konverzia inferovaných typov

[mokere]

ahojte std::string_view (a nie len ten) podporuje implicitnú konverziu z std::string-u aj z const char* (resp const char[n])

dajme tomu že máme takúto funkciu:

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::string

samozrejme 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::wstring

Ale 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.

---

---

Odpovědi

[olda79]

Obecně nemá překladač jak určit šablonu, ale jsou metody jak překladači pomoci, aby se nemusel udávat konkrétní typ.

1. Vytvořit si vlastní make funkce
2. Deduction guides
3. String view literal - nejde pro basic_string

#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 >.

[debian+]

< moze byt v <pre>, len ich musis parsovat ako html sekvencie v <pre>, tj. napr < zapisat ako &lt; (alebo vid. posledne tlacidla v editor menu)

[olda79]

Tak to raději budu vkládat jako automaticky předělaný HTML text. Fakt nebudu přepisovat < >.

[Andrej]

Tím jsi chtěl obecenstvu sdělit, že nemáš nainstalovaný sed? Jinak tuhle poznámku fakt nechápu.

[olda79]

Ne. Nevím co je na mém příspěvku nepochopitelného.

[Andrej]

Nevím co je na mém příspěvku nepochopitelného.

Slovo přepisovat.

[olda79]

https://prirucka.ujc.cas.cz/?slovo=p%C5%99episovat

[Andrej]

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.

[olda79]

Proč to vztahuješ na mě. Sám jsi napsal, že nechápeš slovo přepisovat, a najednou to vztahuješ na mě. I sed, nebo jakykoliv jiný program, dokáže přepisovat znaky. Co je na tom nepochopitelného?

[MadCatX]

sed -e 's/</\&lt;/g' -e 's/>/\&gt;/g' FILE.cpp

[Andrej]

Ještě &amp; 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 = —…

[NUKE GAZA! 🎆]

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;
};

[MadCatX]

Postačí něco jako tohle?

#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;
}

[Andrej]

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:

S explicitními dedukčními pravidly

#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);
}

Bez explicitních dedukčních pravidel

#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);
}

[Andrej]

Fuf. Tak jsem se do těch dedukčních pravidel nesmyslně zamotal a nedával jsem pozor. Až tak, že v mém prvním výše uvedeném příspěvku nejsou vůbec použitá, když typ znaku není zobecněný. Tak tady jsou konečně opravdu (ale opravdu (ale opravdu)) použitá:

#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);
}

[mokere]

Ďakujem Vám všetkým za tipy :) Idem si ich vyskúšať.

[10minuteman]

Pri volani funkce je povolena pouze jedna implicitni konverze, ty se snazis o dve, a proto to nefunguje.

Nic radsi nezkousej (naucis se leda prasit) a sprav si design. Michat ruzne typy stringu je vazne spatny napad, a pokud mas takovy vstup, snad by bylo lepsi normalizovat to uz tam (trochu pochybuju, ze ti tyhle stringy prichazi z jednoho stejneho zdroje).

[mokere]

Programujem v C++ jednu aplikáciu a spolu s ňou si súbežne robím aj knižnicu základných helper funkcií a tried, ktoré často používam - takých na aké som zvyknutý z .NETu a Node.JS (Dokonca som sa inšpiroval aj ich api samozrejme prisposobil som ho C++ špecifikám). Robím to preto aby som nemusel zakaždým objavovať Ameriku. Knižnička je postavená nad STL a mala by si rozumieť s jeho filozofiou (nemá to byť náhrada za STL, iba ho dopĺňa).

V aplikácii používam na textové dáta skoro výlučne len std::wstring (tak ako .NETe sa pre reťazce používa UCS2 resp UTF-16 tak aj ja používam najme toto) aj keď občas som nútený pooužívať aj wchar_t* a na binárne dáta std::vector<char>, ale v budúcnosti sa môže stať, že pri inej aplikácii použijem napríklad std::string_view, preto nechcem knižničku viazať na konkrétny typ stringu, ani na konkrétny typ kontainerov a preto tam dosť veľa používam šablóny a iterátory. A ďalší dôvod prečo to robím zložito, je že sa snažím C++ naučiť do hĺbky. Aj pre mňa by bolo jednoduchšie naviazať knižnicu na std::wstring, ale potom by som sa nič nenaučil. C++ je bohatý jazyk a preto sa chcem naučiť využívať všetky jeho možnosti, to prasenie je užitočné keď si chcete jazyk prispôsobiť na svoj obraz. A C++ je v tomto smere veľmi flexibilný.

[10minuteman]

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.

[Jardik]

Pozor si dejte na tyto chyby. Pokud mam na vstupu std string, ktery muze obsahovat nulovy byte jako soucast retezce a pak predate overloadu jen pointer na data a pak z toho udelate view, bude tam jen cast stringu do prvni nuly. Toto jsou caste nenapadne chyby...

[Andrej]

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.

[Anonymous]

Kokoti z ČVUT zůstanou kokotama z ČVUT.