Оператор += работает, но только в форме вызова ->operator+=(.)

#include <iostream>
#include <stdexcept>
#include <vector>
#include <assert.h>
 
using namespace std;
 
// Óçåë îäíîñâÿçíîãî ñïèñêà.
template<typename T>
class node
{
private:
    T value;
    node<T>* next;
    
    void init(T value, node<T>* next)
    {
        this->value = value;
        this->next = next;
    }
    
public:
    // Âîçâðàùàåò çíà÷åíèå value.
    T get_value() const
    {
        return value;
    }
    
    // Óñòàíàâëèâàåò çíà÷åíèå value.
    void set_value(T value)
    {
        this->value = value;
    }
    
    // Âîçâðàùàåò çíà÷åíèå next.
    node<T>* get_next() const
    {
        return next;
    }
    
    // Óñòàíàâëèâàåò çíà÷åíèå next.
    void set_next(node<T>* value)
    {
        next = value;
    }
    
    node(T value, node<T>* next = NULL)
    {
        init(value, next);
    }
    
    node(const node<T>& target)
    {
        init(target.get_value(), target.get_next());
    }
    
    ~node()
    {
    }
    
    // Âûâîäèò ñòðîêîâîå ïðåäñòàâëåíèå îáúåêòà.
    void print() const
    {
        cout << value;
    }
    
    // Âûâîäèò ñòðîêîâîå ïðåäñòàâëåíèå îáúåêòà è ïåðåõîäèò íà íîâóþ ñòðîêó.
    void println() const
    {
        println();
        cout << endl;
    }
};
 
// Ñòåê.
template<typename T>
class stack
{
private:
    node<T>* head;
    int count;
    
    void init()
    {
        head = NULL;
        count = 0;
    }
    
    void throw_if_empty(int count)
    {
        assert(count >= 0);
    }
    
public:
    // Âîçâðàùàåò çíà÷åíèå count.
    int get_count() const
    {
        return count;
    }
    
    stack()
    {
        init();
    }
    
    stack(int count, T* sequence)
    {
        assert(count >= 0);
        assert(sequence != NULL);
        init();
        T* current = sequence;
        for (int i = 0; i < count; i++)
        {
            push(*current);
            current++;
        }
    }
    
    stack(const vector<T>& vector)
    {
        init();
        vector(vector != NULL);
        for (int i = 0; i < vector->size(); i++)
            push(vector[i]);
    }
    
    ~stack()
    {
        clear();
    }
    
    // Âñòàâëÿåò ýëåìåíò â ñòåê.
    void push(T item)
    {
        head = new node<T>(item, head);
        count++;
    }
    
    // Óäàëÿåò è âîçâðàùàåò óäàë¸ííûé ýëåìåíò èç ñòåêà.
    T pop()
    {
        throw_if_empty();
        node<T>* to_remove = head;
        T result_item = head->get_value();
        head = head->get_next();
        delete to_remove;
        count--;
        return result_item;
    }
    
    // Âîçâðàùàåò ýëåìåíò íà âåðøèíå ñòåêà.
    T peek() const
    {
        throw_if_empty();
        return head->get_value();
    }
    
    // Î÷èùàåò ñòåê.
    void clear()
    {
        node<T>* current = head;
        while (current)
        {
            node<T>* to_remove = current;
            current = current->get_next();
            delete to_remove;
        }
        init();
    }
    
    // Âûâîäèò ñòðîêîâîå ïðåäñòàâëåíèå îáúåêòà.
    void print() const
    {
        node<T>* current = head;
        cout << "[";
        while (current)
        {
            current->print();
            if (current->get_next())
                cout << ", ";
            current = current->get_next();
        }
        cout << "]";
    }
    
    // Âûâîäèò ñòðîêîâîå ïðåäñòàâëåíèå îáúåêòà è ïåðåõîäèò íà íîâóþ ñòðîêó.
    void println() const
    {
        print();
        cout << endl;
    }
    
    void operator +=(const T& item)
    {
        push(item);
    }
};
 
int main(int argc, char** argv)
{
    stack<int>* s = new stack<int>();
    for (int i = 0; i < 10; i++)
        s->operator+=(i);
    s->println();
    delete s;
    return 0;
}