Hledání slov v matici – C / C++ – Fórum – Programujte.com

Ahoj, dělám program na řešení osmisměrky a funkce mi není schopná najít hledané slovo a už vůbec není schopná převést velké písmeno na malé. Ať zkouším tolower nebo -'A' + 'a' stále vyhazuje nesmyslné znaky, nebyl by mi někdo schopen poradit nebo najít chybu ? Předem moc děkuji 

for(i=0;i<Pocet;i++){
poc_p = strlen(Slova[i].slovo);

for(j=0;j<Rad;j++){  //vodorovný směr ---->
for(k=0;k<Slp;k++){
p = 0;
if(((mat[j][k]==Slova[i].slovo[0]) || ((mat[j][k] - 'a' + 'A') 
==Slova[i].slovo[0])) && Slp - k >= poc_p){
	p = 1;
	for(l=1;l<poc_p - 1 ;l++){ 
		if(mat[j][k+l] == Slova[i].slovo[l] || (mat[j][k+l] - 'a' + 'A') == Slova[i].slovo[l])
		p = p + 1;
			}
	if( p == poc_p)
	for(l=0;l<poc_p;l++)
	mat[j][k+l] = mat[j][k+l] - 'A' + 'a' ;

tak jinak, vyřešil jsem hledání následovně ale stále mi při výpisu malých písmen vyhodí error, konkrétně 

(unsigned)(c+1) <=256 , netuší někdo čím by to mohlo být ? 

{
	for(i=0;i<Pocet;i++){
		poc_p = strlen(Slova[i].slovo);

		for(j=0;j<Rad;j++){				
			for(k=0;k<Slp;k++){
//vodorovný směr ---->
				p = 0;					 //představuje nalezená písmena
				if(((mat[j][k]==Slova[i].slovo[0]) || ((mat[j][k] - 'A' + 'a') == Slova[i].slovo[0])) && Slp - k >= poc_p){
					p = 1;
					for(l=1;l<poc_p - 1 ;l++){ 
						if(mat[j][k+l] == Slova[i].slovo[l] || (mat[j][k+l] - 'A' + 'a') == Slova[i].slovo[l])
						p = p + 1;
					}
					if( p = poc_p){
						for(l=0;l<poc_p;l++)
							mat[j][k+l] = mat[j][k+l] - 'A' + 'a' ;}
					if( p = poc_p)
						goto nalezeno;}
//vodorovný směr <----
				if(((mat[j][k] == Slova [i].slovo[0]) || ((mat[j][k] + 'A' - 'a') == Slova[i].slovo[0])) && Slp - k >= poc_p){
					p = 1;
					for(l=1;l<poc_p - 1 ;l++){
						if(mat[j][k-l] == Slova[i].slovo[l] || (mat[j][k+l] - 'a' + 'A') == Slova[i].slovo[l])
						p = p + 1;
					}
					if ( p == poc_p)
						for(l=0;l<poc_p;l++)
							mat[j][k-l] = mat[j][k-l] - 'A' + 'a' ;
					if ( p == poc_p)
						goto nalezeno;}

//směr dolů  		
					p = 0;
				if(((mat[j][k]==Slova[i].slovo[0]) || ((mat[j][k] - 'A' + 'a') == Slova[i].slovo[0])) && Rad - k >= poc_p){
					p = 1;
					for(l=1;l<poc_p - 1 ;l++){ 
						if(mat[j+l][k] == Slova[i].slovo[l] || (mat[j+l][k] - 'A' + 'a') == Slova[i].slovo[l])
						p = p + 1;
					}
					if( p = poc_p){
						for(l=0;l<poc_p;l++)
							mat[j+l][k] = mat[j+l][k] - 'A' + 'a' ;}
					if( p = poc_p)
						goto nalezeno;}

//směr nahoru	
					p = 0;
				if(((mat[j][k] == Slova [i].slovo[0]) || ((mat[j][k] + 'A' - 'a') == Slova[i].slovo[0])) && Rad - k >= poc_p){
					p = 1;
					for(l=1;l<poc_p - 1 ;l++){
						if(mat[j-l][k] == Slova[i].slovo[l] || (mat[j-l][k] - 'a' + 'A') == Slova[i].slovo[l])
						p = p + 1;
					}
					if ( p == poc_p)
						for(l=0;l<poc_p;l++)
							mat[j-l][k] = mat[j-l][k] - 'A' + 'a' ;
					if ( p == poc_p)
						goto nalezeno;}

//šímký směr zleva dolů doprava
				p = 0;					 
				if(((mat[j][k]==Slova[i].slovo[0]) || ((mat[j][k] - 'A' + 'a') == Slova[i].slovo[0])) && Rad - k >= poc_p ){
					p = 1;
					for(l=1;l<poc_p - 1 ;l++){ 
						if(mat[j+l][k+l] == Slova[i].slovo[l] || (mat[j+l][k+l] - 'A' + 'a') == Slova[i].slovo[l])
						p = p + 1;
					}
					if( p = poc_p){
						for(l=0;l<poc_p;l++)
							mat[j+l][k+l] = mat[j+l][k+l] - 'A' + 'a' ;}
					if( p = poc_p)
						goto nalezeno;}

//šikmý směr zprava dolů doleva
				p=0;
				if(((mat[j][k] == Slova [i].slovo[0]) || ((mat[j][k] + 'A' - 'a') == Slova[i].slovo[0])) && Slp - k >= poc_p){
					p = 1;
					for(l=1;l<poc_p - 1 ;l++){
						if(mat[j+l][k-l] == Slova[i].slovo[l] || (mat[j+l][k+l] - 'a' + 'A') == Slova[i].slovo[l])
						p = p + 1;
					}
					if ( p == poc_p)
						for(l=0;l<poc_p;l++)
							mat[j+l][k-l] = mat[j+l][k-l] - 'A' + 'a' ;
					if ( p == poc_p)
						goto nalezeno;}

//šikmý směr zleva nahoru doprava				
				p=0;
				if(((mat[j][k] == Slova [i].slovo[0]) || ((mat[j][k] + 'A' - 'a') == Slova[i].slovo[0])) && Rad - k >= poc_p){
					p = 1;
					for(l=1;l<poc_p - 1 ;l++){
						if(mat[j-l][k+l] == Slova[i].slovo[l] || (mat[j-l][k+l] - 'a' + 'A') == Slova[i].slovo[l])
						p = p + 1;
					}
					if ( p == poc_p)
						for(l=0;l<poc_p;l++)
							mat[j-l][k+l] = mat[j-l][k+1] - 'A' + 'a' ;
					if ( p == poc_p)
						goto nalezeno;}

//šikmý směr zprava nahoru doleva					
				p=0;
				if(((mat[j][k] == Slova [i].slovo[0]) || ((mat[j][k] + 'A' - 'a') == Slova[i].slovo[0])) && Rad - k >= poc_p){
					p = 1;
					for(l=1;l<poc_p - 1 ;l++){
						if(mat[j-l][k] == Slova[i].slovo[l] || (mat[j-l][k] - 'a' + 'A') == Slova[i].slovo[l])
						p = p + 1;
					}
					if ( p == poc_p)
						for(l=0;l<poc_p;l++)
							mat[j-l][k] = mat[j-l][k] - 'A' + 'a' ;
					if ( p == poc_p)
						goto nalezeno;}
				else {Slova[i].slovo == Nenalezeno[n].slovo;
						n++;}
}}

nalezeno:;
	}}

V tomhle se nedá vyznat... rozděl si kód do funkcí a hned to půjde líp ;-) 

bool isInRow(char * row, int rowWidth, const char * word) {
	/* todo */
}

bool isInColumn(char ** matrix, int column, int height, const char * word) {
	/* todo */
}

bool isInRows(char ** matrix, int width, int height, const char * word) {
	for (int y = 0; y < height; y++)
		if (isInRow(matrix[y], width, word))
			return true;

	return false;
}

bool isInColumns(char ** matrix, int width, int height, const char * word) {
	for (int x = 0; x < width; x++)
		if (isInColumn(matrix, x, height, word))
			return true;

	return false;
}

bool isInMatrix(char ** matrix, int width, int height, const char * word) {
	if (isInRows(matrix, width, height, word))
		return true;

	if (isInColumns(matrix, width, height, word))
		return true;

	/* todo */

	return false;
}

#3 PiranhaGreg
Dobrá, jeden směr vypadá například takhle ale ani tak to ty slova nemůže najít

for(j=0;j<Rad;j++){				
for(k=0;k<Slp;k++){
//vodorovný směr ---->
p = 0;			//představuje nalezená písmena
  if(((mat[j][k]==Slova[i].slovo[0]) || ((mat[j][k] - 'A' + 'a') == Slova[i].slovo[0])) && Slp - k >= poc_p){
    p = 1;
for(l=1;l<poc_p - 1 ;l++){ 
if(mat[j][k+l] == Slova[i].slovo[l] || (mat[j][k+l] - 'A' + 'a') ==  Slova[i].slovo[l])
    p = p + 1;}
if( p = poc_p){
for(l=0;l<poc_p;l++)
    mat[j][k+l] = mat[j][k+l] - 'A' + 'a' ;}
if( p = poc_p)
    goto nalezeno;}