Mały problem z przeciążeniem operatora

Mam problem z przeciążeniem operatora wypisania "<<"

Mój program składa się z Main.cc, Stos.cc i Stos.h.
Chcę zrobić taki operator (wrzucam to do Stos.cc) :

ostream & operator<<(ostream & ekran, Stos & s){   // operator wypisania
        /.../
} 

Próbowałem już przez kilka godzin zrobić DOBRĄ deklarację w pliku .h . Ale nic nie wyszło. Działało tylko wtedy jak wrzucałem cały operator do Main.cc (co zbytnio zaskakujące nie jest).
A tak to kompilator wywala błędy

I jescze jedno , czy taki Makefile może być ?

 
Program: Main.cc Stos.cc Stos.h
     gcc -o Program Main.cc Stos.cc

Proszę o pomoc, bo sprawa jest pilna. Jak powinny prawidłowo wyglądać deklaracje i ciało operatora.
Program jako całość pracował wyśmienicie, jednak po "pokrojeniu" do makefile jest kiszka.
Pozdrawiam

Makefile może być, ale można to zrobić lepiej używając zmiennych predefiniowanych.

Plik nagłówkowy musi wyglądać np tak:

#ifndef __Stos_h
#define __Stos_h 1

#include <iostream>

std::ostream & operator <<(ostream & ekran, /* const o ile dobrze pamiętam powinno być, ale dawno nie przeładowywałem operatorów w C++ */ Stos & s);

#endif

Deklaracja w stos.h:

ostream & operator<<(ostream & ekran, const Stos &s);

Definicja w stos.cc:

ostream & operator<<(ostream & ekran, const Stos &s)
   {
    /**/
    return ekran;
   }

const przy Stos &s można nie dawać z tym że mało prawdopodobne że stos ma w jakiś sposób zmienić swoje składowe po wypisaniu do strumienia.
A jeżeli już to lepiej jednak zostawić const zaś użyć mutable.

Dałem definicję w nagłówku poza ciałem klasy .

 gcc -o Program Main.cc Stos.cc
Undefined                       first referenced
 symbol                             in file
operator new[](unsigned int)        /var/tmp//ccSEf4Wa.o
std::basic_ostream<char, std::char_traits<char> >::operator<<(std::basic_ostream<char, std::char_traits<char> >& (*)(std::basic_ostream<char, std::char_traits<char> >&))/var/tmp//ccSEf4Wa.o
std::basic_ostream<char, std::char_traits<char> >::operator<<(int)/var/tmp//ccSEf4Wa.o
operator delete[](void*)            /var/tmp//ccSEf4Wa.o
std::cout                           /var/tmp//ccEuS5gp.o
std::ios_base::Init::~Init()        /var/tmp//ccEuS5gp.o
std::ios_base::Init::Init()         /var/tmp//ccEuS5gp.o
__gxx_personality_v0                /var/tmp//ccEuS5gp.o
std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)/var/tmp//ccEuS5gp.o
std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&)/var/tmp//ccSEf4Wa.o
ld: fatal: Symbol referencing errors. No output written to Program
collect2: ld returned 1 exit status
*** Error code 1
make: Fatal error: Command failed for target `Program'

Sypie takim czymś.
Porażka ...

Kompiluj używając g++ bo gcc nie linkuje STL'a i strumieni.

Wkleję jeszcze cały plik .h .

 
#ifndef _STOS_
#define _STOS_ 1
#include <iostream>

using namespace std;

class Stos

{
             int Rozmiar;
      public:
             int *Ele;
             int Szczyt;

             Stos(int R);
             Stos(const Stos & stos);
             void Push(int R);  // kladzenie na stos
             int Pop();  // zdejmowanie ze stosu

             Stos& operator=(Stos& elem); // operator przypisania
             Stos& operator+(Stos& elem); // dodawanie stosów
             Stos& operator*(Stos& elem); // dodawanie elementów stosów
             Stos& operator-(Stos& elem); // odejmowanie stosów
             Stos& operator%(Stos& elem); // odejmowanie elementów stosow
             ~Stos();

};

            ostream &  operator<<(ostream & ekran , const Stos & s );



#endif

DZIALA !!!

dzięki wielkie, gcc bezmyślnie totalnie napisałem . Bosz

Program: Main.cc Stos.cc Stos.h
     gcc -o Program Main.cc Stos.cc

w ten sposób za każdym razem przekompilowywane są oba pliki .cc, nawet jeśli zmienił się tylko jeden. żeby tego uniknąć

Program: Main.o Stos.o
	gcc Main.o Stos.o -o Program

Main.o: Main.cc Main.h
	gcc -c Main.cc

Stos.o: Stos.cc Stos.h
	gcc -c Stos.cc

plik się szybko skomplikuje, ale można to zautomatyzować. poczytaj o makefile'ach.

Kompiluj używając g++ bo gcc nie linkuje STL'a i strumieni.

trzeba wtedy dodać parametr -lstdc++

Elbo dać:

CC=gcc
CPP=g++

Program: Main.o Stos.o
        $(CPP) $< -o $@
 
Main.o: Main.cc Main.h
        $(CC) -c $< -o $@
 
Stos.o: Stos.cc Stos.h
        $(CC) -c $< -o $@