What i am making wrong with operator overloading?

Question

I don't understand what is wrong when I overload operator + (purpose of this is to join 2 stacks in one new) ... it returns "sum" of but change values for those previous. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

template <typename T>
classStack
{
    private:

        struct Node
        {
            T data;
            Node *next;
        } *top;

        std::size_t size;

    public:
        Stack();
        ~Stack();
        void            push(T data);
        void            pop(void);
        size_t          get_size(void);
        const Stack&    operator=(const Stack &stack_obj);
        const Stack     operator+(const Stack &stack_obj);
        void            show_all_stack(void);
};


template <typename T>
const Stack<T>  Stack<T>::operator+(const Stack &stack_obj)
{
    Stack   stack;
    Node    *tmp;

    if (!this->size && !stack_obj.size) {
        return stack;
    }
    if (!stack_obj.size)
    {
        stack.size = size;
        stack.top = top;
    }
    else if (!size)
    {
        stack.size = stack_obj.size;
        stack.top = stack_obj.top;
    }
    else
    {
        stack.size = size + stack_obj.size;
        stack.top = new Node;
        stack.top = top;    
        tmp = stack.top;
        while (tmp->next)
            tmp = tmp->next;
        tmp->next = new Node;
        tmp->next = stack_obj.top;
   }
   return stack;
 }

Default constructor

template <typename T>
Stack<T>::Stack(void): top(nullptr), size(0)
{   
}

Destructor

template <typename T>
Stack<T>::~Stack(void)
{
    Node    *next;

    if (!size)
        std::cout << "Stack is empty!\n";
    else
    {
        while (top != nullptr)
        {
            next = top->next;
            delete top;
            top = next;
        }
        top = nullptr;
    }
}

Assignment operator

template <typename T>
const Stack<T>& Stack<T>::operator=(const Stack<T> &stack_obj)
{
    Node    *tmp;
    Node    *ptr;
    Node    *last;
    Node    *new_node;

    if (&stack_obj != this)
    {
        while (top != nullptr)
        {
            tmp = top;
            top = top->next;
            delete tmp;
        }
        top = nullptr;
        size = stack_obj.size;
        ptr = stack_obj.top;
        while (ptr)
        {
            new_node = new Node;
            new_node->data = ptr->data;
            new_node->next = nullptr;
            if (!top)
            {
                top = new_node;
                last = new_node;
            }
            else
            {
                last->next = new_node;
                last = new_node;
            }
            ptr = ptr->next;
        }
    }
}

Answer 1

Before creating functions that return Stack<T> by value, or have functions that require copy semantics for Stack<T> (as in your operator +), you need to make sure that Stack<T> is safely copyable. Right now, you are lacking a copy constructor, thus your operator + would never work correctly, even if the function itself is bug-free.

You're missing this function:

Stack::Stack(const Stack<T>&)

The easiest way to implement the copy constructor is to take most of your code out of the assignment operator, and place that into the copy constructor. More or less, the code should look something like this (the code has not been compiled or tested -- it is there to illustrate the main point of this answer):

template <typename T>
Stack<T>::Stack<T>(const Stack<T> &stack_obj) : top(nullptr), size(0)
{
    Node    *tmp;
    Node    *ptr;
    Node    *last;
    Node    *new_node;

    ptr = stack_obj.top;
    while (ptr)
    {
        new_node = new Node;
        new_node->data = ptr->data;
        new_node->next = nullptr;
        if (!top)
        {
            top = new_node;
            last = new_node;
        }
        else
        {
            last->next = new_node;
            last = new_node;
        }
        ptr = ptr->next;
    }
}

You have already written a destructor that should work, so we won't get into that function, but a working destructor is required for the next step -- implementation of the assignment operator.

Now that you have a copy constructor and destructor, you can now write the assignment operator. The technique used here is the copy / swap idiom

#include <algorithm>
//...
template <typename T>
Stack<T>& Stack<T>::operator=(const Stack<T> &stack_obj)
{
    if ( &stack_obj != this )
    {
        Stack<T> temp(stack_obj);
        std::swap(top, temp.top);
        std::swap(size, temp.size);
    }
    return *this;
}

Believe it or not, this works. The code that used to be here was moved to the copy constructor, and thus the assignment operator is going to take advantage of the copy constructor.

To explain briefly, the code creates a temporary Stack<T> object from the passed-in stack_obj (this is why you need a working copy constructor). Then all that is done is to swap out the this members with the temporary members. Last, the temp dies off with the old data (this is why the destructor needs to be working correctly).

Note that you need to swap all of the members, so if you add more members to the Stack<T> class, you need to swap them in the assignment operator.

Once you have the basic 3 functions (copy, assign, destroy) written correctly, then and only then should you write functions that return Stack<T> by value, or write functions that take a Stack<T> by value.

You may have other issues with operator + that lie outside the scope of what this answer is presenting to you, but the gist of it is that your class requires that it has correct copy semantics before implementing +.