ich habe in meiner main folgenden Aufruf stehen:

cout << computerzahl.richtigPlatzierte(meinVersuch);

Wobei computerzahl und meinVersuch Objekte sind.

Jetzt möchte ich gerne den << operator schreiben.

So funktioniert er nicht, da meinVersuch unbekannt.

ostream& operator<<(MastermindZahl &out,const MastermindZahl& computerzahl) {
out<<computerzahl.richtigPlatzierte(meinVersuch);
return out;
}

aber:
ostream& operator<<(MastermindZahl &out,const MastermindZahl& computerzahl, const MastermindZahl meinVersuch)
funktioniert auch nicht, da << operator keine 3 Parameter akzeptiert.

Wie kann ich das Problem lösen? Vielen Dank im Voraus.

Wie kann ich das Problem lösen?

So gar nicht. Du könntest höchstens ein Metaobjekt dafür einfügen. Wobei ich noch nicht ganz den Sinn verstehe.

btw. sfds

#include<iostream>
#include "mastermind.h"
using namespace std;

void main (void) 
{ 
	int anzahlVersuche = 1; 
	MastermindZahl meinVersuch;
	MastermindZahl computerzahl; 
	computerzahl.ausdenken();
	cout << "Erster Versuch; gib Zahl: " << endl;
	meinVersuch.einlesen(computerzahl); 
	while (computerzahl != meinVersuch) 
	{ 
		cout << "richtig!";
		cout << computerzahl.richtigPlatzierte(meinVersuch); 
        cout << " an der richtigen Stelle; sonst "; 
		cout << computerzahl.sonstNochRichtige(meinVersuch) 
		     << " richtig" << endl; 
		anzahlVersuche++; 
		cout << endl << anzahlVersuche << ". Versuch: "; 
		meinVersuch.einlesen(); 
	} 
	cout << endl << "Gefunden!"; 
 }

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

ostream& operator <<(ostream& lhs, const T& rhs)

lhs ist das Stream Objekt selbst, über welches ausgegeben werden soll. In deinem Fall cout. rhs ist das Objekt, was ausgegeben werden soll. In deinem Fall ist wohl T == MastermindZahl. Wenn du im Operator jetzt schreibst:

lhs << rhs;

musst du beachten, dass lhs (ostream) nur bekannte Argumente akzeptiert. Standardseitig sind das Sachen wie Ganzzahlen, Gleitkommazahlen, Zeichen und Strings. Objekte deines Typs MastermindZahl sind aber noch nicht bekannt. Das willst du ja genau mit dem Operator erreichen. Also musst du innerhalb der Operatorfunktion dein Objekt soweit aufdröseln, dass nur noch Sachen übrig bleiben, die ostream kennt. Was geben denn die Funktionen richtigPlatzierte bzw. sonstNochRichtige zurück? MastermindZahl? Wenn ja, was aus dem Objekt soll denn ausgegeben werden?

ostream& MastermindZahl::operator<<(ostream& out) {
	MastermindZahl meinVersuch;
	out<<richtigPlatzierte(meinVersuch)<<sonstNochRichtige(meinVersuch);
	return out;
}

Ist das so in Ordnung, da ich zum 2. Mal das Objekt "meinVersuch" erzeuge?

#include <iostream>
#include <time.h>
#include <stdlib.h> 
#include "mastermind.h"
using namespace std;

bool operator!=(const MastermindZahl& meinVersuch, const MastermindZahl& computerzahl) {
	int i,j,number;
	j=0;
	int* pi=&i;
	number=computerzahl.getNumber();
	for (i=0; i<number; i++) {
		if (meinVersuch.getArray(i)!=computerzahl.getArray(i)) {
			return true;
		}
	}
	while (meinVersuch.getArray(j)==computerzahl.getArray(j)) {	
		if (j==number-1) {
			return false;
		}
		j++;
	}
}

MastermindZahl::MastermindZahl() {

}

MastermindZahl::~MastermindZahl() {

}

ostream& MastermindZahl::operator<<(ostream& out) {
	MastermindZahl meinVersuch;
	out<<richtigPlatzierte(meinVersuch)<<sonstNochRichtige(meinVersuch);
	return out;
}

void MastermindZahl::ausdenken() {
	time_t sek;
	int i;
	int* pi=&i;
	cout << "Aus wievielen Ziffern besteht Ihre Zahl?" << endl
		 << "Eingabe: ";
	cin >> number;
	cout << endl;
	srand((unsigned) time(&sek));
//	int* array = new int[number];
	for (i=0; i<number; ++i) {
		array[i]=(rand()*7)%6+1;
		cout << "array[i]: " << array[i] << endl;
	}		
}

void MastermindZahl::einlesen(MastermindZahl& computerzahl) {
	int i;
	int* pi=&i;
	number=computerzahl.getNumber();
	cout << "Bitte geben Sie Ihre " << number << "-stellige Zahl ein!";
	cout << endl << "Eingabe:" << endl;

//	int* array = new int[number];

	for (i=0; i<number; i++) {
		cout << i+1 << ".Ziffer: ";
		cin >> array[i];
		cout << endl;
	}
}

void MastermindZahl::einlesen() {
	int i;
	cout << endl << "Bitte geben Sie Ihre " << number << "-stellige Zahl ein!";
	cout << endl << "Eingabe:" << endl;

//	int* array = new int[number];

	for (i=0; i<number; i++) {
		cout << i+1 << ".Ziffer: ";
		cin >> array[i];
		cout << endl;
	}
}

int MastermindZahl::richtigPlatzierte(MastermindZahl& meinVersuch) {
	int i,counter;
	counter=0;
	for (i=0; i<number; i++) {
		if (array[i]==meinVersuch.getArray(i)) {
			counter++;
		}
	}
	return counter;
}

int MastermindZahl::sonstNochRichtige(MastermindZahl& meinVersuch) {
	int i,j,counter;
	counter=0;
	for (i=0; i<number; i++) {
		for (j=0; j<number; j++) {
			if ((array[i]==meinVersuch.getArray(j))&&(array[i]!=meinVersuch.getArray(i))) {
				counter++;
			}
		}
	}
	return counter;

}

int MastermindZahl::getArray(const int index)const {
	return array[index];

}

int MastermindZahl::getNumber() const{
	return number;
}

Die korrekte Signatur wäre:

std::ostream& operator <<(std::ostream& Stream, const MastermindZahl& Zahl);

Aber soweit ich das sehe brauchst dir hier aber überhaupt keinen selbstdefinierten operator<<.