Почему передача такого параметра переменного размера по значению невозможна?

Как правило, если вам нужен параметр IN, передавайте встроенные типы по значению, а другие типы по ссылке на const, т. е.

template< size_t size >
void function( Container<size> const& input,size_t Size )
{
 //all instances do exactly same thing and with regard to Size that determines the size of object
}

С этим определением есть вероятность, что компилятор + компоновщик оптимизируют все так, что будет только одна версия машинного кода function.

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

Попробуйте сами, и если вы так же удивлены, как когда-то был я, то хорошо! В противном случае, скорее всего, не будет существенной разницы. Но в некоторых крайних случаях вы можете обнаружить то, что в старые времена называлось «раздуванием шаблонного кода», и тогда пришло время игнорировать это или измерить, достаточно ли это важно, чтобы выполнить работу по переводу полиморфизма времени выполнения.

Теперь на ваш вопрос,

«Мне любопытно, что единственная функция, которая принимает параметр переменного размера, как указано выше, который не разрешен C++, является чем-то, что вообще невозможно реализовать и сгенерировать сборку, или каким-то образом приводит к неэффективной реализации с точки зрения скорости/памяти?»

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

Безопасный способ — использовать std::string из стандартной библиотеки C++, заголовок <string>. Это включает в себя динамическое выделение где-то внутри std::string, которое выполняется автоматически для вас, но влияет на эффективность. Но ваш код, содержащий char[size] characters, не был допустимым C++, и это указывает на начальный уровень, поэтому есть вероятность, что ваш дизайн не был выбран по какой-либо веской причине, поэтому сделайте:

class Container
{
public:
    std::string characters;
};

void function( Container const& input )
{
    // whatever, using e.g. input.characters.length()
}

Ура и чт.,

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

class ContainerBase {
 private: // can't be copied
  ContainerBase(ContainerBase const& o);
  ContainerBase &operator=(ContainerBase &);

 protected:
  ContainerBase(char *datap):datap(datap) { }

 public:
  char *data() { return datap; }

 private:
  char *datap;
};

template<std::size_t size>
class Container : public ContainerBase {
 public:
  Container():ContainerBase(d.characters)
  Container(Container const& o):ContainerBase(d.characters), d(o.d) 
  { }

  Container &operator=(Container const& o) {
    d = o.d;
    return *this;
  }

  struct {
   char characters[size];
  } d;
};


void function(ContainerBase const& input, std::size_t Size){
 /* operate on input.data() */
}

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

template<std::size_t size>
class Container : public ContainerBase {
 public:
  char *data() { return characters; }

 public:
  char characters[size];
};

// note that this function works in plain arrays too
void function(char *input, std::size_t Size){
 /* operate on input */
}

function(c.data(), N);

Между прочим, тогда вы находитесь в boost::array<char, N>, который предоставляет именно этот интерфейс и другие полезные функции (по-прежнему являющиеся агрегатом), хотя он слишком общий, поскольку не закреплен на char.

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

#include <cstddef>
#include <cstdio>

template <size_t size>
struct Container
{
    char characters[size];
};

template <size_t size>
inline void function(const Container<size>& input)
{
    real_work(input.characters, size);
}

void real_work(const char* p, size_t len)
{
    while (len--) puts(p++);
}

int main()
{
    Container<6> x = {"hello"};
    function(x);
}

Обратите внимание, что я намеренно назвал разные типы аргументов по-разному, чтобы вы не запутались.

Контейнер‹1> — это другой тип, чем Контейнер‹2>, и передача указателя ничего вам не решит, потому что они будут указателями на разные типы.

Вам не кажется, что size должен быть параметром конструктора контейнера, а не шаблонным значением?

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

Будет ли что-то вроде этого приемлемым для вас:

class BaseContainer{ /* ... */ };

template<size_t size>
class Container : public BaseContainer{
 public:
  char[size] characters;
};

void function(BaseContainer input,size_t Size){
  //
}