ich komme ursprünglich aus der Java-Welt und mach grad mal meine ersten Gehversuche mit C++11.

Als "Übungsprojekt" habe ich mich jetzt einfach mal für einen Löser für Magische Quadrate beliebiger Größe entschieden:

- Es macht Sinn, das ganze auf Performance zu trimmen
- Es beinhaltet ein paar grundlegende Templates
- Später kann man darauf aufbauend sich schön mit Parallelisierung auseinandersetzen, denke ich.

Wie gesagt, das ganze ist ein erster Gehversuch und ich würde mich einfach gerne über ein bisschen Feedback freuen ob das ganze in die richtige Richtung geht. Zielplattform ist Linux und gcc. Interessiert bin ich nicht nur an "echte" Fehler sondern auch an Meinungen ob etwas "Stilunüblich" in der C++-Welt ist.

Gelöst wird das ganze folgendermaßen: Es wird rekursiv durch alle möglichen Kombinationen iteriert, also das nächste freie Feld einmal mit allen verbleibenden Zahlen gefüllt und dafür dann wieder die Funktion aufgerufen wird. Dabei wird aus einer "Verzweigung" ausgestiegen, sobald sich das Quadrat bei einer Prüfung als unlösbar herausstellt. Die methode bekommt einen Consumer als Funktionspointer, jedes gefundene fertige Quadrat wird an diesen Consumer zurückgegeben.

Also hier der Code:

#pragma once

#include <cassert>
#include <array>

template<int Size>
class MagicSquare {
public:

	inline void unset_cell(int row, int col) {
		unset_cell(cell_id(row, col));
	}

	inline void set_cell(int row, int col, int val) {
		set_cell(cell_id(row, col), val);
	}

	inline int get_cell(int row, int col) {
		return get_cell(cell_id(row, col));
	}

	inline void replace_cell(int row, int col, int val) {
		replace_cell(cell_id(row, col), val);
	}

	int get_progress() {
		int prog = 0;
		for (int idx = 0; idx < FIELDS; ++idx) {
			if (field[idx]) {
				++prog;
			}
		}
		return prog;
	}

	void resolve(void (*consumer)(MagicSquare<Size> &)) {
		resolve(consumer, get_progress());
	}

	void resolve(void (*consumer)(MagicSquare<Size> &), int progress) {
		if (progress == FIELDS) {
			consumer(*this);
		}

		int firstUnusedCell = 0;
		while (field[firstUnusedCell]) {
			++firstUnusedCell;
		}

		for (int idx = 1; idx < FIELDS + 1; ++idx) {
			if (usedNumbers[idx]) {
				continue;
			}
			replace_cell(firstUnusedCell, idx);

			if (check_square()) {
				resolve(consumer, progress + 1);
			}
		}
		unset_cell(firstUnusedCell);
	}

	bool check_square() {
		for (int idx = 0; idx < Size; ++idx) {
			if (!check_row(idx) || !check_col(idx)) {
				return false;
			}
		}

		if (!check_diag1() || !check_diag2()) {
			return false;
		}
		return true;
	}

	bool check_diag1() {
		int sum = 0;
		bool empty = false;
		for (int idx = 0; idx < Size; ++idx) {
			int cell = get_cell(idx, idx);
			sum += cell;
			empty |= !cell;
			if (sum > ROWSUM) {
				return false;
			}
		}

		return empty || sum == ROWSUM;
	}

	bool check_diag2() {
		int sum = 0;
		bool empty = false;
		for (int idx = 0; idx < Size; ++idx) {
			int cell = get_cell(idx, Size - 1 - idx);
			sum += cell;
			empty |= !cell;
			if (sum > ROWSUM) {
				return false;
			}
		}

		return empty || sum == ROWSUM;
	}

	bool check_col(int col) {
		int sum = 0;
		bool empty = false;
		for (int row = 0; row < Size; ++row) {
			int cell = get_cell(row, col);
			sum += cell;
			empty |= !cell;
			if (sum > ROWSUM) {
				return false;
			}
		}

		return empty || sum == ROWSUM;
	}

	bool check_row(int row) {
		int sum = 0;
		bool empty = false;
		for (int col = 0; col < Size; ++col) {
			int cell = get_cell(row, col);
			sum += cell;
			empty |= !cell;
			if (sum > ROWSUM) {
				return false;
			}
		}

		return empty || sum == ROWSUM;
	}

private:
	enum {
		FIELDS = Size * Size,
		ROWSUM = Size * (Size * Size + 1) / 2
	};

	inline int cell_id(int row, int col) {
		assert(row < Size);
		assert(col < Size);
		return row * Size + col;
	}

	inline void set_cell(int cell, int value) {
		assert(field[cell] == 0);
		assert(usedNumbers[value] == false);
		field[cell] = value;
		usedNumbers[value] = true;
	}

	inline void unset_cell(int cell) {
		usedNumbers[field[cell]] = false;
		field[cell] = 0;
	}

	inline int get_cell(int cell) {
		return field[cell];
	}

	inline void replace_cell(int cell, int value) {
		usedNumbers[field[cell]] = false;
		usedNumbers[value] = true;
		field[cell] = value;
	}

	std::array<int, FIELDS> field = { };
	std::array<bool, FIELDS + 1> usedNumbers = { };
};

#include <iostream>
#include <array>
#include <cstdio>

#include "MagicSquare.hpp"

template<int Size>
void dumpSquare(MagicSquare<Size> &square) {
	printf("----------------\n");
	for (int row = 0; row < Size; row++) {
		for (int col = 0; col < Size; col++) {
			printf("%2d ", square.get_cell(row, col));
		}
		printf("\n");
	}
}

int main() {
	MagicSquare<4> square;
	square.resolve(&dumpSquare);
	return 0;
}

Danke schonmal für eventuelles Feedback

Stummi

template <typename Callable>
    void resolve( Callable consumer, int progress) {
        // [...]

Wird eine Funktion an dieses Funktionstemplate übergeben, wird für Callable ein Funktionszeigertyp deduziert. Der Rest bleibt völlig gleich - sowohl beim Callee als auch im Rumpf. Cool, was?

• Du verletzt DRY. Die Funktionen check_diag1 , check_diag2 usw. sind sehr ähnlich.

template <typename Callable>
bool _internal_neat_function( Callable get_cell_call )
{
        int sum = 0;
        bool empty = false;
        for (int idx = 0; idx < Size; ++idx) {
            int cell = get_cell_call(idx);
            sum += cell;
            empty |= !cell;
            if (sum > ROWSUM)
                return false;
        }

        return empty || sum == ROWSUM;
}

bool check_diag1() {
        return _internal_neat_function( [] (int idx) {return get_cell(idx, idx);} );
    }
    bool check_diag2() {
        return _internal_neat_function( [] (int idx) {return get_cell(idx, Size - 1 - idx);} );
    }
    // ...

(alles ungetestet)
Falls dir sowohl Funktionstemplate als auch Lambdas fremd sind - eigne sie dir an! Sind extrem coole und essentielle Features von C++.

• Z. 137-140: Warum eine Enumeration? Warum nicht einfach statische Member-Konstanten?

static const auto FIELDS = Size * Size;

Edit: Die genaue Funktionsweise deiner Algorithmen habe ich mir noch nicht angeschaut, auch die lässt sich wahrscheinlich optimieren.

empty |= !cell;

sieht komisch aus. Warum nicht einfach so?

empty = !cell;

Anstelle der rohen Funktionszeiger könntest du mir mal std::function anschauen

Und über die Verwendung von printf in einem C++ Programm lässt sich natürlich streiten (anstelle von std::cout)

Und genaugenommen ist #pragma once kein Standardkonformes C++ (oder hat sich das inzwischen geändert?)

empty |= !cell;

sieht komisch aus. Warum nicht einfach so?

empty = !cell;

Weil das etwas anderes tut. Was wenn in empty true gespeichert ist und !cell den Wert false hat?

Besser wäre jedoch gleich den logischen Operator zu verwenden:

empty ||= !cell;

Anstelle der rohen Funktionszeiger könntest du mir mal std::function anschauen

Ne, nicht gut. function ist hier unpassend.

Besser wäre jedoch gleich den logischen Operator zu verwenden:

empty ||= !cell;

Diesen Operator gibt es nicht.

#include <iostream>
#include <array>
#include <cstdio>

#include "MagicSquare.hpp"

template<int Size>
void dumpSquare(MagicSquare<Size> &square) {
	printf("----------------\n");
	for (int row = 0; row < Size; row++) {//viele bevorzugen != und präinkrement
		for (int col = 0; col < Size; col++) {
			printf("%2d ", square.get_cell(row, col));//printf
		}
		printf("\n");
	}
}

int main() {
	MagicSquare<4> square;
	square.resolve(&dumpSquare);
	return 0;
}

[*]Du verletzt DRY.

Das war mir klar, aber nicht wie ich es besser machen könnte. Danke für den Verweis auf Lambdas und Funktionszeiter, da werde ich mich nochmal genauer einlesen. Dein Codebeispiel bringt mir aber einen Fehler:

../MagicSquare.hpp:93:43: error: ‘this’ was not captured for this lambda function

Grüße,
Stummi

Und genaugenommen ist #pragma once kein Standardkonformes C++ (oder hat sich das inzwischen geändert?)

Pragma-Direktiven sind definitionsgemäß implementationsspezifisch und damit kein Teil des C++ Standards auch wenn diese mittlerweile meines Wisens nach von allen gängigen Compilern unterstützt wird.

../MagicSquare.hpp:93:43: error: ‘this’ was not captured for this lambda function

Ja, du musst noch this capturen, sonst kann das Lambda keine Memberfunktionen aufrufen.
Einfach this in die eckigen Klammern schreiben.

Diesen Operator gibt es nicht.

Tatsächlich! Ich werd' verrückt! Bist du gerade in der Zeit zurückgereist und hast diesen Operator aus jeglichen Standardisierungen von C und C++ entfernt?

Gut, schreiben wir es aus, immer noch besser:

empty = empty || !cell;

Die Zeile wird Arcoth gefallen.

Ist es vom Standard definiert dass true | false wiederum true oder false ergibt? Siehe auch hier.

Dein Codebeispiel bringt mir aber einen Fehler:

Upsi. Schreib das Lambda in beiden Fällen zu

[this] (int idx) {return get_cell(idx, idx);}

um, und probier' noch mal.

funktionszeiger statt funktionsobjekt ist lahmer.

Ein Funktionszeiger ist ein Funktionsobjekt. Ein Funktionsobjekt ist dadurch definiert dass man es wie eine Funktion aufrufen kann. Und was heißt "Lahm"*? Ich hoffe "uncooler".

Übrigens:

if (!check_diag1() || !check_diag2()) {
            return false;
        }
        return true;

return check_diag1() && check_diag2();

De Morgansche Gesetze und so.

* Außenverteidiger!

Tatsächlich! Ich werd' verrückt! Bist du gerade in der Zeit zurückgereist und hast diesen Operator aus jeglichen Standardisierungen von C und C++ entfernt?

Das hab ich damals schon vor Ort vollbracht.
Spass beiseite. Die Tatsache, dass diese Operatoren und dass der ^^-Operator (Logisch-XOR) fehlen haben mich schon aufgeregt.

Arcoth schrieb:

Ist es vom Standard definiert dass true | false wiederum true oder false ergibt? Siehe auch hier.

Darüber habe ich mir auch schon Gedanken gemacht. Einmal hat jemand hier im Forum einen Ausschnitt aus dem Standard gepostet (das war SeppJ glaub ich, ich finde den Beitrag jedoch nicht mehr, das ist ein Weilchen her, vermutlich noch auf einem meiner alten Accouts), dass dies (und dasselbe mit XOR) wohldefiniert ist. Nachdem camper in dem von dir verlinkten Thread etwas anderes (und genaueres) geschrieben hat bin ich unsicher.

funktionszeiger statt funktionsobjekt ist lahmer.

Ein Funktionszeiger ist ein Funktionsobjekt. Ein Funktionsobjekt ist dadurch definiert dass man es wie eine Funktion aufrufen kann. Und was heißt "Lahm"*? Ich hoffe "uncooler".

Übrigens:

if (!check_diag1() || !check_diag2()) {
            return false;
        }
        return true;

return check_diag1() && check_diag2();

De Morgansche Gesetze und so.

* Außenverteidiger!

Nöö, das war schon sehr gut so.

Arcoth schrieb:

Tatsächlich! Ich werd' verrückt! Bist du gerade in der Zeit zurückgereist und hast diesen Operator aus jeglichen Standardisierungen von C und C++ entfernt?

Das hab ich damals schon vor Ort vollbracht.
Spass beiseite. Die Tatsache, dass diese Operatoren und dass der ^^-Operator (Logisch-XOR) fehlen haben mich schon aufgeregt.

Den ^^ gibts, nur heißt er !=.

Den ^^ gibts, nur heißt er !=.

Ich hab zwar keine Ahnung wie bool s miteinander verglichen werden, aber wenn die oberen Bits über dem achten unspezifiziert sind, dann kann so ein != doch schief gehen, oder? Oder wird beim Vergleich nur das LSB betrachtet?

Edit: Ich sage besser nichts dazu, ich weiss nicht was der Standard über bool s aussagt. Nicht auf mich hören also!

volkard schrieb:

Den ^^ gibts, nur heißt er !=.

Ich hab zwar keine Ahnung wie bool s miteinander verglichen werden, aber wenn die oberen Bits über dem achten unspezifiziert sind, dann kann so ein != doch schief gehen, oder? Oder wird beim Vergleich nur das LSB betrachtet?

Edit: Ich sage besser nichts dazu, ich weiss nicht was der Standard über bool s aussagt. Nicht auf mich hören also!

Ich geh einfach mal davon aus, dass Vergleiche für bools schon definiert sind und zwei gleiche immer gleich sind und nicht auf einmal verschieden, wenn da anderer Müll ist. Das wäre sonst ziemlich blöd.

Arcoth schrieb:

Ist es vom Standard definiert dass true | false wiederum true oder false ergibt? Siehe auch hier.

Darüber habe ich mir auch schon Gedanken gemacht. Einmal hat jemand hier im Forum einen Ausschnitt aus dem Standard gepostet (das war SeppJ glaub ich, ich finde den Beitrag jedoch nicht mehr, das ist ein Weilchen her, vermutlich noch auf einem meiner alten Accouts), dass dies (und dasselbe mit XOR) wohldefiniert ist. Nachdem camper in dem von dir verlinkten Thread etwas anderes (und genaueres) geschrieben hat bin ich unsicher.

true | false ergibt 1
Was ich in dem Thread geschrieben habe bezog sich auf die ABI - mithin das was nach der Übersetzung in Assembler-/Maschinencode zu beachten ist. Mit dem Verhalten auf der Ebene von C++ hat das nichts zu tun: | führt erst mal die gewöhnlich arithmetischen Konvertierungen auf beiden Operanden aus (weil es nur für int und größere integrale Typen definiert ist). Und die Konvertierung von bool nach int ergibt immer 1 bzw. 0 für true bzw. false.