Ошибка с дальностью для внутренней функции

«Причина, по которой я думаю, что это может произойти, заключается в том, что я
указатель представления массива некоторая информация теряется, но почему
эта информация потеряна, я не знаю «.

Да. Массивы довольно легко распадаются на указатели, а указатель не знает длины массива. Диапазон для цикла необходим для оценки begin() а также end() из типа данных.
Мое предложение состоит в том, чтобы избежать массивов в стиле C, и использовать std::array вместо:

#include <iostream>
#include <array>

void printList(std::array<int,6> const& v);

int main(int argc, char const *argv[]) {

std::array<int,6> v{{3, 4, 6, 9, 2, 1}};
printList(v);

return 0;
}

void printList(std::array<int,6> const& v) {
for (auto a : v) {
std::cout << a << " ";
}
std::cout << std::endl;
}

Существует большая разница между массивом и указателем.

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

Во втором примере с шаблоном выгода заключается в том, что вы забыли template <std::size_t len> в определении printListТаким образом, у вас есть 2 разные функции, шаблонная и не шаблонная, которая вызывается.

В этом конкретном случае — я бы рекомендовал использовать более современные std::array

такие for петли используют begin а также end функции-члены, чтобы определить, где находится начало и где конец последовательности.

Например, std::vector действительно имеет эти функции и, следовательно, поддерживает такой вид итерации. На самом деле указатели — это просто целые числа, которые представляют адреса памяти и не имеют этих функций, что делает невозможным повторение над указателем (что само по себе не имеет особого смысла) таким образом.

Вы могли бы сделать итерацию следующим образом:

void printList(int *begin, int *end) {
for(; begin < end; ++begin)
std::cout << *begin;
std::cout << std::endl;
}

Это работает внутри main в вашем случае, потому что массивы иметь begin а также end как размер массива известен. Тем не менее, передача массива в функцию приводит к его распаду на указатель.

При передаче массива в функцию он распадается на указатель, таким образом он теряет возможность использования с std :: begin и std :: end. Современный способ сделать то, что вы хотите, это использовать std :: array (вы не должны использовать массивы в стиле C в C ++, если это возможно):

#include <iostream>
#include <array>

template <typename T, size_t ArraySize>
void printList(const std::array<T, ArraySize>& v)
{
for (auto a : v) {
std::cout << a << " ";
}
std::cout << std::endl;
}

int main(int argc, char const *argv[]) {

std::array<int,6> v = {3, 4, 6, 9, 2, 1};

printList(v);

return 0;
}

Массив внутри main имеет известный размер.

Однажды перешел на printList функция имеет гнилой на указатель на intс, следовательно, ошибки, которые вы получаете.

Вы можете передать массив фиксированного размера в функцию:

void printList(int (&v)[6]) {        // pass by reference
for (auto& a : v) {              // use reference to avoid making a copy
std::cout << a << " ";
}
}

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

template <int size>
void printList(int (&v)[size]) {
for (auto& a : v) {
std::cout << a << " ";
}
}

Приятно то, что когда вы вызываете функцию, вы даже не замечаете, что это шаблон, потому что компилятор может определить параметр шаблона (он, конечно, знает размер):

int main() {
int v[] = {3, 4, 6, 9, 2, 1};
printList(v);
}

печатает:

3 4 6 9 2 1

int v[] = {3, 4, 6, 9, 2, 1};

получил тип int[6], в то время как int *v.. ну его тип int *. Вы можете использовать указатель на int для доступа к массиву, но он не несет информацию о размере этого массива.
Вы можете передать массив следующим образом, но вы ограничите себя размером массива:

void foo(int (&p)[6])

или сделать шаблон:

template <std::size_t size> void foo( int (&p)[size] )

Если по какой-то причине вы не можете использовать циклы automic for () (например, для переносимости на платформы, где поддержка C ++ 11 \ 14 сомнительна), вам нужно использовать либо std :: array \ std :: vector, либо указатель передачи и размер массив