Am having real problem understanding what the problem is. Here is the code :

Stack.h :

#ifndef STACK_H
#define STACK_H
#include<Node.h>

typedef int Stack_entry;

class Stack
{
public:
    enum Error_code{succes,overflow,underflow};

    private:
        int counter;

    public:
        Stack();
        ~Stack();
        //Stack& operator=(const Stack &Stack_copy);
        bool empty_stack()const;
        Error_code push(const Stack_entry &item);
        Error_code pop();
        Error_code top(Stack_entry &item)const;
        int size_of_stack();

    protected:

        Node *top_node; // upucuje na prvi elemenat u LL-u. Ono na sto on upucuje se pop-a ili pusha prvo

};

#endif // STACK_H

Stack.cpp :

#include "Stack.h"
#include <cstddef>
using namespace std;

Stack::Stack() // kreiramo prazan stack
{
    top_node = NULL;

}

Stack ::~Stack(){

    while(!empty_stack())
        pop();
}

 /*void Stack::operator=(const Stack &Stack_copy){

   Node *new_top,*new_copy, *original_node = Stack_copy.top_node; // kreiramo novi top, novu kopiju i orginalni node
   if(original_node == NULL) new_top = NULL;  // ako je objekat prazan, novi top je prazan
   else{

    new_copy = new_top = new Node(original_node->value); // ??
    while(original_node->p_next != NULL){

        original_node = original_node->p_next;
        new_copy->p_next = new Node(original_node->value);  // kopiramo podatke u kopiju
        new_copy = new_copy->p_next;
    }

    }

    while(!empty_stack()) // obrisi stare entrije
        pop();
    top_node = new_top; // i zamjeni sa novim



 }*/

Stack::Error_code Stack::push(const Stack_entry &item) {

  Node *new_element = new Node(item,top_node);  // kreiramo novi node, novi node upucuje tamo gdje je top_node upucivao
  if(new_element == NULL) return overflow;      // error check, blaah
  top_node = new_element;                       // a top node upucuje na novi node
  return succes;
}

Stack::Error_code Stack::pop(){

Node *old_top = top_node;                  // kreiramo novu referencu za top LL-a da se nebi izgubio pocetak LL-a
if(top_node == NULL) return underflow;     // error check..
top_node = old_top->p_next;                // top node sada upucuje na node koji se nalazi iza prvog u listi
delete old_top;                            // uklanjamo prvi node u listi
return succes;

}

int Stack::size_of_stack(){

Node.h :

//typedef int Stack_entry;

class Node
`{`

  public:

     Stack_entry value;
     Node *p_next;

    public:
        Node();
        Node(Stack_entry item);
        Node(Stack_entry item, Node *next);

    protected:

};

Node.cpp :

#endif // NODE_H

Node.cpp

#include "Node.h"
#include <cstddef>

using namespace std;

Node::Node()   // default constructor
{
    p_next = NULL;
}

Node::Node(Stack_entry item){  // korisnik daje samo vrijednost, p_next je NULL

    value = item;
    p_next = NULL;

}

Node::Node(Stack_entry item, Node *next){  // korisnik daje i value i gdje ce taj objekat upcivat nakon kreacije

   value = item;
   p_next = next;

}

main :

Stack outer_stack;
for(int i = 0;i<100000;i++){
Stack inner_stack;
inner_stack.push(some_data);
inner_stack = outer_stack;} // problem line !

Now, I get that I need to wright AO, because in case like this, inner_stack.top_node will be NULL, so data in inner_stack will become garbage, also destructor will always be called on outer_stack even thought its not out of scope. Take a look at the operator overload function and if you could explain to me what is does difrently from the default asignment in main. Thanks

Firstly ... take a look at this in your 'main' function:

Stack outer_stack;

Stack inner_stack; // probably want this here ???

for( int i = 0; i < 100000; ++i )
{
    //Stack inner_stack; // really ???
    inner_stack.push(some_data); //WHAT is 'some_data' ... is it 'i' ? or some value depending in 'i' ?

    //inner_stack = outer_stack; //problem line !
    // ... do you really want to make a copy after each
    // new data item was added to inner_stack ? //
}

//maybe you want to make a COPY WHEN DONE ???
inner_stack = outer_stack;

I have NOT looked at the rest of your code ... but this, in main, looked very unusual!

Just a quick perusal of the operator overload looks like you're assigning original_node to the next node before you're using its value. It seems to me that this would mean that you're skipping the first node