Почему у нас несоответствие типов?

Я написал программу, чтобы увидеть, как строковые литералы выводятся в шаблонных функциях.

#include <iostream>
#include <string>
#include <type_traits>

template<typename T> void passByValue(T by_value)
{
    std::cout << std::is_same_v<char const*, decltype(by_value)> << std::endl; // okay
}

template<typename T> void passByReferance(T &by_ref)
{
    std::cout << std::is_same_v<char const*, std::remove_reference_t<decltype(by_ref)>> << std::endl;
}

template<typename T> void passByConstRef(const T &const_ref)
{
    std::cout << std::is_same_v<char const*, std::remove_const_t<std::remove_reference_t<decltype(const_ref)>>> << std::endl;
}

int main()
{
    std::cout << std::boolalpha;
    passByValue("string");    // true: good
    passByReferance("string");// false ??
    passByConstRef("string"); // false ??
    return 0;
}

Получается, что только для passByValue строковые литералы выводятся к типу const char*.

В двух других случаях (passByReferance и passByConstRef), если мы применим к выведенным аргументам, std::remove_reference_t и std::remove_const_t, я полагаю, что мы получим const char*, это правильно?

Я получаю совпадение типов, когда выполняю полное затухание с помощью std::decay_t, почему?


c++ templates type-deduction
person Const    schedule 30.01.2019    source источник
comment
Ответ охватывает все детали. Если вам нужна лучшая видимость типов, вы можете использовать помощников здесь: godbolt.org/z/AqTA0e   -  person balki    schedule 30.01.2019
comment
@balki Это хорошо: ваш код демонстрирует вид машины. Не могли бы вы опубликовать его в разделе ответов? По крайней мере, я могу дать вам большой палец вверх.   -  person Const    schedule 30.01.2019

Ответы (2)


arrow_upward
7
arrow_downward

Вы проезжаете const char[7], а не const char *. Массивы и указатели — это не одно и то же. Их часто путают, потому что массивы легко распадаются на указатели на их первый элемент. При взятии по ссылке массивы не должны распадаться на указатели. Только в первом случае ваш массив должен распадаться на указатель.

Следующие тесты производят true для каждого случая:

#include <iostream>
#include <string>
#include <type_traits>

template<typename T> void passByValue(T by_value)
{
    std::cout << std::is_same_v<char const*, decltype(by_value)> << std::endl; 
}

template<typename T> void passByReferance(T &by_ref)
{
    std::cout << std::is_same_v<char const[7], std::remove_reference_t<decltype(by_ref)>> << std::endl;
}

template<typename T> void passByConstRef(const T &const_ref)
{
    std::cout << std::is_same_v<char [7], std::remove_const_t<std::remove_reference_t<decltype(const_ref)>>> << std::endl;
}

int main()
{
    std::cout << std::boolalpha;
    passByValue("string");    
    passByReferance("string");
    passByConstRef("string"); 
    return 0;
}

Редактировать: Что касается std::decay, это явно приводит к тому, что типы массивов распадаются на указатели:

Если T называет тип "массив U" или "ссылка на массив U", тип typedef члена - U*.

person François Andrieux    schedule 30.01.2019
comment
что произойдет в случае применения std::decay_t - person Const; 30.01.2019
comment
@JoeyMallone Не используйте простые массивы, и вам никогда не придется об этом беспокоиться. std::array и std::string/std::string_view должно быть достаточно. - person Max Langhof; 30.01.2019
comment
@MaxLanghof, да, спасибо. Я узнаю что-то новое, каждый день здесь. - person Duck Dodgers; 30.01.2019
comment
@Const Переместил мой комментарий в ответ. - person François Andrieux; 30.01.2019
comment
@FrançoisAndrieux Да, это правда, я все время думал, что std::decay делает его const char*, но те, которые я использовал, нет. Это проясняет мои сомнения. Спасибо. - person Const; 30.01.2019

arrow_upward
2
arrow_downward

Некоторые помощники, чтобы лучше видеть типы. CE: https://godbolt.org/z/6EFmIR

#include <type_traits>

template<class T>
struct Tis { Tis(); };

template<bool b>
struct Truth{ Truth(); };

template<typename T> void passByValue(T by_value)
{
    Tis<T>{}; //call    Tis<char const*>::Tis()
    Truth<
        std::is_same_v<char const*, decltype(by_value)>
    >{}; // call    Truth<true>::Truth()
}

template<typename T> void passByReferance(T &by_ref)
{
    Tis<T>{}; // call    Tis<char const [7]>::Tis()
    Tis<decltype(by_ref)>{}; // call    Tis<char const (&) [7]>::Tis()
    Truth<
        std::is_same_v<char const*, std::remove_reference_t<decltype(by_ref)>> 
    >{}; // call    Truth<false>::Truth()
    Tis<
        std::remove_reference_t<decltype(by_ref)>
    >{}; // call    Tis<char const [7]>::Tis()
}

template<typename T> void passByConstRef(const T &const_ref)
{
    Tis<T>{}; // call    Tis<char [7]>::Tis()
    Truth<
        std::is_same_v<char const*, std::remove_const_t<std::remove_reference_t<decltype(const_ref)>>> 
    >{}; // call    Truth<false>::Truth()
    Tis<
        std::remove_const_t<std::remove_reference_t<decltype(const_ref)>>
    >{}; // call    Tis<char [7]>::Tis()
}

void foo1(){
    passByValue("string");
}
void foo2() {
    passByReferance("string");
}
void foo3() {
    passByConstRef("string");
}
person balki    schedule 30.01.2019