സി ++ സ്ട്രിംഗുകൾ



സ്ട്രിംഗ്

ഞങ്ങളുടെ പ്രോഗ്രാമിൽ സ്ട്രിംഗുകൾ സൃഷ്ടിക്കുന്നതിനും ഉപയോഗിക്കുന്നതിനും മൂന്ന് അടിസ്ഥാന വഴികൾ സി ++ നൽകുന്നു:

  1. ചാർ ഘടകങ്ങളുടെ ഒരു നിര ഉപയോഗിക്കുന്നു
  2. ഉപയോഗിക്കുന്നു string ക്ലാസ്
  3. ഉപയോഗിക്കുന്നു wchar_t വിശാലമായ പ്രതീകങ്ങൾക്കായി

പ്രതീകങ്ങളുടെ നിര

പ്രതീകങ്ങളുടെ ഒരു ശ്രേണിയാണ് സ്ട്രിംഗ്. char സി ++ ലെ ഒരൊറ്റ പ്രതീകത്തെ പ്രതിനിധീകരിക്കുന്നതിന് ഡാറ്റ തരം ഉപയോഗിക്കുന്നു. അതിനാൽ നിങ്ങളുടെ പ്രോഗ്രാമിൽ ഒരു സ്ട്രിംഗ് ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ നിങ്ങൾക്ക് ഒരു കൂട്ടം പ്രതീകങ്ങൾ ഉപയോഗിക്കാം. ഒരു കൂട്ടം പ്രതീകങ്ങൾ ഉപയോഗിച്ച് സ്‌ട്രിംഗിന്റെ പ്രഖ്യാപനവും നിർവചനവും മറ്റേതൊരു ഡാറ്റാ തരത്തിന്റെയും അറേയുടെ പ്രഖ്യാപനത്തിനും നിർവചനത്തിനും സമാനമാണ്:

//define an array of chars with 10 elements
char msg[10] = { 'M', 'E', 'S', 'S', 'A', 'G', 'E', '\0' };

ഏത് സ്ട്രിംഗും അവസാനിക്കുന്ന ശൂന്യമായ പ്രതീകമായ '\ 0' ഉപയോഗിച്ച് അവസാനിക്കുന്നു. അത്തരത്തിലുള്ള ഒരു അറേ നിർവചനത്തിൽ അവസാന ഘടകമായി '\ 0' എന്ന ശൂന്യ പ്രതീകം ഉൾപ്പെടുത്തണം. മുകളിൽ പറഞ്ഞ സാഹചര്യത്തിൽ ഒരു അറേയുടെ ശേഷി 10 ആണെങ്കിലും ഞങ്ങൾ അതിൽ 8 എണ്ണം മാത്രമാണ് ഉപയോഗിച്ചിരിക്കുന്നത്. ഒരു അറേയുടെ ശേഷിക്കുന്ന രണ്ട് പ്രതീകങ്ങൾ നിർവചിക്കില്ല.

ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ ചലനാത്മക ദൈർഘ്യമുള്ള പ്രതീകങ്ങളുടെ ഒരു നിര പ്രഖ്യാപിക്കാനും നിർവചിക്കാനുമുള്ള മറ്റൊരു മാർഗം:

char msg2[] = { 'M', 'E', 'S', 'S', 'A', 'G', 'E', '\0' };

മുകളിൽ പറഞ്ഞ സന്ദർഭങ്ങളിൽ, പ്രതീകങ്ങളുടെ ശ്രേണി സംഭരിക്കുന്നതിന് അനുവദിച്ച മെമ്മറിയുടെ അളവ് കൃത്യമായി തുല്യമായിരിക്കും.

പ്രതീകങ്ങളുടെ ഒരു നിര സമാരംഭിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതമായ മാർ‌ഗ്ഗം ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ ഇരട്ട ഉദ്ധരണികളിൽ‌ സ്‌ട്രിംഗ് അക്ഷരാർത്ഥത്തിൽ ഉപയോഗിക്കുക എന്നതാണ്:

char msg3[] = "Message";

എന്നതിൽ നിന്നുള്ള ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ചാർ അറേകളിൽ ചില അടിസ്ഥാന പ്രവർത്തനങ്ങൾ നടത്താൻ കഴിയും cstring പോലുള്ള ലൈബ്രറി:

ഒരു സ്ട്രിംഗ് മറ്റൊന്നിലേക്ക് പകർത്തുക

strcpy_s(destination, source)

ഉപയോഗിക്കുന്നതിനുള്ള ഡെമോ ചുവടെയുണ്ട് strcpy_s
char msg[10] = { 'M', 'E', 'S', 'S', 'A', 'G', 'E', '\0' };
char dest[20];
strcpy_s(dest, msg);
cout << "String copied from msg = " << dest << endl;

മുകളിലുള്ള ഉദാഹരണത്തിന്റെ output ട്ട്‌പുട്ട് ചുവടെ കാണിച്ചിരിക്കുന്നു

സ്ട്രിംഗ് msg = MESSAGE ൽ നിന്ന് പകർത്തി

ഒരു സ്ട്രിംഗ് മറ്റൊന്നിലേക്ക് സംയോജിപ്പിക്കുക

strcat_s(string1, string2)

സ്ട്രിംഗ് 2 സ്ട്രിംഗിന്റെ അവസാനത്തിൽ കൂട്ടിച്ചേർക്കും
//declare 2 messages
char string1[20] = "Good";
char string2[] = " Morning";
//concatenate strings
strcat_s(string1, string2);
cout << string1 << endl;

പ്രോഗ്രാമിന് മുകളിലുള്ള OS ട്ട്‌പുട്ട് ഇതായിരിക്കും:

സുപ്രഭാതം

കുറിപ്പ്: സ്ട്രിംഗ് 1 ഉപയോഗിച്ച് സംയോജിപ്പിക്കാൻ നിങ്ങൾക്ക് സ്ട്രിംഗ് 2 ൽ മതിയായ സ space ജന്യ സ്ഥലം ഉണ്ടായിരിക്കണം.

സ്ട്രിംഗിന്റെ നീളം നേടുക

strlen(string)

cout << "Length of the string 2 is " << strlen(string2) << endl;

മുകളിലുള്ള കോഡിന്റെ put ട്ട്‌പുട്ട് ആയിരിക്കും

സ്ട്രിംഗ് 2 ന്റെ നീളം 8 ആണ്

സ്ട്രിംഗ്: “രാവിലെ” 7 പ്രതീകങ്ങളിലും 8 പേരിലും സംഭരിച്ചിരിക്കുന്നുth പ്രതീകം അസാധുവായ പ്രതീകമാണ് - '\ 0'

രണ്ട് സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുക

strcmp(string1, string2)

ഈ പ്രവർത്തനം മടങ്ങും 0, സ്ട്രിംഗുകൾ തുല്യമാണെങ്കിൽ; നെഗറ്റീവ് മൂല്യം, സ്ട്രിംഗ് 1 ആണെങ്കിൽ കുറവ് സ്ട്രിംഗ് 2 എന്നതിനേക്കാളും നല്ല സ്ട്രിംഗ് 1 ആണെങ്കിൽ മൂല്യം കൂടുതൽ സ്ട്രിംഗ് 2 നെക്കാൾ.
//declare two strings
char str1[100];
char str2[100];
//get user input of strings:
cout << "Please enter the first string\n";
cin >> str1;
cout << "Please enter the second string\n";
cin >> str2;
//compare strings
int result = strcmp(str1, str2);
if (result == 0)
{
	//strings are equals
	cout << str1 << " is equal to " << str2 << endl;
}
else
{
	if (result > 0)//str1 is greater
		cout << str1 << " is greater than " << str2 << endl;
	else//str2 is greater
		cout << str1 << " is less than " << str2 << endl;
}

മുകളിലുള്ള പ്രോഗ്രാമിന്റെ output ട്ട്‌പുട്ട് ചുവടെയുണ്ട്


ആദ്യ സ്ട്രിംഗ് നൽകുക
abc
രണ്ടാമത്തെ സ്ട്രിംഗ് നൽകുക
abd
abc abd നേക്കാൾ കുറവാണ്

strcmp ലെക്സിക്കോഗ്രാഫിക്കൽ (അക്ഷരമാലാക്രമത്തിൽ) സ്ട്രിംഗുകളെ താരതമ്യം ചെയ്യുന്നു. സ്ട്രിംഗുകൾക്ക് “കുറവ്” എന്നതിനർത്ഥം “പൂച്ച” “നായ” യേക്കാൾ കുറവാണ്, കാരണം “പൂച്ച” അക്ഷരമാലാക്രമത്തിൽ “നായ” ക്ക് മുമ്പായി വരുന്നു.

സ്ട്രിംഗ് ക്ലാസ്

സ്റ്റാൻഡേർഡ് സി ++ ലൈബ്രറി നൽകുന്ന ക്ലാസ് ഉപയോഗിച്ച് സ്ട്രിംഗുകളെ പ്രതിനിധീകരിക്കുന്നതിനുള്ള മറ്റൊരു മാർഗം. ഈ ക്ലാസിന് പേര് നൽകിയിട്ടുണ്ട് string സി ++ ലെ ചാർ അറേകളേക്കാൾ വളരെയധികം പ്രവർത്തനക്ഷമത ഇതിന് ഉണ്ട്. നിങ്ങളുടെ പ്രോഗ്രാമുകളിൽ “സ്ട്രിംഗ്” ക്ലാസ് ഉപയോഗിക്കുന്നത് നിങ്ങൾക്ക് കൂടുതൽ കഴിവുകൾ വാഗ്ദാനം ചെയ്യുന്നു. നിങ്ങളുടെ പ്രോഗ്രാമിൽ സ്ട്രിംഗുകൾ ഉപയോഗിക്കുന്നതിന് ഇനിപ്പറയുന്ന സ്റ്റേറ്റ്മെന്റ് ഉൾപ്പെടുത്തണം:

#include <string>

ഈ തലക്കെട്ട് ഫയൽ ഉൾപ്പെടുത്തിയ ശേഷം നിങ്ങളുടെ പ്രോഗ്രാമിൽ സ്ട്രിംഗ് ഒബ്ജക്റ്റുകൾ ഉപയോഗിക്കാൻ കഴിയും. ഒരു സ്ട്രിംഗ് പ്രഖ്യാപിക്കുന്നതിനും നിർവചിക്കുന്നതിനുമുള്ള ഉദാഹരണം ഇതാ:
string s1 = "Have a";
string s2 = " nice day";

കൂടെയുള്ള ജോലി സ്ട്രിംഗ് ക്ലാസ് വളരെ എളുപ്പമാണ്.

കോൺകറ്റനേറ്റ് സ്ട്രിംഗുകൾ

സ്ട്രിംഗുകളുമായി ഒത്തുചേരുന്നതിന് പ്ലസ് ചിഹ്നം ഉപയോഗിക്കുക:

string s3 = s1 + s2;
cout << s3 << endl;

മുകളിലുള്ള കോഡിന്റെ output ട്ട്‌പുട്ട് ചുവടെയുണ്ട്

ഒരു നല്ല ദിനം ആശംസിക്കുന്നു

ഒരു സ്ട്രിംഗിന്റെ നീളം

ഒരു സ്ട്രിംഗിന്റെ ദൈർഘ്യം ലഭിക്കാൻ, ഉദാഹരണത്തിന്, “s3”, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഫംഗ്ഷൻ ഉപയോഗിക്കാം

s3.length()

സ്ട്രിംഗ് ദൈർഘ്യം നേടുന്നതിനുള്ള ഉദാഹരണം
cout << "Length of s3 is " << s3.length() << endl;

മുകളിലുള്ള കോഡിന്റെ output ട്ട്‌പുട്ട് ചുവടെയുണ്ട്

എസ് 3 ന്റെ നീളം 15 ആണ്

ഒരു സ്ട്രിംഗ് മറ്റൊന്നിലേക്ക് പകർത്തുക

ഒരു സ്ട്രിംഗ് മറ്റൊന്നിലേക്ക് പകർത്താൻ അസൈൻമെന്റ് ഓപ്പറേറ്റർ ഉപയോഗിക്കുക

string s4 = s2;
cout << s4 << endl;

കോഡിന് മുകളിലുള്ള os ട്ട്‌പുട്ട് os ചുവടെയുണ്ട്

നല്ല ദിവസം

സ്‌ട്രിംഗ് സ്ഥിരമായ പ്രതീക അറേയിലേക്ക് പരിവർത്തനം ചെയ്യുക

ചില സമയങ്ങളിൽ ഒരു സ്‌ട്രിംഗ് ഒബ്‌ജക്റ്റ് സ്ഥിരമായ ചാർ അറേയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നത് ഉപയോഗപ്രദമാണ്. ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും c_str() ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ പ്രവർത്തിക്കുക

const char* cstr = s3.c_str();

സ്ട്രിംഗ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കുക

നിങ്ങൾക്ക് ഉപയോഗിക്കാം empty() സ്ട്രിംഗ് ശൂന്യമാണോ അല്ലയോ എന്ന് നിർണ്ണയിക്കുന്നതിനുള്ള സ്ട്രിംഗിന്റെ പ്രവർത്തനം. ഒരു സ്ട്രിംഗ് ശൂന്യമാണെങ്കിൽ, പ്രവർത്തിക്കുക ശൂന്യമാണ് () തിരിച്ചു വരും true അല്ലെങ്കിൽ false

എങ്ങനെ ഉപയോഗിക്കാമെന്ന് കാണിച്ചിരിക്കുന്ന കോഡ് ചുവടെയുണ്ട് empty()

if (s4.empty())
	cout << "s4 is empty" << endl;
else
	cout << s4 << endl;

സ്ട്രിംഗുകൾ കൈകാര്യം ചെയ്യുന്നതിന് പ്രോഗ്രാമറിന് സ്ട്രിംഗ് ക്ലാസ് ധാരാളം കഴിവുകൾ നൽകുന്നു, പക്ഷേ ഞങ്ങൾ ഇപ്പോൾ ചർച്ച ചെയ്യുന്നത് അടിസ്ഥാന കാര്യങ്ങൾ മാത്രമാണ്. അടുത്ത വിഷയങ്ങളിൽ സ്ട്രിംഗ് ക്ലാസിനെക്കുറിച്ച് ഞങ്ങൾ കൂടുതൽ വിവരങ്ങൾ നൽകും.

വിശാലമായ പ്രതീകം wchar_t

വിശാലമായ പ്രതീകം wchar_t ലളിതമായ പ്രതീക ഡാറ്റാ തരത്തേക്കാൾ വലുപ്പമുള്ള ഒരു ഡാറ്റ തരമാണ്. ഈ ഡാറ്റാ ടൈപ്പ് “2 അല്ലെങ്കിൽ 4” ബൈറ്റുകൾ ഉൾക്കൊള്ളുന്നു. സ്ട്രിംഗുകളെ പ്രതിനിധീകരിക്കുന്നതിന് വിപുലീകൃത പ്രതീക സെറ്റുകൾ ഉപയോഗിക്കാനുള്ള കഴിവ് ഈ തരം നൽകുന്നു. ചൈനീസ്, ജാപ്പനീസ് പോലുള്ള അന്തർ‌ദ്ദേശീയ ഭാഷകൾ‌ ഉപയോഗിക്കുമ്പോൾ‌ പ്രധാനമായും wchar_t ഡാറ്റാ ടൈപ്പ് ഉപയോഗിക്കുന്നു. പ്രതിനിധീകരിക്കാൻ ഡാറ്റ തരത്തിൽ അന്തർനിർമ്മിതമായ സി ++ നൽകുന്നു wchar_t വിശാലമായ പ്രതീകങ്ങൾ.

വൈഡ് ക്യാരക്ടർ വേരിയബിളിന്റെ പ്രഖ്യാപനം ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യാം:

wchar_t wideString;

വിശാലമായ പ്രതീകങ്ങളുടെ ഒരു നിര ഉപയോഗിക്കുന്നതിന് ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ നിങ്ങൾ wchar_t ന്റെ ഒരു നിര പ്രഖ്യാപിക്കണം:
wchar_t wideString[100];

പ്രവർത്തിക്കാൻ wchar_t നിങ്ങൾ ഉൾപ്പെടുത്തേണ്ട തരം wchar ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ നിങ്ങളുടെ പ്രോഗ്രാമിലെ ലൈബ്രറി:
#include <wchar.h>

വിശാലമായ പ്രതീകങ്ങൾക്കൊപ്പം പ്രവർത്തിക്കാൻ വ്യത്യസ്ത പ്രവർത്തനങ്ങളും സ്ഥിരതകളും Wchar ലൈബ്രറി വാഗ്ദാനം ചെയ്യുന്നു. ൽ നിരവധി സ്ഥിരതകളുണ്ട് wchar ലൈബ്രറി:
  • NULL - ശൂന്യ പോയിന്റർ സ്ഥിരാങ്കത്തെ പ്രതിനിധീകരിക്കുന്നു.
  • WCHAR_MAX - whcar_t യുടെ പരമാവധി മൂല്യം പ്രതിനിധീകരിക്കുന്നു
  • WCHAR_MIN - wchar_t യുടെ ഏറ്റവും കുറഞ്ഞ മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്നു.
  • WEOF - ഫയലിന്റെ അവസാനം സൂചിപ്പിക്കാൻ സ്ഥിരമായി ഉപയോഗിക്കുന്നു.

വിശാലമായ പ്രതീക സ്‌ട്രിംഗിന് ഒരു മൂല്യം നൽകുന്നതിന് നിങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട് swprintfപ്രവർത്തനം:

int swprintf (wchar_t*  destinationString, size_t length, const wchar_t* formatString, ...);

ഇവിടെ പാരാമീറ്ററുകൾ ഇവയാണ്:
  • ഉദ്ദിഷ്ടസ്ഥാന സ്ട്രിംഗ് - ഫോർമാറ്റ് ചെയ്ത ഡാറ്റ സൂക്ഷിക്കുന്ന വിശാലമായ പ്രതീകങ്ങൾ. ഇത് wchar_t ന്റെ ഒരു ശ്രേണി അല്ലെങ്കിൽ ഒരൊറ്റ വിശാലമായ പ്രതീകം ആകാം.
  • ദൈർഘ്യം - എഴുതിയ പ്രതീകങ്ങളുടെ എണ്ണം. സ്‌ട്രിംഗിന്റെ അവസാനം ശൂന്യമായ പ്രതീകത്തിനായി സ്‌ട്രിംഗിന്റെ ദൈർഘ്യം ഒന്നായി വർദ്ധിപ്പിക്കാൻ നിങ്ങൾ ഓർക്കണം.
  • ഫോർമാറ്റ് സ്ട്രിംഗ് - ഫോർമാറ്റ് അനുസരിച്ച് ഡാറ്റ എഴുതാൻ ഉപയോഗിക്കുന്ന സ്ട്രിംഗ്.
  • … - ഫോർമാറ്റ് സ്ട്രിംഗിനൊപ്പം ഉപയോഗിക്കേണ്ട പാരാമീറ്ററുകൾ.

വിജയകരമായപ്പോൾ ഈ ഫംഗ്ഷന്റെ റിട്ടേൺ മൂല്യം എഴുതിയ പ്രതീകങ്ങളുടെ എണ്ണമാണ്.

ചുവടെ ഒരു ഉദാഹരണം

swprintf(wideString, 6, L"HELLO");

മുകളിലുള്ള സാഹചര്യത്തിൽ, ഫോർമാറ്റ് സ്ട്രിംഗ് ഒരു ലളിതമായ സ്ട്രിംഗാണ്, കൂടാതെ സ്ട്രിംഗ് a ലേക്ക് പരിവർത്തനം ചെയ്യാൻ “HELLO” ന് മുമ്പുള്ള “L” പ്രതീകവും ഉപയോഗിക്കുന്നു const wchar_t*

ഫോർമാറ്റ് സ്‌പെസിഫയറുകൾ ഉപയോഗിച്ച് ഫോർമാറ്റ് സ്‌ട്രിംഗ് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് അടുത്ത ഉദാഹരണം കാണിക്കുന്നു:

swprintf(myMessage, 13, L"My age is %d ", 20);

മുകളിലുള്ള കേസിൽ myMessage വേരിയബിളിൽ “എന്റെ പ്രായം 20 ആണ്".

ചില ഫോർമാറ്റ് സ്പെസിഫയറുകളുടെ പട്ടിക ഇനിപ്പറയുന്ന പട്ടികയിൽ പ്രതിനിധീകരിക്കുന്നു:

 സ്‌പെസിഫയർടൈപ്പ് ചെയ്യുക
 d, iദശാംശമോ പൂർണ്ണസംഖ്യയോ. ആർഗ്യുമെന്റ് ഒരു പൂർണ്ണ സംഖ്യയാണ്
 Uസൈൻ ചെയ്യാത്ത സംഖ്യ
 Oഒക്ടൽ പൂർണ്ണസംഖ്യ
 x, X.ഹെക്സാഡെസിമൽ സംഖ്യ
 Fഫ്ലോട്ടിംഗ് പോയിൻറ് മൂല്യം
 Eശാസ്ത്രീയ ഫ്ലോട്ടിംഗ് പോയിൻറ്
 cകഥാപാത്രം
 sസ്ട്രിംഗ്
 nInt ലേക്ക് പോയിന്റർ

വിശാലമായ പ്രതീകങ്ങൾ അച്ചടിക്കാൻ ഞങ്ങൾ ഉപയോഗിക്കണം wpritnf പ്രവർത്തനം:

int wprintf (const wchar_t* formatString, ...);

wprintf നിർദ്ദിഷ്ട ഫോർമാറ്റ് ഉപയോഗിച്ച് സ്റ്റാൻഡേർഡ് output ട്ട്‌പുട്ടിലേക്ക് വിശാലമായ പ്രതീകങ്ങൾ എഴുതുന്നു. ഉദാഹരണത്തിന്, മുകളിലുള്ള കോഡിൽ ഉപയോഗിച്ചിരിക്കുന്ന രണ്ട് വിശാലമായ പ്രതീക സ്ട്രിംഗുകളുടെ മൂല്യം ചുവടെ അച്ചടിക്കാൻ ഞങ്ങൾക്ക് കഴിയും
wprintf(wideString);
wprintf(myMessage);

നിങ്ങൾക്ക് ഉപയോഗിക്കാനാകുന്ന സ്റ്റാൻഡേർഡ് output ട്ട്‌പുട്ടിലേക്ക് വിശാലമായ പ്രതീകങ്ങൾ എഴുതാൻ wcout നിങ്ങൾ ഉപയോഗിച്ച അതേ രീതിയിൽ ഒബ്‌ജക്റ്റ് ചെയ്യുക cout output ട്ട്‌പുട്ട് ഡാറ്റയിലേക്ക്.
wcout << "Use of wcout " << wideString << endl;

കൺസോളിൽ നിന്നുള്ള വിശാലമായ പ്രതീകം വായിക്കാൻ നിങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട് wcin ഇതിനുപകരമായി cin
wchar_t name[50];
cout << "Enter your name" << endl;
wcin >> name;
cout << endl << "Your name is ";
wprintf(L"%s", name);