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

Шаблонная функция (или метод) — это рецепт создания функций.

Объявление функции (или метода) — это одновременно инструкция о том, как отправить вызов функции, и обещание разработчика, что вы реализуете это позже.

Функция шаблона

template<class T>
void foo(T);

не является функцией; его создание foo<int> не то же самое, что:

void foo(int);

Цель этого правила — позволить вам использовать механизм перегрузки для маршрутизации конкретных случаев из реализации шаблона в версии для конкретного типа.

Таким образом, ваш foo<T> может вызвать convert_to_int(t) и перенаправить работу обратно на foo(int); и звонок convert_to_int(int) может быть пессимизацией.

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

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

template<class...Ts>
my_class(Ts&&...ts)

Чтобы изменить способ «копирования» вашего класса, вам нужно создать нешаблон my_class(my_class const&), а не полагаться на функцию шаблона, которая сделает это за вас.

Итак, (а) это не будет работать для неспециальных функций-членов, и (б) это конкретно не работает для специальных функций-членов как преднамеренной части стандарта.

...

Кстати, я бы крайне осторожен с тем, что делаете вы. Семантика того, что означают = и копирование, обычно должна быть простой; у вас нет, потому что a=b может копировать или не копировать определенные части состояния b в a.

Вы также глубоко внедряете бизнес-логику в свой класс.

Я бы сам следовал правилу 0. По правилу 0 мы размещаем классы со специальными функциями-членами как можно дальше от конечного пользователя.

struct creation_count_index {
  static int get_index() {
    static int current = 0;
    return current++;
  }
  const int index = get_index();
  creation_count_index(creation_count_index const&){}
  creation_count_index(creation_count_index &&){}
  creation_count_index& operator=(creation_count_index const&)&{return *this;}
  creation_count_index& operator=(creation_count_index &&)&{return *this;}
  ~creation_count_index()=default;
};

теперь этот creation_count_index можно поместить в другой класс, и он придаст семантическое значение вашему индексу, причем другой класс не должен знать, как он работает.

class number{
private:
  creation_count_index index;
  double value;
public:
  number(number const&)=default;
  number(number &&)=default;
  number& operator=(number const&)& =default;
  number& operator=(number &&)& =default;
};

ваш путь get_value может сосуществовать с указанным выше. Дело в том, что вам больше не нужно вообще возиться с index, он «просто делает правильные вещи».