Если что-то создаётся как массив, хранится как массив и используется как массив, то это, очевидно, и есть массив.

ЗЫ: и таки в примере я не передавал размер массива в функцию. Точно так же как не задавал ожидаемый размер. А шаблонная функция или нет - пусть у компилятора голова болит.

Не совсем ясно, к чему это.



Вы, видимо, путаете понятия "шаблон функции" и "шаблонная функция". Вы пока не привели никакой функции, ни шаблонной, ни какой-то еще. Вы привели шаблон функции. Шаблон функции - это не функция, как я уже заметил выше. В некотором (и весьма близком) смысле точно так же, как функциональный макрос в С не является функцией.

К функции, например, я могу применить оператор взятия адреса, получить указатель на функцию и в дальнейшем вызывать ее через указатель. Никакая "головная боль компилятора" не сможет это сделать в вашем примере, ибо никакой функции у вас нет. Как вы сами, надеюсь, понимаете, любые попытки превратить ваш шаблон в функцию будут сопровождаться специализацией шаблона, то есть фиксацией конкретного типа и размера массива.

У нас тут, знаете ли, технический форум и обмануть нас шаблоном, а затем напустить толстую дымовую завесу из "пусть у компилятора голова болит" - не получится.

К std::array

Не только привёл, но и вызвал её с массивами разного размера.

И к перегруженной? Моя функция в этом плане ничуть не хуже. Это С++, тут всё по другому.

Никто вас не собирается обманывать. Понимаете как это работает - отлично. Кто не понимает - тому и не надо. А я лишь взял объект типа srd:array, передал его в функцию и использовал без указания размера. Каким способом я и компилятор это сделали - дело десятое. Надо будет и адрес возьму.

Нет, не привели. И вызвать вы "её" не могли, ибо то, что вы привели вызвать невозможно. А вызывали вы на самом деле специализации своего шаблона, сгенерированные для вас компилятором с конкретными типами и размерами. Добавьте в свой шаблон распечатку `__PRETTY_FUNCTION__` - и вы увидите эти типы и размеры невооруженным взглядом.



??? Разумеется и к перегруженной. А почему вы упоминаете перегруженные функции? Вы не знаете как в С++ получить адрес перегруженной функции? `static_cast` с радостью поможет вам в этом.



В некотором смысле, аналогия действительно есть. Никакой "вашей функции" не существует, однако при помощи все того же `static_cast` вы можете попросить компилятор сгенерировать конкретную специализацию, на которую вы сможете поставит указатель. Разумеется, с указанием конкретного типа и конкретного размера. От этого никуда не денешься.



Совершенно верно. Я как раз даю под запись детальное описание того, как "по другому" тут "всё". Однако тут все совсем не настолько по-другому, как может показаться с первого взгляда.



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

Если я пишу foo(a), то я вызываю функцию foo с аргументом а. Пользуюсь при этом штатными средствами языка программирования. Написал её сам или взял из стандартной библиотеки тот же std::min - вообще не важно. std::min(1,2) это вызов функции, а остальное демагогия.

Нет, конечно. Даже в языке С это не так. Но тут речь идет о С++, где "все по-другому", как вы сами заметили.

Когда вы пишете `foo(a)` - это в С++ может значить множество самых разных, никак не связанных друг с другом вещей. Что именно означает эта запись - зависит от того, что такое `foo` и что такое `a`.

1. Это может быть и объявлением переменной с лишними скобками, если `foo` - имя конкретного типа.
2. Это может быть и кастом к конкретному типу, если `foo` - имя конкретного типа.
3. Это может быть и кастом к конкретной специализации шаблона класса, выведенной с использованием deduction guides, если `foo` - имя шаблона класса.
4. Это может быть и вызовом функции, если `foo` - функция.
5. Это может быть и вызовом конкретной специализации шаблона функции, если `foo` - шаблон функции.
6. (Наверное можно придумать больше, но и этого достаточно).

Ваш вариант - номер 5.



Это звучит как мантра, которую зачастую мерно и нудно повторяют сами себе люди, пытающиеся оправдать свое нежелание досконально изучать язык. Мол "мне и этого достаточно". Но, еще раз, от того, что вы будете повторять это по кругу снова и снова, это не станет правдой.

Ну вы же сами говорите, что мой вариант 5 (вызов функции). Код приведён, какие в этом могут быть сомнения? Можно даже сказать, что в результате выполнения foo(a) в стандартный вывод будут выведены все элементы аргумента а. Обычный вызов функции как он есть. Извинте, но меня эта болтология уже утомила, дальше без меня.

Так ведь уж в десятом подряд сообщении объясняется: это вызов неявно сгенерированной компилятором функции. Сгенерированной компилятором, а не написанной непосредствено вами. Вы сами никакой функции не написали. Вы написали лишь заготовку, глорифицированный макрос - шаблон функции. Шаблон функции - это еще не функция.

А функция здесь генерируется компилятором на основе специализации вашего шаблона. Специализация - это и есть процесс определения и подстановки конкретного типа и конкретного размера массива в качестве аргументов вашего шаблона. Так что от конкретного типа и конкретного размера массива в функции на этапе компиляции тут никуда не деться, как ни верти. А это и есть тема нашего обсуждения.



Темой данного обсуждения, еще раз, является то, может ли функция уйти от зависимости от размера массива на этапе компиляции. Суть заключается в том, что шаблонное программирование в С++ никоим образом не выполняют такого "ухода", а лишь прячут его за толстым слоем синтаксического сахара, отделяющего шаблоны функций от самих функций.

То есть как уже не раз говорилось выше, тема шаблонов совершенно ортогональна исходной теме дискуссии. Шаблоны тут ничего не меняют.

Может быть небольшая шаблонная прокси функция которая определит размер массива, заинлайнится и вызовет функцию которой уже передается массив и размер. У меня в либах что-то такое есть:

Спойлер

Код:

template<typename T>
concept IntPtrEnum = std::integral<T> || std::is_pointer_v<T> || std::is_enum_v<T>;

template<uint32_t N>
static _always_inline_ char* toStr(char(&buf)[N], IntPtrEnum auto val, uint32_t radix = 10) requires(N >= (sizeof(val) > 4 ? 65 : 33))
{
   using V = decltype(val);
   using U = std::conditional_t<std::is_enum_v<V>, std::underlying_type<V>, std::type_identity<V>>::type;
   using P = std::conditional_t<(sizeof(U) > 4), uint64_t, uint32_t>;
   using T = std::conditional_t<std::is_signed_v<U>, std::make_signed_t<P>, P>;

   return toStr_((char*)buf + N - 1, (T)val, radix);
}

"Может быть" для чего именно?

Речь идет о том, что как на верти, но начинаться все в любом случае будет с функции, "знающей" размер массива на стадии компиляции и жестко привязанной к этому размеру (то есть новый размер - новая функция). А уж как эта функция будет порождена: пользователь ли ее напишет ручками или компилятор сгенерирует из шаблона, "толстая" ли она будет или "тонкая прокси" - ничего принципиально не меняет

То, о чем вы говорите - это правильная техника борьбы с раздуванием кода, вызванным генерацией множества функций из шаблонов. Это очень полезно, но к рассматриваемой теме никакого содержательного отношения не имеет.

Последний раз для непонятливых:
1. Алгоритм работы функции описан.
2. Массив создан.
3. В месте вызова действие с массивом, описанное в п.1, выполнено.
Всё, это самый натуральный вызов функции. Что для этого сделал компилятор - его проблемы.

Это все замечательно, но я в сотый раз повторяю вопрос: какое это имеет отношение к рассматриваемой теме?

Обсуждение посвящено тому, что как ни верти, размер типа "массив" является элементом статической типизации в языке С++. И как ни верти, никуда от этого не денешься: для того, чтобы функция сама по себе "знала" размер массива, придется генерировать отдельную функцию для каждого размера.

Вы же нам тут бросились взахлеб рассказывать о том, как при помощи шаблонов можно без особых усилий штамповать такие функции почти "на автомате". Прекрасно. Мы знаем. Но то, как можно быстро штамповать такие функции, не является темой обсуждения. Это вообще не имеет никакого отношения к теме. К чему вы сюда продолжаете совать эти свои шаблонные "открытия"? Что именно вы хотите ими сказать?

Как насчет такого "последнего раза для непонятливых", а?

¯\_(ツ)_/¯

Между написанием кода на ЯВУ и его выполнением происходит много чего. Почему именно процесс инстанцирования вас так возбуждает? Чем он хуже вывода типов, разрешения имен и других этапов компиляции, необходимых для реализации функционала языка?

ЗЫ: Какими возможностями С++ ещё нельзя пользоваться? Огласите полный список сразу.

Что за странное напускание дыму? Что такое "хуже" или "не хуже"?

Мы здесь говорим не о "хуже" или "не хуже", а о том совершенно объективном, формальном и техническом факте, что для каждого типа массива понадобится своя отдельная функция. Вы попытались замаскировать этот факт при помощи синтаксического сахара - шаблонов, а я вам просто указал на то, что использование шаблонов тут абсолютно ничего не меняет.

Вот и все.

Реальность:
- есть стандарт языка;
- есть код, написанный согласно этому стандарту;
- есть программа, скомпилированная из этого кода, делающая ровно то что задумано;
- шаблоны это неотъемлемая часть языка.

Фантазии:
- я что-то пытаюсь замаскировать. В каком месте? Там чуть больше десятка строк кода, ткните пальцем, где что замаскировано?
- шаблоны - синтаксический сахар. Вот это заход, создатели языка об этом хоть знают?

Я могу лишь в пятнадцатый раз задать один и тот же вопрос: какое отношение это все имеет к обсуждаемой теме?

Вы пришли сюда рассказать нам, что у вас есть программа, которая "соответствует стандарту языка" и "делает то, что вами задумано", а также о том, что "есть стандарт языка" и "шаблоны это неотъемлемая часть языка"? ОК. Это замечательно. Но к чему это здесь?

Остальные участники дискуссии лишь удивленно переглянулись, пожали плечами и решили не обращать внимания. Я один лишь все тщетно пытаюсь добиться от вас: к чем вы это все сюда валите?



Знают, не сомневайтесь! Я - один из "создателей языка" Я, правда, один из "создателей языка" С, а не языка С++, но именно в этом качестве в свое время принимал участие в работе С++ комитета.

Который из них? Керниган или Ритчи ? Я-то думал, что Си в USA разработали.
Не в обиду...

Ну дак Корбен Даллас - это ихняя актриса такая
Ну не думал, что на этом прекрасном мяу-форуме тусуются великие создатели языка, на котором многие из нас пишуть.
Позвольте у создателя тогда спросить пару вопросов. Чож в языке Си так дубово сделали работу с заголовочными файлами то. Всё, что в него написал, становится видимым из любого места, а не изолируется тем, вкуда подключен заголовочник.

Шаблоны - это не баг, а фича, которая умеет подставляться при компиляции кода в зависимости от заданных условий. Некий аналог условной компиляции, только более гибкий, с возможностью задавать разные условия для одного и того же фрагмента.
В обычном Си условия компиляции - константы на всем протяжении компиляции, в шаблоны в С++ - переменные условия компиляции. В Си переменные условия будут выбираться при работе непосредственно кода, а в С++ нужный код будет выбран и поставлен ещё при компиляции.

Обсуждение началось, насколько я смог найти, вот с этого вопроса
viewtopic.php?p=4300682#p4300682

В ходе обсуждения, почему-то пришли к заключению, что массив в С++ кроме как по указателю да ещё с передачей размера не передать.
viewtopic.php?p=4309472#p4309472

Собственно, мой пример со std::array показывает обратное. А уж какой механизм языка за этим стоит - дело десятое.

Нет, это сразу же было очевиднейшим образом неверное "заключение". Уже следующим же своим сообщением я опроверг это неверное заключение и продемонстрировал, что ест еще один способ передачи массива в функцию: путем передачи именно указателя-на-массив или ссылки-на-массив.
viewtopic.php?p=4309501#p4309501

Таким образом, передавать массивы в функции можно как минимум двумя способами

1. Либо размер массива придется передавать отдельным параметром
2. Либо размер массива фиксируется и становится частью сигнатуры функции еще на стадии компиляции

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

И тут вдруг появились вы, без каких либо объяснений вываливших в тему упоминание `std::array` и шаблона функции. Последний является лишь синтаксической фичей языка, предназначенной для автоматической генерации функций по второму пункту из перечисленных выше. Вам об этом сразу сказал azhel12
viewtopic.php?p=4309552#p4309552

И я, соответственно, удивился: к чему это здесь? Все это прекрасно понимают, что происходит при использовании шаблона функции. В этом нет ничего нового. Это лишь способа легко "штамповать" функции по второму пункту, точно так же их можно "штамповать" при помощи макросов в С. Что вы хотели все этим сказать?

В ответ вы принялись лишь разбрасываться туманными фразами в стиле "у меня все работает" и "есть стандарт языка". Все попытки выяснить, что же именно вы хотели сказать, закончились ничем. Неудивительно, что нам остается лишь пожать плечами и махнуть рукой.

P.S. Я смотрю, все эти пространные объяснения с моей стороны - как об стенку горох... Видать, в них больше нет смысла. Пришло время и мне пожать плечами и махнуть рукой.