Использование -> вместо . - почему компилятор пропускает этот случай?

    node_t(const node_t<T>& target)
    {
        init(target->value, target->ptr_next);
    }

#include <iostream>
 
template <class T>
class node_t {
public:
    node_t() = default;
 
    node_t(const node_t<T>& target) {
        std::cout << target->value << "\n";
    }
 
private:
    T value = T();
};
 
// Для появления ошибки компиляции - убрать специализацию
#if 1
 
template <>
class node_t<float> {
public:
    node_t<float>& operator->() { return *this; }
 
private:
    float value;
};
 
#endif
 
int main() {
    node_t<int> n1; // Конструктор копирования не используется, нет ошибки
    
    node_t<float> n2;
    node_t<float> n3(n2); // Нет ошибки, если есть специализация.
}

#include <iostream>
 
template <class T>
struct node_t {
    T value = T();
};
 
template <>
struct node_t<float> {
    const node_t<float>* operator->() const { return this; }
 
    float value = 42;
};
 
template <class T>
void f(const node_t<T>& target) {
    std::cout << target->value << "\n";
}
 
int main() {
    node_t<int> n1;
    node_t<float> n2;
    
    // Ошибка будет только в случае инстанцирования f для int.
    //f(n1);
    f(n2);
}

#include <iostream>
 
struct data
{
    int value = 333;
    
    data* ptr_next = {};
};
 
template <class T>
class node_t 
{
    template<class U>
        void init(U& value, T*)
    { std::cout << "init(): " << value << '\n'; }
    
public:
    node_t():value(){}
    
    node_t(const node_t<T>& target)
        :value()
    { init(target->value, target->ptr_next); }    
    
    const T* operator->() const { return &value; }    
    T* operator->() { return &value; }
private:
    T value;
};
 
int main()
{
    node_t<data> data1;
    
    node_t<data> data2 = data1;
    
    (void)data2;
}