فایل ها و رشته های کاراکتری در ++C — جامع و کامل

به بخش دیگری از آموزش ++C از وب سایت آموزشی پی استور رسیدیم. در این جلسه با مباحث فایل ها و رشته های کاراکتری در ++C، مروری بر اشاره‌گرها، توابع عضو cin و cout و نوع‌ string در ++C آشنا خواهید شد. پس از مطالعه این مقاله شما می‌توانید رشته‌های کاراکتری در ++C را ايجاد نمايید؛ توابع معرفی شده عضو cin و cout را بشناسید؛ نوع string را شناخته و رشته‌هايی از اين نوع ايجاد کنيد و با استفاده از توابع خاص، اين رشته‌ها را دست‌کاری نماييد و در نهایت اطلاعات کاراکتری و رشته‌ای را در يک فايل متنی نوشته يا از آن بخوانيد.

مقدمه

داده‌هايی که در کامپیوترها پردازش می‌شوند هميشه عدد نيستند. معمولاً لازم است که اطلاعات کاراکتری مثل نام افراد، نشانی‌ها، متون، توضيحات، کلمات و غیره نيز پردازش گردند، جستجو شوند، مقايسه شوند، به يکديگر الصاق شوند يا از هم‌ تفکيک گردند.

در اين جلسه از آموزش فایل ها و رشته های کاراکتری در ++C بررسی می‌کنيم که چطور اطلاعات کاراکتری را از ورودی دريافت کنيم و يا آن‌ها را به شکل دلخواه به خروجی بفرستيم. در همين راستا توابعی معرفی می‌کنيم که انجام اين کارها را آسان می‌کنند.

مروری بر اشاره‌گرها در ++C

يک اشاره‌گر متغيری است که حاوی يک آدرس از حافظه می‌باشد. نوع اين متغير از نوع مقداری است که در آن آدرس ذخيره شده. با استفاده از عملگر ارجاع & می‌توان آدرس يک شی را پيدا کرد.

همچنين با استفاده از عملگر مقداريابی * می‌توانيم مقداری که در يک آدرس قرار دارد را مشخص کنيم. به تعاريف زير نگاه کنيد:

int n = 44;
int* p = &n;

رشته‌های کاراکتری در ++C

در زبان ++C يک «رشته کاراکتری» آرايه‌ای از کاراکترهاست که اين آرايه دارای ويژگی مهم زير است:

1. يک بخش‌ اضافی در انتهای آرايه وجود دارد که مقدار آن، کاراکتر NUL يعنی ‘O\‘  است. پس تعداد کل کاراکترها در آرايه هميشه يکی بيشتر از طول رشته است.
2. رشته کاراکتری را می‌توان با ليترال رشته‌ای به طور مستقيم مقدارگذاری کرد مثل:

char str[] = "string";

توجه‌ کنيد که‌ اين‌ آرايه‌ هفت‌ عنصر دارد:

's' و 't' و 'r' و 'i' و 'n' و 'g' و '\0'

3. کل يک رشته کاراکتری را می‌توان مثل يک متغير معمولی چاپ کرد. مثل:

cout << str;

در اين صورت، همه کاراکترهای درون رشته کاراکتری str يکی يکی به خروجی می‌روند تا وقتی که به کاراکتر انتهايی NUL برخورد شود.

4. يک رشته کاراکتری را می‌توان مثل يک متغير معمولی از ورودی دريافت کرد مثل:

cin >> str;

در اين صورت، همه کاراکترهای وارد شده يکی يکی درون str جای می‌گيرند تا وقتی که به يک فضای خالی در کاراکترهای ورودی برخورد شود. برنامه‌نويس بايد مطمئن باشد که آرايه str برای دريافت همه کاراکترهای وارد شده جا دارد.

5. توابع تعريف شده در سرفايل <cstring> را می‌توانيم برای دست‌کاری رشته‌های کاراکتری به کار بگيريم. اين توابع عبارتند از:

• تابع طول رشته ()strlen
• توابع کپی رشته ()strcpy و ()strncpy
• توابع الصاق رشته‌ها ()strcat و ()strncat
• توابع مقايسه رشته‌ها ()strcmp و ()strncmp
• تابع استخراج نشانه ()strtok

رشته‌های کاراکتری با کاراکتر NUL خاتمه‌ می‌يابند. برنامه کوچک زير نشان می‌دهد که کاراکتر ‘O\’ به رشته‌های کاراکتری الصاق می‌شود:

int main()
{  char s[] = "ABCD";
   for (int i = 0; i < 5; i++)
      cout << "s[" << i << "] = '" << s[i] << "'\n";
}

رشته کاراکتری s دارای پنج عضو است که عضو پنجم، کاراکتر ‘O\’ می‌باشد. تصوير خروجی اين مطلب را تاييد می‌نمايد. وقتی کاراکتر ‘O\’ به cout فرستاده می‌شود، هيچ چيز چاپ نمی‌شود. حتی جای خالی هم چاپ نمی‌شود. خط آخر خروجی، عضو پنجم را نشان می‌دهد که ميان دو علامت آپستروف هيچ چيزی چاپ نشده است.

ورودی/خروجی رشته‌های کاراکتری

به چند روش می‌‌توان رشته‌ های کاراکتری در C را دريافت کرده يا نمايش داد. يک راه استفاده از عملگرهای کلاس string است که در بخش‌های بعدی به آن خواهيم پرداخت. روش ديگر، استفاده از توابع کمکی است که آن را در ادامه شرح  می‌دهيم.

مثال‌: روش ساده دريافت و نمايش رشته‌ های کاراکتری در C

در برنامه زير يک رشته کاراکتری به طول 79 کاراکتر اعلان شده و کلماتی که از ورودی خوانده می‌شود در آن رشته قرار می‌گيرد:

int main()
{  char word[80];
   do
   {  cin >> word;
      if (*word) cout << "\t\"" << word << "\"\n";
   } while (*word);
}

توابع عضو cin و cout

به cin شی فرآيند ورودی می‌گويند. اين شی شامل توابع زير است:

cin.getline() 
cin.get() 
cin.ignore() 
cin.putback()
cin.peek()

همه اين توابع شامل پيشوند cin هستند زيرا آن‌ها عضوی از cin می‌باشند. به cout شیء فرآيند خروجی می‌گويند. اين شی نيز شامل تابع ()cout.put است. نحوه کاربرد هر يک از اين توابع عضو را در ادامه خواهيم ديد. فراخوانی ;cin.getline(str,n) باعث می‌شود که n کاراکتر به درون str خوانده شود و مابقی کاراکترهای وارد شده ناديده گرفته می‌شوند.

تابع ()cin.getline با دو پارامتر

اين‌ برنامه‌ ورودی را خط به‌ خط به خروجی می‌فرستد:

int main()
{  char line[80];
   do
   {  cin.getline(line,80);
      if (*line) cout << "\t[" << line << "]\n";
   } while (*line);
}

تابع ()cin.getline با سه پارامتر

برنامه زیر، ورودی را جمله به جمله تفکیک می‌نماید:

int main()
{  char clause[20];
   do
   {  cin.getline(clause, 20, ',');
      if (*clause) cout << "\t[" << clause << "]\n";
   } while (*clause);
}

تابع ()cin.get

اين برنامه‌ تعداد حرف‌ ‘e’ در جريان‌ ورودی را شمارش‌ می‌کند. تا وقتی cin.get(ch) کاراکترها را با موفقيت به درون ch می‌خواند، حلقه ادامه می‌يابد:

int main()
{  char ch;
   int count = 0;
   while (cin.get(ch))
      if (ch = = 'e') ++count;
   cout << count << " e's were counted.\n";
}

تابع ()cout.put

برنامه زير، اولين حرف از هر کلمه ورودی را به حرف بزرگ تبديل کرده و آن را مجددا در خروجی چاپ می‌کند:

int main()
{  char ch, pre = '\0';
   while (cin.get(ch))
   {  if (pre = = ' ' || pre = = '\n')
         cout.put(char(toupper(ch)));
      else cout.put(ch);
      pre = ch;
   }
}

توابع ()cin.ignore و ()cin.putback

با استفاده از برنامه زير، تابعی آزمايش می‌شود که اين تابع اعداد صحيح را از ورودی استخراج می‌کند:

int nextInt();
int main()
{  int m = nextInt(), n = nextInt();
   cin.ignore(80,'\n');         // ignore rest of input line
   cout << m << " + " << n << " = " << m+n << endl;
}
int nextInt()
{  char ch;
   int n;
   while (cin.get(ch))
      if (ch >= '0' && ch <= '9')  // next character is a digit
      {  cin.putback(ch);          // put it back so it can be
         cin >> n;                 // read as a complite int
         break;
      }
   return n;
}

تابع ()cin.peek

اين‌ نسخه‌ از تابع‌ ()nextInt معادل‌ آن‌ است‌ که‌ در مثال‌ قبلی بود:

int nextInt()
{  char ch;
   int n;
   while (ch = cin.peek())
      if (ch >= '0' && ch <= '9')
      {  cin >> n;
         break;
      }
      else cin.get(ch);
   return n;
}

توابع‌ کاراکتری ++C

در مثال به تابع () toupper اشاره شد. اين فقط يکی از توابعی است که برای دست‌کاری کاراکترها استفاده می‌شود. ساير توابعی که در سرفايل <ctype.h> يا <cctype> تعريف شده به شرح زير است:

•  تابع () isalnum

int isalnum(int c);

اگر C کاراکتر الفبایی یا عددی باشد مقدار غیر صفر، وگرنه صفر را بر‌می‌گرداند.

• تابع () isalpha

int isalpha(int c);

اگر C کاراکتر الفبایی باشد مقدار غیرصفر و در غیر آن، صفر را برمی‌گرداند.

• تابع () iscntrl1

int iscntr1(int C);

اگر C کاراکتر کنترلی باشد مقدار غیر صفر و در غیر آن، صفر را بر‌می‌گرداند.

• تابع () isdigit

int isdigit (int C)

اگر C کاراکتر عددی باشد، مقدار غیر صفر و در غیر آن، صفر را برمی‌گرداند.

• تابع () isgraph

int isgraph (int C);

اگر C کاراکتر چاپی و غیر خالی باشد، مقدار غیر صفر وگرنه صفر را برمی‌گرداند.

• تابع ()islower

int islower (int C);

اگر C حرف کوچک باشد مقدار غیر صفر و در غیر آن، صفر را برمی‌گرداند.

• تابع () isprint

int isprint (int C);

اگر C کاراکتر قابل چاپ باشد مقدار غیر صفر و در غیر این‌صورت صفر را برمی‌گرداند.

• تابع () ispunct

int ispunct (int C);

اگر C کاراکتر چاپی به غیر از حروف و اعداد و فضای خالی باشد، مقدار غیر صفر برمی‌گرداند، وگرنه مقدار صفر را برمی‌گرداند.

• تابع () isspace

int isspace (int C);

اگر C کاراکتر فضای سفید شامل فضای خالی ‘  ‘ و عبور فرم ‘ f\ ‘ و خط جدید ‘ n\ ‘ و بازگشت نورد ‘ r\ ‘ و پرش افقی ‘ t\ ‘ و پرش عمودی ‘ v\ ‘ باشد، مقدار غیر صفر را برمی‌گرداند وگرنه صفر را برمی‌گرداند.

• تابع () isupper

int isupper (int C);

اگر C حرف بزرگ باشد، مقدار غیر صفر و در غیر این‌صورت صفر را برمی‌گرداند.

• تابع () isxdigit

int isxdigit (int C);

اگر C یکی از ده کاراکتر عددی یا یکی از دوازده عدد شانزده‌دهی شامل ‘D’و ‘E’و ‘F’و ‘C’و ‘B’و ‘A’ و’f’ و’e’ و’d’و ‘c’و ‘b’ و’a’ باشد، مقدار عیر صفر وگرنه مقدار صفر را برمی‌گرداند.

• تابع () tolower

int tolower (int C);

اگر C حرف بزرگ باشد، کاراکتر کوچک معادل آن را برمی‌گرداند وگرنه خود C را برمی‌گرداند.

• تابع () toupper

int toupper (int C);

اگر C حرف کوچک باشد، کاراکتر بزرگ معادل آن را برمی‌گرداند وگرنه خود C را برمی‌گرداند.

توجه کنيد که همه توابع فوق يک پارامتر از نوع int دريافت می‌کنند و يک مقدار int را برمی‌گردانند. علت اين است که نوع char در اصل يک نوع صحيح است. در عمل وقتی توابع فوق را به کار می‌برند، يک مقدار char به تابع می‌فرستند و مقدار بازگشتی را نيز در يک char ذخيره می‌کنند. به همين خاطر اين توابع را به عنوان «توابع کاراکتری» در نظر می‌گيريم.

آرايه‌ای از رشته‌ها

در ادامه پست رشته های کاراکتری در ++C با ما همراه باشید. به خاطر داريد که در پست آرایه‌ها در ++C گفتيم يک آرايه دوبعدی در حقيقت آرايه‌ای يک بعدی است که هر کدام از اعضای آن يک آرايه يک بعدی ديگر است. مثلا در آرايه دو بعدی که به شکل مقابل اعلان شده باشد:

char name[5][20]; 

اين آرايه در اصل پنج عضو دارد که هر عضو می‌تواند بيست کاراکتر داشته باشد. اگر آرايه فوق را با تعريف رشته‌های کاراکتری مقايسه کنيم، نتيجه اين می‌شود که آرايه بالا يک آرايه پنج عنصری است که هر عنصر آن يک رشته کاراکتری بيست حرفی است. اين آرايه را می‌توانيم به شکل مقابل تصور کنيم.

از طريق name[0] و name[1] و name[2] و name[3] و name[4] می‌توانيم به هر يک از رشته‌های کاراکتری در آرايه بالا دسترسی داشته باشيم. يعني آرايه name گرچه به صورت يک آرايه دوبعدی اعلان شده ليکن به صورت يک آرايه يک بعدی با آن رفتار می‌شود.

آرايه‌ای از رشته‌های کاراکتری

برنامه زير چند رشته کاراکتری را از ورودی می‌خواند و آن‌ها را در يک آرايه ذخيره کرده و سپس مقادير آن آرايه را چاپ می‌کند:

int main()
{  char name[5][20];
   int count=0;
   cout << "Enter at most 4 names with at most 19 characters:\n";
   while (cin.getline(name[count++], 20)) ;
   --count;
   cout << "The names are:\n";
   for (int i=0; i<count; i++)
      cout << "\t" << i << ". [" << name[i] << "]" << endl;
}

يک آرايه رشته‌ای پويا

اين برنامه نشان مي‌دهد که چگونه می‌توان از کاراکتر ‘$’ به عنوان کاراکتر نگهبان در تابع ()getline استفاده کرد. مثال زير تقريبا معادل مثال قبلی است. برنامه زير مجموعه‌ای از اسامی را می‌خواند، طوری که هر اسم روی يک خط نوشته می‌شود و هر اسم با کاراکتر ‘n\’ پايان مي‌یابد. اين اسامی در آرايه name ذخيره می‌شوند. سپس نام‌های ذخيره شده در آرايه name چاپ می‌شوند:

int main()
{  char buffer[80];
   cin.getline(buffer,80,'$');
   char* name[4];
   name[0] = buffer;
   int count = 0;
   for (char* p=buffer; *p ! '\0'; p++)
      if (*p == '\n')
      {  *p = '\0';              // end name[count]
         name[++count] = p+1;    // begin next name
      }
   cout << "The names are:\n";
   for (int i=0; i<count; i++)
      cout << "\t" << i << . [" << name[i] << "]" << endl;
}

مقداردهی يک آرايه رشته‌ای

اين برنامه هم آرايه رشته‌ای name را مقداردهی کرده و سپس مقادير آن را چاپ می‌نمايد:

int main()
{char* name[]= { "Mostafa Chamran", "Mehdi Zeinoddin", "Ebrahim Hemmat" };
      cout << "The names are:\n";
      for (int i = 0; i < 3; i++)
         cout << "\t" << i << ". [" << name[i] << "]" 
              << endl;
}

توابع رشته‌های کاراکتری

سرفايل‌ <cstring> که به آن «کتابخانه رشته‌های کاراکتری» هم می‌گويند، شامل خانواده توابعی است که برای دست‌کاری رشته‌های کاراکتری خيلی مفيدند. مثال بعدی ساده‌ترين آن‌ها يعنی تابع طول رشته را نشان می‌دهد. اين تابع، طول يک رشته کاراکتری ارسال شده به آن (يعنی تعداد کاراکترهای آن رشته) را برمی‌گرداند.

تابع‌ ()strlen:

برنامه زير يک برنامه آزمون ساده برای تابع ()strlen است. وقتی strlen(s) فراخوانی می‌شود، تعداد کاراکترهای درون رشته s که قبل از کاراکتر NUL قرار گرفته‌اند، بازگشت داده می‌شود:

#include <cstring>
int main()
{  char s[] = "ABCDEFG";
   cout << "strlen(" << s << ") = " << strlen(s) << endl;
   cout << "strlen(\"\") = " << strlen("") << endl;
   char buffer[80];
   cout << "Enter string: ";   cin >> buffer;
   cout << "strlen(" << buffer << ") = " << strlen(buffer)  << endl;
}

توابع‌ ()strrchr(), strchr(), strstr

برنامه زير، مکان‌يابی يک کاراکتر يا زيررشته خاص را در رشته کاراکتريی s نشان می‌دهد:

#include <cstring>
int main()
{  char s[] = "The Mississippi is a long river.";
   cout << "s = \"" << s << "\"\n";
   char* p = strchr(s, ' ');
   cout << "strchr(s, ' ') points to s[" << p - s << "].\n";
   p = strchr(s, 'e');
   cout << "strchr(s, 'e') points to s[" << p - s << "].\n";
   p = strrchr(s, 'e');
   cout << "strrchr(s, 'e') points to s[" << p - s << "].\n";
   p = strstr(s, "is");
   cout << "strstr(s, \"is\") points to s[" << p – s
        << "].\n";
   p = strstr(s, "isi");
   cout << "strstr(s, \"is\") points to s[" << p – s
        << "].\n";
   if (p == NULL) cout << "strstr(s, \"isi\") returns
                           NULL\n";
}

تابع‌ ()strcpy

برنامه زير نشان می‌دهد که فراخوانی strcpy(s1, s2) چه تاثيری دارد:

#include <iostream>
#include <cstring>
int main()
{  char s1[] = "ABCDEFG";
   char s2[] = "XYZ";
   cout << "Before strcpy(s1,s2):\n";
   cout << "\ts1 = [" << s1 << "], length = " << strlen(s1)
        << endl;
   cout << "\ts2 = [" << s2 << "], length = " << strlen(s2)
        << endl;
   strcpy(s1,s2);
   cout << "After strcpy(s1,s2):\n";
   cout << "\ts1 = [" << s1 << "], length = " << strlen(s1)
        << endl;
   cout << "\ts2 = [" << s2 << "], length = " << strlen(s2)
        << endl;
}

تابع‌ ()strncpy

برنامه زير بررسی می‌کند که فراخوانی strncpy(s1, s2, n) چه اثری دارد:

int main()
{  char s1[] = "ABCDEFG";
   char s2[] = "XYZ";
   cout << "Before strncpy(s1,s2,2):\n";
   cout << "\ts1 = [" << s1 << "], length = " << strlen(s1)
        << endl;
   cout << "\ts2 = [" << s2 << "], length = " << strlen(s2)
        << endl;
   strncpy(s1,s2,2);
   cout << "After strncpy(s1,s2,2):\n";
   cout << "\ts1 = [" << s1 << "], length = " << strlen(s1)
        << endl;
   cout << "\ts2 = [" << s2 << "], length = " << strlen(s2)
        << endl;
}

تابع الصاق رشته ()stract

برنامه زير بررسی می‌کند که فراخوانی strcat(s1, s2) چه تاثيری دارد:

int main()
{  char s1[] = "ABCDEFG";
   char s2[] = "XYZ";
   cout << "Before strcat(s1,s2):\n";
   cout << "\ts1 = [" << s1 << "], length = " << strlen(s1)
        << endl;
   cout << "\ts2 = [" << s2 << "], length = " << strlen(s2)
        << endl;
   strcat(s1,s2);
   cout << "After strcat(s1,s2):\n";
   cout << "\ts1 = [" << s1 << "], length = " << strlen(s1)
        << endl;
   cout << "\ts2 = [" << s2 << "], length = " << strlen(s2)
        << endl;
}

نگاهی دقيق‌تر به تبادل داده‌ها در ++C

در مبحث رشته های کاراکتری در ++C وقتی می‌خواهيم داده‌هايی را وارد کنيم، اين داده‌ها را در قالب مجموعه‌ای از کاراکترها تايپ می‌کنيم. همچنين وقتی می‌خواهيم نتايجی را به خارج از برنامه بفرستيم، اين نتايج در قالب مجموعه‌ای از کاراکترها نمايش داده می‌شوند.

لازم است که اين کاراکترها به نحوی برای برنامه تفسير شوند. مثلا وقتی قصد داريم يک عدد صحيح را وارد کنيم، چند کاراکتر عددی تايپ می‌کنيم. حالا ساز و کاری لازم است که از اين کاراکترها يک مقدار صحيح بسازد و به برنامه تحويل دهد. همچنين وقتی قصد داريم يک عدد اعشاری را به خروجی بفرستيم، بايد با استفاده از راه‌کاری، آن عدد اعشاری به کاراکترهايی تبديل شود تا در خروجی نمايش يابد.

جريان‌ها اين وظايف را در ++C بر عهده دارند. جريان‌ها شبيه پالايه‌ای هستند که داده‌ها را به کاراکتر تبديل می‌کنند و کاراکترها را به داده‌هايی از يک نوع بنيادی تبديل می‌نمايند. به طور کلی، ورودی‌ها و خروجی‌ها را يک کلاس جريان به نام stream کنترل می‌کند. اين کلاس خود به زيرکلاس‌هايی تقسيم می‌شود.

شیء istream جريانی است که داده‌های مورد نياز را از کاراکترهای وارد شده از صفحه کليد، فراهم می‌کند. شیء ostream جريانی است که داده‌های حاصل را به کاراکترهای خروجی قابل نمايش روی صفحه نمايش‌گر تبديل می‌نمايد.

شیء ifstream جريانی است که داده‌های مورد نياز را از داده‌های داخل يک فايل، فراهم می‌کند. شیء ofstream جريانی است که داده‌های حاصل را درون يک فايل ذخيره می‌نمايد. اين جريان‌ها و طريقه استفاده از آن‌ها را در ادامه خواهيم ديد.

استفاده‌ از عملگر بيرون‌کشی برای کنترل کردن يک حلقه‌:

int main()
{  int n;
   while (cin >> n)
      cout << "n = " << n << endl;
}

ورودی قالب‌بندی نشده‌

سرفايل <iostream> توابع مختلفی برای ورودی دارد. اين توابع برای وارد کردن کاراکترها و رشته‌های کاراکتری در ++C به کار می‌روند که کاراکترهای فضای سفيد را ناديده نمی‌گيرند. رايج‌ترين آن‌ها، تابع ()cin.get برای دريافت يک کاراکتر تکی و تابع ()cin.getline برای دريافت يک رشته کاراکتری است.

دريافت کاراکترها با استفاده از تابع ()cin.get در ++C

while (cin.get(c))
{  if (c >= 'a' && c <= 'z') c += 'A' - 'a';   // capitalize c
   cout.put(c);
}

وارد کردن يک رشته کاراکتری به وسيله تابع ()cin.getline در ++C

برنامه زير نشان می‌دهد که چطور می‌توان داده‌های متنی را خط به خط از ورودی خوانده و درون يک آرايه رشته‌ای قرار داد:

const int LEN=32;        // maximum word length
const int SIZE=10;       // array size
typedef char Name[LEN];  // defines Name to be a C_string type
int main()
{  Name martyr[SIZE]; // defines martyr to be an array of 10 names
   int n=0;
   while(cin.getline(martyr[n++], LEN) && n<SIZE)
      ;
   --n;
   for (int i=0; i<n; i++)
      cout << '\t' << i+1 << ". " << martyr[i] << endl;
}

نوع‌ string در ++C

در رشته‌های کاراکتری در ++C نوع داده‌ای خاصی به نام string وجود دارد که مشخصات اين نوع در سرفايل <string> تعريف شده است. برای آشنايی با اين نوع جديد، از طريقه اعلان و مقداردهی آن شروع می‌کنيم. اشيايی که از نوع string هستند به چند طريق می‌توانند اعلان و مقداردهی شوند:

string s1; 		        	    // s1 contains 0 characters
string s2 = "PNU University";       // s2 contains 14 characters
string s3(60, '*');         	    // s3 contains 60 asterisks
string s4 = s3;             	    // s4 contains 60 asterisks
string s5(s2, 4, 2);         // s5 is the 2-character string "Un"

استفاده از نوع string

کد زير يک مجموعه کاراکتر را از ورودی می‌گيرد و سپس بعد از هر کاراکتر “E” يک علامت ويرگول ‘,’ اضافه می‌نمايد. مثلا اگر عبارت “The SOFTWARE MOVEMENT is began” وارد شود، برنامه زیر آن را به جمله زیر تبدیل می‌کند: The SOFTWARE, MOVE,ME,NT is began . متن برنامه چنین است:

string word;
int k;
while (cin >> word)
{  k = word.find("E") + 1;
   if (k < word.length())
      word.relace(k, 0, ",");
   cout << word << ' ';
}

فایل‌ها در ++C

يکي از مزيت‌های رايانه، قدرت نگهداری اطلاعات حجيم است. فايل‌ها اين قدرت را به رايانه می‌دهند. اگر چيزی به نام فايل وجود نداشت، شايد رايانه‌ها به شکل امروزی توسعه و کاربرد پيدا نمی‌کردند. چون اغلب برنامه‌های امروزی با فايل‌ها سر و کار دارند، يک برنامه‌نويس لازم است که با فايل آشنا باشد و بتواند با استفاده از اين امکان ذخيره و بازيابی، کارايی برنامه‌هايش را ارتقا دهد.

پردازش‌ فايل‌ در ++C بسيار شبيه‌ تراکنش‌های معمولی ورودی و خروجی است زيرا اين‌ها همه از اشيای جريان مشابهی بهره می‌برند. جريان fstream برای تراکنش برنامه با فايل‌ها به کار می‌رود. fstream نيز به دو زيرشاخه ifstream و ofstream تقسيم می‌شود.

جريان ifstream برای خواندن اطلاعات از يک فايل به کار می‌رود و جريان ofstream برای نوشتن اطلاعات درون يک فايل استفاده می‌شود. فراموش نکنيد که اين جريان‌ها در سرفايل <fstream> تعريف شده‌اند، پس بايد دستور پيش‌پردازنده #include <fstream> را به ابتدای برنامه بيافزاييد. سپس می‌توانيد عناصری از نوع جريان فايل به شکل زير تعريف کنيد:

ifstream readfile("INPUT.TXT");
ofstream writefile("OUTPUT.TXT");

طبق کدهای فوق، readfile عنصری است که داده‌ها را از فايلی به نام INPUT.TXT می‌خواند و writefile نيز عنصری است که اطلاعاتی را در فايلی به نام OUTPUT.TXT می‌نويسد. اکنون می‌توان با استفاده از عملگر << داده‌ها را به درون readfile خواند و با عملگر >> اطلاعات را درون writefile نوشت. به مثال زير توجه کنيد.

 ایجاد يک دفتر تلفن‌ در ++C

در ادامه مبحث رشته‌ های کاراکتری در ++C به ایجاد یک دفتر تلفن  می‌پردازیم. برنامه زير، چند نام و تلفن مربوط به هر يک را به ترتيب از کاربر دريافت کرده و در فايلی به نام PHONE.TXT ذخيره می‌کند. کاربر برای پايان دادن به ورودی بايد عدد  0 را تايپ کند.

#include <fstream>
#include <iostream>
using namespace std;
int main()
{  ofstream phonefile("PHONE.TXT");
   long number;
   string name;
   cout << "Enter a number for each name. (0 for quit): ";
   for ( ; ; )
   {  cout << "Number: ";
      cin >> number;
      if (number == 0) break;
      phonefile << number << ' ';
      cout << "Name: ";
      cin >> name;
      phonefile << name << ' ';
      cout << endl;
   }
}

جستجوی يک شماره در دفتر تلفن‌

اين برنامه، فايل توليد شده توسط برنامه قبل را به کار می‌گيرد و درون آن به دنبال يک شماره تلفن می‌گردد:

#include <fstream>
#include <iostream>
using namespace std;
int main()
{  ifstream phonefile("PHONE.TXT");
   long number;
   string name, searchname;
   bool found=false;
   cout << "Enter a name for findind it's phone number: ";
   cin >> searchname;
   cout << endl;
   while (phonefile >> number)
   {  phonefile >> name;
      if (searchname == name) 
      {  cout << name << ' ' << number << endl;
         found = true;
      }   if (!found) cout << searchname
                    << " is not in this phonebook." << endl;
}

سخن پایانی فایل ها و رشته های کاراکتری در ++C

در این جلسه مروری بر اشاره‌گرها داشتیم. رشته ‌های کاراکتری، ورودی و خروجی، توابع کارکتری و فایل‌ها را توضیح دادیم. امیدوارم این مطالب برای شما عزیزان مفید بوده باشد. در جلسه‌های قبلی به مباحث متغیر‌ها در ++C، آرایه‌ها در ++C، توابع در ++C، شرط و انتخاب و حلقه و تکرار در ++C پرداختیم. منتظر نظرات و پیشنهادات شما عزیزان هستیم. موفق و پیروز باشید.