gets(string);
		size=strlen(string);
printf("%s",string(1));
printf("%s",string(size));
puts(string);

הסוגריים מרובעים כמובן, פשוט כאן הוא מוריד אותם...

נניח כי הקלט הוא aaa.
בשני הפקודות של ה print הוא מדפיס אות בג'יבריש.. משהו שלא שייך לקלט.. וכשאני עושה debug הוא אומר שהוא לא יכול לגשת לתא הזה.
ובהדפסה האחרונה זה עובד.

ככה שמשהו כזה אמור לעבוד:

		char* string = new char[100];
		gets(string);
		int size=strlen(string);
		printf("%c",string[1]);
		printf("%c",string[size]);
		puts(string);

אגב, עדיף להשתמש ב-cout ו-cin לקלט ופלט, הרבה יותר נוח ולא צריך לדאוג לפורמט או לסוג.

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

אני לא מבין מה המחשב רוצה.

לדוגמא:

#include <iostream>
using namespace std;
int main()
{
    char* str = new char[100];
    cin >> str;
    cout << "First cell: " << str[0] << endl;
    cout << str;
    return 0;
}

אבל זה יותר c++, אם אתה בC תשאר עם printf לבינתיים בתור התחלה.

ולבעיה עצמה - אתה עובד עם Visual Studio? אם כן תנסה לעשות Rebuild All קודם (Build למעלה ואז Rebuild All או Alt+B+E).
מוזר מאוד, אם אתה יכול תביא את הקוד המלא שלך, אולי יש משהו אחר בדרך.

וד"א סתם לנוחיות - יש לך בצד ימין פה מתחת לסמיילים "המרת סוגריים מרובעים" - זה מתקן את הבעיה איתם

#include <stdio.h>
#include <string.h>
#define length 100
void scan_parameters (char *string[length]);
void main()
{
	char string[length];
	scan_parameters(string);
	printf("\n");
	printf("If you see this MSG the string is OK");
	puts(string);
	getch();
}
void scan_parameters (char *string[length])
{
	//scan parameters
	int exit,size,i;
	char temp[length];
	do
	{
		exit=1;
		printf("Enter text up to %d letters: ",length-1);
		flushall();
		gets(string);
		size=strlen(string);
		if (size>length-1)
		{
			printf("\nInput is too big, please follow guidelines\n");
			exit=0;
		}
		else 
			if (strstr(string,"  ")!=NULL)
			{
				exit=0;
			}
			else
				if ((string[size-1]!='?')&&(string[size-1]!='!')&&(string[size-1]!='.'))
				{
					exit=0;
				}
				else
				{
					for (i=0;i<size-1;i++)
					{
						if ((string[i]<'A') && (string[i]>'z')&&(string[i]!=' '))
						{
							exit=0;
							break;
						}
					}		
				}
	}
	while (exit==0);
}

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

וכמו שidan192 אמר לך בתגובה מעל, תשנה את השם מstring כי זה קצת בעייתי בC.

ויש המון שגיאות של המרות.

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

אולי פתחת בטעות פרויקט של c++?

זה מה שקיבלתי כשניסיתי לקמפל:

char* str לדוגמא זה מצביע char למערך בגודל 100, זה אמור להיות מערך בגודל 100 או מצביע char*, לא גם וגם.

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

void scan_parameters (char string[], int arrsize)

ואז תשים לב שעוברת לך מחרוזת אמיתית בDebug ולא BadPtr שאתה מקבל שם עכשיו.

או שאתה יכול:

void scan_parameters (char* string)

ואתה יכול להעביר לCPP רק כדי לראות מה השגיאות, תתקן, תבין ואז תחזיר.

בנוגע להשוואות - אחרי שתתקן את ההצבעה למערך שלך לא תהיה לך בעיה כי אז אתה תקבל char באמת כשתעשה [] ולא int ואז ההשוואה שלך תהיה לא תקינה.

תבין את ההבדל - יש char* ויש char str[] - אי אפשר גם וגם (טכנית, אפשר, אבל זה כבר יותר מתקדם ממה שאתה צריך).

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

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

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

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

שני כל, טיפוס char* זה טיפוס של מערך של צ'ארים.
מה ש-printf של %s עושה זה בעצם
for (int i=0; s[i] != '\0'; ++i) printf("%c", s[i]);
כמובן שברמה אטומי באסמבלי, אבל רק למען הרעיון...

ה string שלי הוא באמת מטיפוס *char.

לא עושים דברים כאלו למען הסדר הטוב והכאבי ראש שמגיעים אחרי זה =]

כשאתה משתמש ב-%s אתה בעצם אומר לקומפיילר לגשת לכתובת הנ"ל
ושם להתחיל לקרוא char-char.

כשאתה מבצע %s על [char[0, (למשל), אתה בעצם אומר לקומפיילר שתוכן התא בכתובת הנ"ל - הוא בעצם כתובת למקום אחר בזכרון שם נמצא מערך ה-char-ים.

כלומר
**str במקום מה שהתכוונת, ומכיוון שאתה ניגש, לאיזו כתובת שקרית - כמובן שתראה הרבה זבל.