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

مقدمه فایل‌ها و رشته های کاراکتری در ++C استاندارد

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

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

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

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

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

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

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

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

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

char str[] = "string";

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

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

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

cout << str;

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

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

cin >> str;

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

۵. توابع تعریف شده در سرفایل <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

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

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 استفاده می‌شوند و البته بخش مهمی از ++C نیز محسوب می‌شوند زیرا وسیله مفیدی برای پردازش سریع داده‌ها هستند. اما این سرعت پردازش، هزینه‌ای هم دارد: خطر خطاهای زمان اجرا. این خطاها معمولا از این ناشی می‌شوند که فقط بر کاراکتر NUL به عنوان پایان رشته تکیه می‌شود.

رشته های کاراکتری در ++C امن‌تر و مطمئن‌تر هستند. در این رشته‌ها، طول رشته نیز درون رشته ذخیره می‌شود و لذا فقط به کاراکتر NUL برای مشخص نمودن انتهای رشته اکتفا نمی‌شود.

نگاهی دقیق‌تر به تبادل داده‌ها در ++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 ذخیره می‌کند. کاربر برای پایان دادن به ورودی باید عدد  ۰ را تایپ کند.

#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، توابع در ++C، کامپایلر آنلاین در ++C، شرط و انتخاب و حلقه و تکرار در ++C پرداختیم. در جلسه بعد با مفهوم شی‌گرایی در زبان ++C در خدمت شما عزیزان خواهیم بود. منتظر نظرات و پیشنهادات شما عزیزان هستیم. موفق و پیروز باشید.