ps. Die Ueberpruefung soll zeilenweise stattfinden.

void lineOut( fstream& stream, fstream& stream2 ) {
	char buffer1[200];
	char buffer2[200];

	while( stream.getline( buffer1, sizeof(buffer1) ) ) {
		if( stream.fail() ) {
			cout << "  Unknown Error";
			break;
		}
		while( stream2.getline( buffer2, sizeof(buffer2) ) ) {
			if( stream2.fail() ) {
				cout << "  Unknown Error";
				break;
			}
		cout << buffer1;
		cout << buffer2;
      			if(memcmp(buffer1, buffer2, sizeof(buffer1)) == 0 )
      				cout << "  Eintrag existierts bereits";
		}
      }
}

Und aufrufen tuhe ich sie so:

temp_sid.open( "db/temp_sid.txt", ios_base::out );
				temp_sid << sid;
				temp_sid.close();

				temp_sid.open( "db/temp_sid.txt" );
				students.open( "db/students.txt" );
				lineOut( temp_sid, students );
				students.close();
				temp_sid.close();

Ich glaube es liegt an dem Vergleich buffer1 == buffer2, denn wenn ich mir den Inhalt mit:
cout << buffer1;
cout << buffer2;
ausgeben lasse, erhalte ich an manschen stellen eine Uebereinstimmung der Zeilen.

wobei ich glaube memcmp is nur fuer int. och menno

Ich weiss einfach net mehr weiter, hoffe mir kann jemand helfen.

Rgds
Coda

bool foo(const char* A,const char *B)
{
    if(strlen(A)!=strlen(B))
        return(false);
    if(strcmp(A,B))
        return(false);
    return(true);
}
...
char *Buffer1="Hallo", *Buffer2="Welt", *Buffer3="Hallo";
foo(Buffer1,Buffer2); //0
foo(Buffer2,Buffer3); //1
foo(Buffer1,Buffer3); //0
foo(Buffer1,Buffer1); //1

Benutze strcmp um 2 char Buffer mit einander zu vergleichen

wäre doch viel einfacher

@Blazer:

bool foo(const char* A,const char *B)
{
    if(strlen(A)!=strlen(B))
        return(false);
    if(strcmp(A,B))
        return(false);
    return(true);
}

Das ist ja murks. std::strlen geht jedes einzelle Zeichen durch bis es auf ein '\0'. Das reicht auch direkt ein std::strcmp aus. Wenn die beiden gleich lang sind, ist es dann performanter:

bool compare(const char* first, const char* second) { return std::strcmp(first, second) == 0; }

Wäre höchstens snike, wenn de das machst:

template <typename T>
bool compare(T const& first, T const& second) { return first == second; }
template<>
bool compare(const char* first, const char* second) { return std::strcmp(first, second) == 0); }

//! compare lines of two files for equality
/*! The compare-function reads line by line the content of the both input-streams and compare each lines.
\param first First input-stream
\param second Second input-stream
\return Count of equal lines in both input-streams */
std::size_t compare(std::istream& first, std::istream& second) 
{
	std::string tmp_first, tmp_second;
	std::size_t equal_lines(0);
	while ( std::getline(first, tmp_first) && std::getline(second, tmp_second);)
		if (tmp_first == tmp_second) ++equal_lines;
	return equal_lines;
}

wäre doch viel einfacher

Du bist mein Retter, grosses thx.

Rgds
Coda

Deine Fkt. hat immer nur z.B. Zeile 3 mit Zeile 3 der anderen Datei verglichen und nie Zeile 2 mit Zeile 5, weshalb ich es noch mal etwas umgeschrieben habe.

size_t compare( fstream& stream, fstream& stream2 )
{
	string tmp_first, tmp_second;
	size_t equal_lines(0);

	while( getline(stream, tmp_first) ) {
		while( getline(stream2, tmp_second) ) {
	        	if(tmp_first == tmp_second) {
				++equal_lines;
			}
		}
	}
return equal_lines;
}

Das Problem ist allerdings, dass der Rueckgabewert von der Fkt. immer 0 ist, jedoch wenn es eine Uebereinstimmung gibt, sollte equal_lines den Wert 1 oder hoeher haben, je nachdem wieviele Uebereinstimmungen es gibt.

Ist sicher nur ein dummer Fehler.

Rgds
Coda