Ich habe das oben genannte Programm aus "Algorithmn und Problemlösungen mit C++"
ausgeführt und es kam nicht zu dem aufgeführten Ergebnis.

0 1 1 1
191 -192 11 -12
0 0 1 1
46185 -80102 15 5
-262144 0 0 27973 -16809 -2 13
6222 -16809 -2 13
7973 -1108 2 2
3560 -1908 -16 4
29443 44463 -6 14
-11425 5080 4 -10
-8 -210 5 -6

wurde zu

nicht kodierbar
nicht kodierbar
...

Als Ergebnis soll

nicht kodierbar
16, 15
0
nicht kodierbar
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
8, 11, 7, 3
2, 0, 2, 1, 1, 2, 1, 2, 1
15, 3, 8
nicht kodierbar
10, 1, 4, 3
3, 5, 0

ausgegeben werden.

Hat jemand eine Idee?

Danke

Edit: Aufgrund der Größe des Codes und der Forunrichtlinien habe ich den Code erstmal weggelassen. Sollte Interesse bestehen, kann dieser nachgeliefert werden.

Für eineKomplexe Kodierung wird folgender Code benutzt:

#include <cmath>
#include <math.h>
#include <fstream>
#include <vector>

const char* const MSG_ERR = "nicht kodierbar";

using namespace std;

// ------- Deklration der Klasse Complex ----- //

class Complex{

	private:
		long _re, _im;

	public:
		Complex() {};
		Complex(long re, long im): _re(re), _im(im){}
		~Complex() {};
		double getModul() const;
		Complex operator-(Complex&);
		Complex operator-(long);
		Complex operator*(Complex&);
		Complex operator/(Complex&);
		int operator==(long);
		friend istream& operator>>(istream&, Complex&);
};

// ------ Implentierung der Klasse Complex ------ //
inline double Complex::getModul() const{

	double aux = _re*_re + _im*_im;
	return sqrt(aux);

}

inline Complex Complex::operator-(Complex &z) {

	return Complex( _re - z._re, _im - z._im);

}

inline Complex Complex::operator-(long l) {

	return Complex(_re - l, _im);

}

inline Complex Complex::operator* (Complex &z){

	return
		Complex(_re*z._re - _im*z._im, _re*z._im + _im*z._re);

}

inline Complex Complex::operator/(Complex &z) {

	long r = z._re;
	long i = z._im;
	long m2 = r*r + i*i;
	return
		Complex((_re*r + _im*i ) /m2, (_im*r - _re*i) /m2);

}

inline int Complex::operator==(long l) {

	return
		(_re==1 && _im==0);

}

// -- Imlenmentierung der friend-Methode der Klasse Complex --- //

istream& operator>>( istream &is, Complex &u ) {

	is >> u._re >> u._im;
	return is;

}

// --------- lokale Methode -------------------------------//
inline Complex operator%(Complex &z1, Complex &z2) {

	Complex z;
    Complex a;
    a=(z1/z2);
    a=z2 * a;
	z = z1 - a;
	return z;

}

inline int operator!=(Complex &z, long l) {

	return (!(z == 1));

}

void writeSolution(const vector<int>& v, ofstream &out) {

	vector<int>::const_reverse_iterator itEnd = v.rend();
	vector<int>::const_reverse_iterator it;
	for(it = v.rbegin(); it != (itEnd-1); it++)
		out << *it << ",";
	out << *it;
	out << endl;

}

void process(Complex &X, Complex &B, ofstream& out) {

	vector<int>	V;
	Complex ZAux;
	double temp = B.getModul();
	int aMax = (int)temp;
	if(temp - aMax == 0) aMax--;
	if(X==0) {V.push_back(0);}
	short j=0;
	for( ; (j<100) && (X != 0); j++) {

		bool gefunden = false;
		for(int i=0; i<=aMax; i++) {

			ZAux = X -i;
			if(ZAux % B == 0) {

				V.push_back(i);
				X = ZAux / B;
				gefunden = true;
				break;

			}

		}

		if(!gefunden) {out << MSG_ERR << endl; break;}

	}

	if(X==0) {writeSolution(V, out);}
	else if(j==100) {out << MSG_ERR << endl;}

}

// ---------- Hauptprogramm ------ //

int main() {

	Complex X ,B;
	ifstream in("code.in");
	ofstream out("code.out");
	while(in && !in.eof() && in >> X >> B) {

		process(X, B, out);

	}

}

wieso eine kaputte schlechte klasse für komplexe zahlen implementiert wird statt std::complex zu nutzen ist mir schleierhaft.

der autor hat offenbar noch nie etwas von const-correctness gehört.

Aber irgendwie habe ich immer noch folgende Ausgabe:

nicht kodierbar
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,15
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar

P.S.: ISBN 978-3-8348-0763-2
vieweg + Teubner von Doina Logofatu

2. Auflage und der Titel ist "... mit C++"

Edit: nach dem Beseitigen des 2. Fehlers folgende Ausgabe:

nicht kodierbar
16,15
0
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar
nicht kodierbar

der autor hat offenbar noch nie etwas von const-correctness gehört.

Ist anscheinend von 2001 und da wars schon veraltet.

Ich weiß immer noch nicht, wo der Fehler liegt.

Ich weiß immer noch nicht, wo der Fehler liegt.

Du weißt ja, was der Algorithmus tun soll. Benutze einen Debugger!