Разница между const auto & и auto &, если объект ссылки является константным

Ключевое слово auto автоматически определяет тип переменной во время компиляции.

В первом случае auto уменьшается до int, а во втором — до const int. Итак, оба ваших случая сводятся к тому же коду, что и:

const int &k = i;

Однако лучше указать константу явно для лучшей читабельности и убедиться, что ваша переменная TRULY равна const.

Вывод типа с auto работает так же, как вывод типа аргумента шаблона с несколькими исключениями, которые не применяются в данном примере. Следовательно

const int i = 42;
const auto& k1 = i; // same as const int& k1 = i;
auto& k2 = i; // same as (const int)& k2 = i;

Тем не менее, вероятно, более читабельно добавить квалификатор const.

Вот еще один пример, когда предпочтение краткости с помощью auto вводит в заблуждение:

int *i;
const auto k1 = i; // same as int* const k1 = i;
const auto *k2 = i;  // same as const int *k2 = i;

В первом случае объект, на который указывает i, можно модифицировать через k1, во втором — нельзя.

Есть небольшая разница: в первом случае auto будет выведено в const int, а во втором случае в int (как вы явно указали const).

состояния ссылок cpp

Ключевое слово auto может сопровождаться модификаторами, такими как const или &, которые будут участвовать в выводе типа. Например, при заданном const auto& i = expr; тип i точно совпадает с типом аргумента u в воображаемом шаблоне шаблона void f(const U& u), если вызов функции f(expr) был скомпилирован. Следовательно, auto&& может быть выведен либо как ссылка lvalue, либо как ссылка rvalue в соответствии с инициализатором, который используется в цикле for на основе диапазона.

Для вас это означает

// case 1
const int i = 42;   
const auto &k = i;   // auto -> int

// case 2
const int i = 42;
auto &k = i;  // auto -> const int

Однако, на мой взгляд, более важным является то, что намерение выражается более четко, если вы указываете const явно и гарантируете константность. Поэтому в данном случае я бы явно предпочел его.

Привет и добро пожаловать в переполнение стека.

Как показывает эта небольшая тестовая программа, независимо от того, как вы указываете тип k, компилятор никогда не позволит вам потерять константность i.

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

#define XSTR(s) STR(s)
#define STR(s) #s

template<class T> 
struct type;

template<>
struct type<int>
{
    static std::string name() { return "int"; }
};

template<class T>
struct type<T&&>
{
    static std::string name() { return type<T>::name() + " &&"; }
};

template<class T>
struct type<T&>
{
    static std::string name() { return type<T>::name() + " &"; }
};

template<class T>
struct type<T const>
{
    static std::string name() { return type<T>::name() + " const"; }
};

#define REPORT_CONST(decl, var, assign) \
{ \
    decl var = assign; \
    do_it(STR(decl var = assign;), var); \
}

template<class Var> 
void do_it(const char* message, Var&&)
{
    std::cout << "case: " << message << " results in type: " << type<Var>::name() << '\n';
}

int main()
{
    const int i = 42;

    REPORT_CONST(const auto &, k, i);
    REPORT_CONST(auto &, k, i);
    REPORT_CONST(auto &&, k, std::move(i));
    REPORT_CONST(auto const &&, k, std::move(i));
    REPORT_CONST(int const&, k, i);
    // REPORT_CONST(int &, k, i); // error: binding reference of type 'int&' to 'const int' discards qualifiers
}

Ожидаемые результаты:

case: const auto & k = i; results in type: int const &
case: auto & k = i; results in type: int const &
case: auto && k = std::move(i); results in type: int const &
case: auto const && k = std::move(i); results in type: int const &
case: int const& k = i; results in type: int const &

http://coliru.stacked-crooked.com/a/7c72c8ebcf42c351

Обратите также внимание на распад именованных r-значений в l-значения.

Принятый ответ правильный, т.е. нет никакой разницы в отношении скомпилированного результата. Важно отметить, что версия auto& сочетает const-версию ссылки k с const-версией переменной i. Я подумал, что, поскольку вопрос озаглавлен «Разница между const auto & и auto &...», важно подчеркнуть здесь прагматическую разницу, в которой, если вы не поместите ключевое слово const, вы не можете гарантировать, что ссылка будет иметь эту cv-квалификацию. В некоторых случаях, когда это желательно, зачем оставлять на волю случая, что i останется const в будущем?