Log<<"ZEICHENKETTE";
Log<<"ZEICHENKETTE"<<[Variable (String/char-Array];
usw

jetz wollt ich fragen wie ich die Opperatoren überladen muss (also welch pearamter usw)
die erste Möglichkeit hab ich versucht mit templets reallisieren, wobei dies nicht funktionirt hat.
es kamm folgender linker fehler

1>Main.obj : error LNK2019: Verweis auf nicht aufgelöstes externes Symbol ""public: void __thiscall LogData::operator<<<char const *>(char const *)" (??$?6PBD@LogData@@QAEXPBD@Z)" in Funktion "_main".

Log.h

class LogData
		 {

		 public:
			 template<class T> 
			 void operator<<(T);

		 };

Log.cpp

#include "Log.h"
#include "iostream"

template <class T>
inline void LogData::operator<<(T Ausgabe)
{
	std::cout<<Ausgabe; 
}

Main.cpp

#include "Log.h"
int main()
{
	LogData DATA;
	DATA<<"HALLO";
	return 0; 
}

schon mal danke

#include "iostream"	
class LogData
		 {

		 public:
			 template<class T> 
			 void operator<<(T Ausgabe)
				{
					std::cout<<Ausgabe; 
				}

		 };

funktioniert es aber warum

Grüssli

wie muss ich dafür die operatoren überladen

Du musst es zwar nicht so machen,aber üblicherweise wird für jeden Typ, den du ausgeben willst eine Funktion definiert:

class foo {
...
int x;
std::string whatever;
...
public:
friend std::ostream & operator << ( std::ostream & os , const foo & rhs );
};

std::ostream& operator << ( std::ostream & os , const foo & rhs )
{
 os << rhs.x << " " << rhs.whatever;
 return os;
}

das erste objekt soll die klass sein die später als singleton implementiert wird
das zweit uns soll entweder sein string oder char-array objekt dastellen
also ungefähr so

LOGKLASSE<<STRINGOBJEKT<<CHAR-ARRAY<<"LITERALKONST"<<std::endl;

das sollte möglich sein wär nett wenn mir da jemand einen ansatz geben könnte

MyClass& MyClass::operator<< (const MyObject& Var)
{
    // ...
}

funktioniert soweit auch ganz gut hab nur noch das problem das es ich std::endl nicht hinbekomme

std::endl ist eine Funktion, die auch als Argument von operator<< dienen kann. Schau dir doch mal das genauer an.

Du kannst auch gerne konkret fragen, wenn du etwas nicht verstehst.

template<class T> 
	 LogData& operator<<(const T& Write)
	{
			std::cout<<Write; 
			return *this;
	 }

als basis wie müsste ich das templat und die funktion für das std::endl spezalisieren wäre für jeden kleienen weiteren ansaz dankbar

Schau dir mal Funktionszeiger an. Dann kannst du den Funktionszeiger mit der Signatur von std::endl; als Parametertyp von deinem operator<< verwenden.

LogData& operator<<(const SIGNATUR* endl())
{
std::cout<<std::endl;
return *this;
}
hab ich das richtig verstanden welche signatur muss ich nehemen?

Geht es dir nur darum, alle Eingaben an std::cout weiterzuleiten? Dann ist ein Template das einfachste.

template <typename T>
std::ostream& operator<< (T& Object)
{
	return std::cout << Object;
}

diese klasse kann bisher dashier entgegen nehmen
LogData::getInstanz()<<Hallo<<" wie gehts"<<" was machst du ";
nun soll noch die implementierung von std::endl erfolgen das dies auch möglich ist
LogData::getInstanz()<<Hallo<<" wie gehts"<<" was machst du "<<std::endl,
implementierung des bisherigen << operator steht weiter oben

Ich geb dir jetzt mal den Code für die Deklaration, aber ich empfehle dir, ihn zu verstehen versuchen. Über Funktionszeiger findest du hier eine gute Seite.

LogData& operator<< (std::ostream& (*Object)(std::ostream&));