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

קוד PHP:

 int StrCount(const char* str, const char* search)
{
     int ocnum = 0;
     for(int i=0; i<strlen(str); i++)
     if(str[i] == search)
     ocnum++;
     return ocnum;
} 


אבל זה לא עובד.. מה הבעיה בקוד הזה?

ועכשיו זה רץ ללא שגיאות, יש שאלות?
(:

קוד PHP:

 int StrCount(const char* str, const char* search)
{
     int ocnum = 0;
     for(int i=0; i<(int)strlen(str); i++)
             if(str[i] == search[0])
                     ocnum++;
     return ocnum;
} 


[ זיו ]
[ fat fish ]

למרות שזיו ואלכס כבר תקנו לך את הבעיה, לדעתי עדיין צריך להוסיף.
קודם כל, כפי שאלכס הסביר, אתה מקבל מבציע עם search, למה לך?
הריי אתה רוצה לדעת רק כמה פעמים search נמצא בתוך str, ואתה לא מעוניין לשנות אותו.


הייתי הולך יותר בכיוון של:

קוד PHP:

 int CountAppear( char *s, int nSearch )
{
    int nCounter = 0;
    
    while( *s != '\0' )
        if( *(s++) == nSearch ) nCounter++;
            
    return nCounter;
} 


שים לב שהפונקציה הזאתי היא Case Sensitive.
כמובן, לא היה צריך לשנות שום דבר בקוד שלך, חוץ מלבצע de-reference ל search.
בהצלחה.

The C Programming Language 2nd Edition עמוד19.

We can't use char since nSearch must be big enough to hold EOF in addition to any possible char. Therefore we use int.

(;

wchar (המהפכה של היוניקוד)

[ זיו ]
[ fat fish ]

למה לו להשתמש בwchar_t, הריי הוא ייצטרך להשתמש בכל הפונקציה wchar למינהם.
fgetwc, fgetws, getwc וכו.
ושים לב שgetwchar שמקבילה לgetchar שלנו, מחזירה wint_t, ולא wchar_t מאותה סיבה.

If the value returned by getwchar() is stored into a variable of type wchar_t and then compared against the wint_t macro WEOF, the comparison need never succeed.

אולי הספר "קצת ישן", אבל אותו עקרון עדיין נשמר.
ואלכס אתה יודע בידיוק למה, אם לא אז בבקשה

מה לחפש ב-

תודה על התיקונים!

יש לי 2 שאלות אחרות:
1) יש דרך להגדיר מתוך פונקצייה משתנה גלובלי?
2) איך אני יכול להגיע למשתנה שהוגדר בתוך מחלקה דרך אחד האובייקטים שלה?

1. לא שידוע לי.
2. בהנחה שהמשתנה לא הוגדר בprivate, מה הבעיה לגשת אליו? תסביר את עצמך.

כן באמת אני לא מבין למה זה לא הצליח כי עכשיו זה כן.

ועוד אתגר :
ניסיתי לעשות פונקציה שמפצלת מחרוזת לפי תו מסויים:

קוד PHP:

 void StrSplit(char *str, char *del)
{
     char *sect;
     sect = strtok(str, del);
     while(sect != NULL)
     {
         cout<<sect<<endl;
         sect = strtok(NULL, del);
     }
} 


אבל התוכנית קורסת - למה?

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

StrSplit( "my string example bla bla bla", " " );

אם כן, אז זאת הטעות

אם לא בכל זאת, תדביק את הקוד, נעזור לך.

לא שמים קריאה לפונקציה שערך החזרה שלה נשמר קבוע לאורך הלולאה בתוך הלולאה
לדוגמא, strlen כתנאי...
מה שקורה על כל תו במחרוזת שלך, אתה עובר שוב על כל המחרוזת ומחשב את אורכה... דבר זה גורם לכך שסיבוכיות הריצה שלך תהיה במקום O(n) היא תהיה O(n*n)
שזה חבל

עוד דבר scripter
גם אני הבנתי למה הוא צריך להכיל 257 ערכים אפשריים? מה לו ולEOF? ממתי זה תו ולידי במחרוזת? הוא לא משתמש בפונקציות קריאה מstdin

כשהפך את הלולאה ל-while שבודק את לא הגענו ל-NULL...
זה אחד אחד מהקטעים שהופכים את C ו-CPP לשפות מגעילות בעיני(בניגוד לשפות עיליות) -
למרות שהעקרון של תכנות פרוצדולרי אומר שפונקציה היא "קופסה שחורה", ולא אכפת לך מה
קורה בפנים - כל עוד אתה מכיר את הממשק שלה(כלומר: הפרמטרים, טיפוסיהם ומשמעותם,
וטיפוסו ומשמעותו של ערך ההחזרה), ב-C אתה חייב לדעת איך פועל הקוד בפנים כדי לכתוב
קוד טוב. (במקרה שלנו, אתה חייב לדעת שבניגוד ל-pascal strings, פה לא נשמר גודל המחרוזת
בשום מקום, והדרך היחידה לקבל אותו היא לסרוק אותו עד לסוף המחרוזת, ולספור אורך)

המסקנה מפה, ד.א., היא שהקוד של איציק(שעובר על המחרוזת עד ה-NULL) עדיף מההצעה
שלך לקרוא לפונקציה בהתחלה, לשמור את הערך במשתנה, ואז לסרוק את המחרוזת בחיפוש
אחר התו המבוקש: למרות שהסיבוכיות תהיה זהה, פונקציות זמן -הריצה יהיו שונות, מאחר
ואצלך סורקים את המחרוזת פעמיים - פעם אחת בקריאה ל-strlen, ופעם נוספת בחיפוש עצמו
[כלומר פונקציות זמן הריצה יהיו n+k ו 2n+m בהתאמה, כאשר k ו-m קבועים. אפילו אם m שלך
יהיה קטן יותר, המקדם של n חשוב יותר(אפשר להתייחס אליו כמקדם של n בחזקת אחד, כאשק
k או m הם מקדמים של n בחזקת אפס, והחזקה הגבוהה יותר משמעותית יותר...)]

טוב, חפרתי...
לילה טוב, טל

זה עניין אחד...
זה שאף אחד לא ציין את העניין הנ"ל זה עניין אחר

בכל מקרה, שפות דור שלישי לכולן יש את הבעיה הנ"ל...
כדי שתוכל לכתוב קוד יעיל, תצטרך לדעת בכלליות איך פועלות פונקציות שאתה משתמש בהן...

נכון תכתוב אפליקציה בפייתון לא יהיו לך את הבעיות הנ"ל...
תכתוב אפליקציה בג'אווה וגם בבייסיק, תצטרך לדעת...

אני לא מבין כל-כך את החלוקה לדורות(במיוחד, כי כל-אחד מחלק איך שבא לו), אבל לפי החלוקה
המוכרת לי ג'וואה ובייסיק הן "שפות עיליות", בעוד ש-C היא "שפת ביניים"(כלומר, "דור" אחד למטה
בשרשרת המזון התכנותית). ב-C(וב-CPP) עפ"י ההגדרה, אתה צריך להתעסק בדברים הללו - C
נוצרה כשפה לבניית מערכות הפעלה(ליתר דיוק: מערכת הפעלה מסויימת ), ולכן נותנת לך את
האפשרות, ומחייבת אותך, לעשות הכל, להגדיר הכל, לקבוע הכל - אבל גם דורשת ממך, בהתאם,
להבין ולדעת הכל...
ג'אווה ובייסיק, בתיאוריה, מנסות כן לפעול בשיטת ה"קופסה השחורה". את ג'אווה אני לא מכיר
עד-כדי כך, אבל אני יכול לומר שבייסיק לא כל-כך הצליחה בתחום הזה: בזמן הדוס, כל התכנות
התבסס על טריקים(מישהו אמר overloading או XMS? ), ולכן ב-QB נאלצת להתעסק בהמון
שטויות(למען האמת, כדי להשתמש ב-XMS כתבו מודולים ב-C או ASM, וקישרו אותם לקוד ה-QB).
ב-VB, בגלל שמדובר ב-MS, אתה נאלץ תמיד לדעת מתי כתוב משהו אחד, והפונקציה עושה
משהו שונה לחלוטין(לעזאזל, Usenet מלא בזה...)...
מצד שני, נדמה לי שבג'אווה המצב טוב יותר

לעניין המחרוזות, בג'אווה ובבייסיק אכן משתמשים ב-pascal strings(בג'אווה זה אפילו יותר
מתוחכם), אבל מעבר לכך, באופן כללי הגישה היא שאתה לא אמור להתעסק בזוטות, כל הקוד
שסופק לך פועל(ופועל טוב), ואתה לא צריך לדאוג מתי להשתמש בו ומתי לא(כמובן שזה בא

על חשבון ביצועים, ואין מה לעשוות את ג'אווה או VB ל-C או CPP...)

מחלקה שניתן להגדיר ולהשתמש בה כמו בהגדרה של משתנים פרימיטיביים, ולכן ג'אווה עשתה את המחרוזות הכי נוחות לשימוש. לי יש דווקא סטייה, שאני אוהב את ההגדרה הקלאסית של מחרוזת ב-C, עם *char, אבל זה בהחלט לא נורמלי

שים לב טל, לא התייחסתי לקוד שהוא הביא במיוחד.
אמנם כפי "הערתם" לפני, אכן יכלתי להחליף בקלות בדוגמא שכתבתי מint ל char.
נכון, במקרה הזה לא היה משנה, אבל כפי אמרת, אם היה מעורב שם פונקציות קריאה מstdin, אז זה היה שונה.
אמנם זה כ"כ default, בפונקציות stdio להשתמש בint, שעם הזמן, זה הפך להיות סטנדרט אצלי גם.
שים לב prototypes הבאים:

char * strchr ( const char * string, int c );

char * strrchr ( const char * string, int c );

void * memchr ( const void * buffer, int c, size_t num );

לא שמים קריאה לפונקציה שערך החזרה שלה נשמר קבוע לאורך הלולאה בתוך הלולאה

לדוגמא, strlen כתנאי...

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

עכשיו נעזוב את התקנים/פונקציות/משתנים הכל..
מה שלומך? טוב לראות אותך מסתובב בפורום עדיין.
איציק.

פשוט לא הבנתי את ההקשר של הEOF לדוגמא הנוכחית...
אם אתה מתייחס לזה כאל סטנדרט של השוואה של int לchar כדי שתוכל גם לזהות EOF וכד'
זה בהחלט מקובל (ע"ע K&R אם הם עשו משהו כל העולם גם יכול)

בכל מקרה גם העניין של להשתמש במצביעים (או באינדקסים שזה קצת יוצר קוד יותר ברור) על מנת לגלות את סוף המחרוזת בלי להשתמש בכלל בstrlen זה בהחלט יותר אפקטיבי
אבל אם אתה בוחר להשתמש מתישהו בstrlen הנק' הייתה שלא תחשב אותה מחדש בכל איטרציה כי זה, אולי בדברים שהבחור כותב עכשיו לא מורגש...

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

בכל מקרה, אלכס (עניתי כאן כדי לא לפתוח הודעה חדשה)
עם נרד מעניין הדורות שניה, אפילו ב#C כשאתה רוצה ליעל תוכנה, זה חשוב לדעת את המימוש של שפת התכנות שאתה עובד איתה. העניין הוא שבשפות גבוהות כמו #C וJAVA אז הדברים האלו הם הצרה הקטנה שלך, למרות זאת, גם כשאני כותב ב#C אני משתמש במשתני עזר...
משתני עזר זה דבר חשוב ואין שום סיבה לא להשתמש בעשרות משתני עזר, זה גורם לקוד שלך להיות יותר ברור, זה חוסך ביצוע פעולות, וזה נעלם באופטימיזציה אם אפשר...

לרוב האנשים אין גישה לקוד המקור של דוטנט, ולכן אין להם מושג איך פועלת C#
מבפנים. אשריך, שדוד/חבר שלך עובד ב-MS וסחב משם ת'קוד בשבילך, ואשריך,
שהצלחת לקרוא ולהבין אותו...

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

כי יש המון "טריקים" שמאפשרים לך לגעת הכי קרוב שאפשר באסמבלר. אין דברים כמו אוסף הזבל בג'אווה (אולי גם C#, אני לא מכיר), שפועלים בזמן ובאופן שאתה לא יכול תמיד לשלוט בו.

טוב, אני לא רוצה לפתוח לשאלה הזאת הודעה חדשה:

יש לי מחלקה cls:

קוד:

class cls

{
	 private:
	 char *var;
 
	 public:
	 cls(char *par) { var = par; }
};

ואת nStr:

קוד:

 char nStr[20] 

אני יוצר אובייקט למחלקה: (cls obj(nStr אבל כשאני משנה את הערך של nStr גם הערך של var בתוך המחלקה משתנה, אז איך אפשר למנוע את זה?
ניסיתי עם מצביעים ולא הצלחתי..

נכון אמרת לבנאי var = par, אז זה בדיוק מה שהוא עשה.

עריכה: הבנתי מה רצית לעשות. ציפית שיווצר עותק של par, אבל זה לא יקרה, כי שניהם בעצם פוינטרים, ולכן רק שניהם כרגע מצביעים על אותה מחרוזת. אתה צריך ממש להעתיק וליצור עותק חדש של המחרוזת, ע"י srcpy.

בכ"א, תיאורטית, דוטנט דווקא נחמדה בקטע הזה, כשהיא מאפשרת לך
להגדיר קטעי קוד כ-Managed(עם אוסף זבל וכו'), או Unmanaged(בלי
עזרה). בפועל, זה לא ממש הולך

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

יש לי שאלה על זיכרון:
נגיד יצרתי מערך זמני (tArr) עם new והעתקתי אותו למערך הראשי (nArr) (מה שעושים אם רוצים מערך שאפשר לשנות לו את הגודל)

קוד:

				T *tArr = new T[aSize+1];
				...
				nArr = tArr;

זה בעצם מכוון ל tArr נכון? כי אם אני מוחק אותו גם nArr נמחק.
אז עשיתי את זה:

קוד:

				T *tArr = new T[aSize+1];
				...
				char *p[aSize+1];
				*p = *tArr;
				nArr = p;
				delete[] tArr;
				delete *p;

ואז אני יכול למחוק את *p ו tArr.
השאלה שלי היא האם זה חוסך בזיכרון או יעיל יותר באיזושהי דרך?