Шаблоны. Плохо понимаемые моменты из книги "Шаблоны С++. Справочник разработчика". (Вандевурд, Джосаттис)

#include <iostream>
#include <vector>
#include <algorithm>
 
template <typename T, int VAL>
T addValue(T const& x){
   return x+VAL;
}
 
int main()
{
     vector<int> v1(100);
     vector<int> v2(100);
     transform(v1.begin(), v1.end(),v2.begin(),addValue<int,5>);
}

#include <iostream>
 
using namespace std;
 
template <typename T>
class MyClass{
    T value;
public:
    
    // --- ошибка №1
    // вы не соблюдаете граммар const
    
    
    // геттеры должны быть двух видов: 
    // константная и не константная версии
    // и возвращают они по ссылке, что бы избежать
    // избыточного копирования при возврате по значению
    const T& get_value()const { return this->value; }
    
    // пример иллюстрация того,
    // как можно вывести неконстантную версию геттера
    // из константной.
    // это делается для того, что бы в случае изменений в логике геттера
    // можно было вносить изменения только в одном месте: в константной версии
    T& get_value() 
    { 
        return const_cast<T&>(
            const_cast<const MyClass*>(this)->get_value()
        );
    }
    
    // обратите внимание на использование универсальной ссылке
    // один шаблоно-сеттер позволяет реализовать 
    // стратегию оптимальной передачи аргументов любого типа
    // лишь бы он был совместим с типом приемника данных T
    template<class U> void set_value(const U&& x) 
        { this->value = std::forward<U>(x); }
    
 
    MyClass(const T&x)
        :value(x) 
    {}
    MyClass(T&&x)
        :value( std::forward<T>(x) )
    {}
 
    // --- вынесем туловище шаблона-функции-члена за пределы класса
    // что бы проиллюстрировать синтаксис
    template <typename U>
    const MyClass& operator= (const MyClass<U>&);
    
 
    // --- не забудем реализовать move-operator
    // что бы оптимизировать операцию присвоения для T
    // умеющих move семантику
    template <typename U>
    const MyClass& operator= (const MyClass<U>&& rhs)
        { this->value = std::move(rhs.get_value()); }
 
    // ВАЖНО: обратие внимание: 
    // операторы присвоения принимают нечто либо по константной ссылке,
    // либо по универсальной, 
    // либо r-value-reference
    // а возвращается всегда const-reference на *this класса
    
    // если вы будете соблюдать эту каноническую согласно граммар-const конструкцию
    // для оператора присвоения,
    // то это привентивно оградит вас от "непонятных" ошибок в шаблонах.
};
 
 
template <typename T>
   template <typename U>
        const MyClass<T>& MyClass<T>::operator= (const MyClass<U>& rhs) {
            this->value = rhs.get_value(); 
            return *this;   
        }
 
 
int main(){
    MyClass<int>    Num1(20);
    MyClass<double> Num3(3.14);
    Num3 = Num1; 
}

struct bad
{
    bad& operator=(const bad&) { return *this; }
};
 
int main()
{
    bad b1, b2, b3;
    (b1 = b2) = b3;
}

//корректно
template <int x=0>
int (&foo())[x][x]{
   int Arr[5][6];
   return Arr;
}

//Некорректно
int (&foo())[5][5]{ // <---- как бы [X][X] ,(X==X)
   int Arr[5][6];
   return Arr;
}

foo<1>();