תודה על העזרה

int stricmpr(const char *s1, const char *s2)
{
	char c1,c2;
	if((int)s1[0]>=65 && (int)s1[0]<=90)
		c1=(int)s1[0]+32;
	else
		c1=s1[0];
	if((int)s2[0]>=65 && (int)s2[0]<=90)
		c2=(int)s2[0]+32;
	else
		c2=s2[0];
	if(s1[0]=='\0' || s2[0]=='\0' || c1!=c2)
		return(c1-c2);
	return(strcmpr(s1+1,s2+1));
}

char* strrchar(const char *s1, const char c)
{
	if(s1[0]=='\0')
		return('\0');
	if(s1[1]!='\0')
		strchar(s1+1,c);
	if(s1[0]==c)
		return(s1);
	return('\0');
}

char* strstrr(const char *s1, const char *s2)
{
	int i=0;
	if(s1[0]=='\0')
		return('\0');
	if(s1[0]==s2[0])
	{
		if(s2[1]=='\0')
			return(s1);
		while(s2[i]!='\0')
		{
			++i;
			if(s1[i]!=s2[i] || (s2[i]!='\0' && s1[i]=='\0'))
				break;
			if(s2[1]=='\0')
				return(s1);
		}
	}
	return(strstrr(s1+1,s2+1));
}

קודם כל, למה אתה משתמש ברקורסיה? זה סתם מסבך. עדיף להשתמש בלולאות.

לגבי stricmpr:

אתה לא צריך להמיר מ-char ל-int. ב-C++, הטיפוס char הוא פשוט מספר, וגם לכל הקבועים התווים (כמו 'a' ו-'0') יש ערך מספרי, כך שאת הקוד הזה:

if((int)s1[0]>=65 && (int)s1[0]<=90)
 c1=(int)s1[0]+32; 

יכלת לכתוב ככה:

if (s1[0]>='A' && s1[0]<='Z')
 c1 = s1[0]+32;

(יכולת אפילו להחליף את 32 ב-('a' - 'A') אם רצית ממש לדייק).

בשורה האחרונה צריך להיות stricmpr.

חוץ מזה, במבט חטוף נראה שהפונקציה בסדר.

לגבי הפונקציה strrchar:

ב-if הראשון, שים לב שאתה מחזיר את הערך '0\'. הפונקציה strrchar אמורה להחזיר NULL, כלומר 0. למרות שהערך של '0\' הוא גם 0, זה לא מומלץ ('0\' מייצג את התו 0, ו-NULL מייצג את המצביע 0). עדיף שתכתוב שם return 0.

ב-if השני, לא הבנתי מה ניסית לעשות. קראת לפונקציה וזרקת את ערך ההחזרה שלה לפח. חוץ מזה, הוא לא היה אמור להתבצע רק אם ה-if השלישי לא הצליח?

ה-if השלישי - שים לב שהפונקציה צריכה להחזיר *char, אבל s1 הוא מטיפוס *const char. אתה צריך לבצע כאן המרה לפני שאתה מחזיר אותו.

בפונקציה strstrr:

אני לא יודע מאיפה להתחיל.... האלגוריתם שלך פשוט לא נכון. סתם לדוגמה - לפי האלגוריתם שלך, אם התו הראשון ב-s1 וב-s2 לא זהים, אתה זורק אותם לפח ומתחיל להשוות את שניהם מהתו השני, ואתה בעצם מתעלם לחלוטין מהתו הראשון ב-s2.

הצעה שלי - אם אתה מוכרח להשתמש ברקורסיות, תתבסס על strrchar כשאתה כותב את strstrr.

הראשון עובד (פשוט קראתי לפונקציה אחרת =\).

בשני אם לא הבנת הפונקציה היא STRRCHR כלומר מהסוף להתחלה.

אז הרעיון להגיע לסוף ולהתחיל לבדוק, אבל עכשיו כשאני רואה הוא תמיל יחזיר 0 אם ההתחלה שונה אחד מהשני.. אין לי רעיון לסדר את זה.

בקשר לשלישי הביצוע נראה לי טוב חוץ מהשורה הסופית של הRETURN שפשוט צריך להחזיר S1+1 וS2...

בכל אופן שיניתי לבלי רקורסיה ועדין לא עובד

char* strstrr(const char *s1, const char *s2)
{
	int i,j;

	for(i=0;s1[i]!='\0';++i)
	{
		if(s1[i]==s2[i])
		{
			for(j=1;s2[i+j]!='\0';++j)
				if(s1[i+j]!=s2[i+j])
					break;
			if(s2[i+j]!='\0')
				return(s1+i);
		}
	}
	return(0);
}

עכשיו בעיקרון לא הייתה לי בעיה עד עכשיו עם ההחזרה אבל בכל אופן איך אני משנה את זה?

ככה?

(char*)

בשני כדאי לך לבדוק מה הערך שהוחזר מהפונקיה הרקורסיבית. ואתה צריך להחזיר NULL בשגיאה, לא '\0'.

strrchr:

היית צריך לומר. ציפית שננחש מה הפונקציה אמורה לעשות?

כמו ש-UI אמר, אתה צריך לבדוק מה הערך שהוחזר מהפונקציה הרקורסיבית ולהשתמש בו. אחרת אתה סתם זורק אותו לפח.

strstrr (הפונקציה הזו אמורה לעשות מה ש-strstr עושה, לא?):

עדיין לא פתרת את הבעיה שהייתה לך קודם - אם התו הראשון ב-s1 וב-s2 שונים, אתה מקדם את i ואז אתה משווה בין התו השני של s1 ו-s2 (ומדלג על התו הראשון של s2 לחלוטין).

טוב שטויות.

בכל אופן סידרתי הכל וזה עובד.. תודה.

בקשר להערה שאמרת שסוג המשתנה הוא CONST CHAR* ושאני צריך לעשות המרה CHAR*. איך עושים את זה?

כמו שאמרת בפוסט הקודם שלך.

(אתה יכול פשוט לנסות ולראות אם זה עובד)

הקטע שזה עובד גם בלי..

טוב שיהיה..

יכול להיות, זה כבר תלוי בקומפיילר.