Thread: Removal of gotos

Finally back at looking through code...I am trying to eliminate the gotos in the sudoku function below:


I have eliminated simple gotos before...

Code:

double sum = 0.0;
     
  int x = 1;
  repeat: sum += 1.0 / x++;

  if (x <= N)
    goto repeat;

  printf("The sum of the first %d reciprocals is %lf\n", N, sum);

Removal:

double sum = 0.0;
     
 int x = 1;
 do
 {
        sum += 1.0 / x;
        x++;
 } while (x <= N);
 printf("The sum of the first %d reciprocals is %lf\n", N, sum);

Now, I am trying to eliminate the 4 goto statments without using breaks or continues...

Code:

bool sudoku_solver(int sudoku[][9], int& diff_single, int& diff_line, int& diff_row, int& diff_block) 
{
	bool empty_fields = true;
    bool operation_done;
    int counter;
	int empty_fields_counter;
	int sdk_to_solve [9][9];

	diff_single = 0;
	diff_line = 0;
	diff_row = 0;
	diff_block = 0;
	
	int sudoku_bool[9][9][10];

	for (int n = 0; n < 9; n++) {
		for (int m = 0; m < 9; m++) {
			for (int p = 0; p < 10; p++) {
				sudoku_bool[n][m][p] = true;
			}
		}
	}
	
	for (int m = 0; m < 9; m++) {
		for (int n = 0; n < 9; n++) {
			sdk_to_solve[m][n] = sudoku[m][n];
		}
	}
	
	//main solver
	while (empty_fields) {
		operation_done = false;
		//Scanning
		for (int n = 0; n < 9; n++) {
			for (int m = 0; m < 9; m++) {
				if (sdk_to_solve[m][n] != NULL) {
					for (int i = 0; i < 10; i++) {
						sudoku_bool[m][n][i] = false;
					}
					for (int i = 0; i < 9; i++) {
						sudoku_bool[m][i][sdk_to_solve[m][n]] = false;
						sudoku_bool[i][n][sdk_to_solve[m][n]] = false;
					}
					for (int k = 0; k < 3; k++) {
						for (int l = 0; l < 3; l++) {
							sudoku_bool[(3 * (m / 3)) + l][(3 * (n / 3)) + k][sdk_to_solve[m][n]] = false;
						}
					}
				}
			}
		}
		//analyze scanned pattern 
		//single field defined value?
		for (int m = 0; m < 9; m++) {
			for (int n = 0; n < 9; n++) {
				int counter = 0;
				int last_true;
				for (int num = 1; num < 10; num++) {
					if (sudoku_bool[m][n][num]) {
					   counter++;
					   last_true = num;
					}
				}
				if (counter == 1) {
					sdk_to_solve[m][n] = last_true;
					operation_done = true;
					diff_single++;
				}
			}
		}
		
		if (operation_done) {
			goto field_counter;   //eliminate me!!!
		}
		
		//Column defined field?
		for (int num = 1; num < 10; num++) {
			for (int m = 0; m < 9; m++) {
				int counter = 0;
				int last_field;
				for (int n = 0; n < 9; n++) {
					if (sudoku_bool[m][n][num]) {
						counter++;
						last_field = n;
					}
				}
				if (counter == 1) {
					sdk_to_solve[m][last_field] = num;
					operation_done = true;
					diff_line++;
				}
			}
		}
		if (operation_done) {
			goto field_counter;   //eliminate me
		}
		
		//Row defined field?
		for (int num = 1; num < 10; num++) {
			for (int n = 0; n < 9; n++) {
				int counter = 0;
				int last_field;
				for (int m = 0; m < 9; m++) {
					if (sudoku_bool[m][n][num]) {
						counter++;
						last_field = m;
					}
				}
				if (counter == 1) {
					sdk_to_solve[last_field][n] = num;
					operation_done = true;
					diff_row++;
				}
			}
		}
		if (operation_done) {
			goto field_counter;  //eliminate me
		}
		//block defined field?
		for (int num = 1; num < 10; num++) {
			for (int block_row = 0; block_row < 9; block_row += 3) {
				for (int block_line = 0; block_line < 9; block_line += 3) {
					counter = 0;
					int last_line;
					int last_row;
					for (int inblock_row = 0; inblock_row < 3; inblock_row++) {
						for (int inblock_line = 0; inblock_line < 3; inblock_line++) {
							if (sudoku_bool[block_row + inblock_row][block_line + inblock_line][num]) {
								counter++;
								last_row = block_row + inblock_row;
								last_line = block_line + inblock_line;
							}
						}
					}
					if (counter == 1) {
						sdk_to_solve[last_row][last_line] = num;
						operation_done = true;
						diff_block++;
					}
				}
			}
		}
		if (operation_done) {
			goto field_counter;   //eliminate me
		}
		
		field_counter:
		empty_fields_counter = 0;
		for (int m = 0; m < 9; m++) {
			for (int n = 0; n < 9; n++) {
				if (sdk_to_solve[m][n] == NULL) {
					empty_fields_counter++;
				}
			}
		}
		if (empty_fields_counter == 0) {
			empty_fields = false;
		}
		if (empty_fields_counter != 0 && !operation_done) {
			return false;
		}
	}
	return true;
}

Any ideas or suggestions on how to do this...flags, what?

Cross-posted

Originally Posted by cpjust

What's wrong with breaks & continues?

nothing.

I use them all the time in my code. everyone says they're just "pretty wrappers for goto", but isn't that actually the BEST reason to use them? so you don't have to use goto. there often isn't a better way to leave a loop or bypass the remainder of the loop, and they fill that role quite nicely.

By the same measure, if you've only introduced the need for `break' or `continue' because you've nested control structures you're essentially giving yourself an excuse not to rewrite the code.

Such people can't do [...] no sense at all.

I don't use `break' or `continue' at all. Coding under that implication I produce better code.

I think the problem is making up rules for the sake of having rules. Their doesn't seem to be a need for a rationale behind them. (See not allowing templates in an embedded environment.)

Soma

Switch's have cases which use "break." That's all he meant.

I don't know why he said it, but the association is too strong in the minds of most programmers. I blame the bogus "rule".

"`if' statements have cases which use "break"."

Hear? The association sounds silly. One doesn't necessitate the other. If you want to use `break' fine, but don't assume you need to because of a rule or because that's the way you first "see" it.

The main reason goto's are bad is because they produce spaghetti code.

Except where they don't. I use `goto' (and its "big brothers": `setjmp'/`longjmp') in virtually every "library level" function in C. (I hate C.) I dare you to try your hand at solid and structured source cleaning up of a dozen resources in the face of a dozen exit points without using `goto' in C.

"break" and "continue" do not produce spaghetti code.

Except where they do. If you care to search the Dev-C++ forum you'll find anecdotal "proof". A user had argued the same statement with me and Clifford, another regular. The source he posted as proof was a horrible mess of nesting and fake control structures solving the "N-Queen" problem. If you find it you'll find the companion source written by Clifford.

Source is written for people. (That's probably a quote.) Source is written by people. (Which is plainly obvious.) It is the programmers writing the source that are responsible for "spaghetti" code. Programming is great like that; you can write crap source in any language using any construct.

Soma