34

--- സി # ഗൈഡ് --- സ്ട്രിംഗുകൾ

ഒരു സാധാരണ പ്രോഗ്രാമിംഗ് വീക്ഷണകോണിൽ നിന്ന്, സ്ട്രിംഗ് സ്ട്രിംഗ് ഡാറ്റ തരം C# ലെ ഏറ്റവും പ്രധാനപ്പെട്ട ഒന്നാണ്. ഈ തരം പ്രതീക സ്ട്രിംഗുകളെ നിർവചിക്കുകയും പിന്തുണയ്ക്കുകയും ചെയ്യുന്നു. മറ്റ് നിരവധി പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ, ഒരു സ്ട്രിംഗ് എന്നത് പ്രതീകങ്ങളുടെ ഒരു നിരയാണ്. കൂടാതെ C#-ൽ, സ്ട്രിംഗുകൾ ഒബ്ജക്റ്റുകളാണ്. അതിനാൽ, സ്ട്രിംഗ് തരം ഒരു റഫറൻസ് തരമാണ്.

ബിൽഡിംഗ് സ്ട്രിംഗുകൾ

ഒരു പ്രതീക സ്ട്രിംഗ് നിർമ്മിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗം ഒരു സ്ട്രിംഗ് അക്ഷരാർത്ഥത്തിൽ ഉപയോഗിക്കുക എന്നതാണ്. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കോഡ് വരി സ്ട്രിംഗ് റഫറൻസ് വേരിയബിൾ str ഒരു സ്ട്രിംഗ് ലിറ്ററലിലേക്ക് ഒരു റഫറൻസ് നൽകുന്നു:

String str = "ഉദാഹരണ സ്ട്രിംഗ്";

ഈ സാഹചര്യത്തിൽ, "ഉദാഹരണ സ്ട്രിംഗ്" എന്ന അക്ഷരങ്ങളുടെ ക്രമം ഉപയോഗിച്ച് വേരിയബിൾ str ആരംഭിക്കുന്നു. ടൈപ്പ് ചാറിന്റെ ഒരു ശ്രേണിയിൽ നിന്നും ടൈപ്പ് സ്‌ട്രിംഗിന്റെ ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കാനാകും. ഉദാഹരണത്തിന്:

Char chararray = ("e", "x", "a", "m", "p", "l", "e"); സ്ട്രിംഗ് str = പുതിയ സ്ട്രിംഗ് (ചാരറേ);

ഒരു സ്ട്രിംഗ് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിച്ചുകഴിഞ്ഞാൽ, ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ടെക്‌സ്‌റ്റിന്റെ ഒരു സ്‌ട്രിംഗ് ആവശ്യമുള്ള എവിടെയും അത് ഉപയോഗിക്കാനാകും.

സ്ട്രിംഗ് പെർസിസ്റ്റൻസ്

വിചിത്രമെന്നു പറയട്ടെ, ടൈപ്പ് സ്ട്രിംഗിന്റെ ഒബ്‌ജക്റ്റിന്റെ ഉള്ളടക്കം മാറ്റാൻ കഴിയില്ല. ഇതിനർത്ഥം ഒരു പ്രതീക ശ്രേണി സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, അത് മാറ്റാൻ കഴിയില്ല എന്നാണ്. എന്നാൽ ഈ പരിമിതി പ്രതീക സ്ട്രിംഗുകൾ കൂടുതൽ കാര്യക്ഷമമായി നടപ്പിലാക്കാൻ സഹായിക്കുന്നു. അതിനാൽ, ഈ പ്രത്യക്ഷത്തിൽ വ്യക്തമായ പോരായ്മ യഥാർത്ഥത്തിൽ ഒരു നേട്ടമായി മാറുന്നു. അതിനാൽ, നിലവിലുള്ള ഒരു സ്ട്രിംഗിന്റെ ഒരു വ്യതിയാനമായി ഒരു സ്ട്രിംഗ് ആവശ്യമാണെങ്കിൽ, ഈ ആവശ്യത്തിനായി ആവശ്യമായ എല്ലാ മാറ്റങ്ങളും ഉൾക്കൊള്ളുന്ന ഒരു പുതിയ സ്ട്രിംഗ് സൃഷ്ടിക്കണം. ഉപയോഗിക്കാത്ത സ്ട്രിംഗ് ഒബ്‌ജക്റ്റുകൾ സ്വയമേവ മാലിന്യമായി ശേഖരിക്കപ്പെടുന്നതിനാൽ, അനാവശ്യ സ്ട്രിംഗുകളുടെ ഗതിയെക്കുറിച്ച് നിങ്ങൾ വിഷമിക്കേണ്ടതില്ല.

എന്നിരുന്നാലും, സ്ട്രിംഗുകളിലേക്കുള്ള വേരിയബിൾ റഫറൻസുകൾ (അതായത്, ടൈപ്പ് സ്ട്രിംഗിന്റെ ഒബ്ജക്റ്റുകൾ) മാറ്റത്തിന് വിധേയമാണ്, അതിനാൽ അവയ്ക്ക് മറ്റൊരു വസ്തുവിനെ പരാമർശിക്കാൻ കഴിയും. എന്നാൽ സ്ട്രിംഗ് ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിച്ചതിന് ശേഷം അതിന്റെ ഉള്ളടക്കം തന്നെ മാറില്ല.

നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം:

സ്റ്റാറ്റിക് ശൂന്യമായ addNewString() (സ്ട്രിംഗ് s = "ഇത് എന്റെ സ്ട്രോക്ക്"; s = "ഇത് പുതിയ സ്ട്രോക്ക്"; )

നമുക്ക് ആപ്ലിക്കേഷൻ കംപൈൽ ചെയ്ത് ഫലമായുണ്ടാകുന്ന അസംബ്ലി ildasm.exe യൂട്ടിലിറ്റിയിലേക്ക് ലോഡ് ചെയ്യാം. ശൂന്യമായ addNewString() രീതിക്കായി ജനറേറ്റുചെയ്യുന്ന CIL കോഡ് ചിത്രം കാണിക്കുന്നു:

ldstr (സ്ട്രിംഗ് ലോഡ്) ഒപ്‌കോഡിലേക്ക് നിരവധി കോളുകൾ ഉണ്ടെന്നത് ശ്രദ്ധിക്കുക. ഈ CIL ldstr ഒപ്‌കോഡ് ഒരു പുതിയ സ്ട്രിംഗ് ഒബ്‌ജക്റ്റ് നിയന്ത്രിത ഹീപ്പിലേക്ക് ലോഡ് ചെയ്യുന്നു. തൽഫലമായി, "ഇത് എന്റെ സ്ട്രോക്ക്" എന്ന മൂല്യം ഉൾക്കൊള്ളുന്ന മുൻ ഒബ്ജക്റ്റ് ഒടുവിൽ മാലിന്യം ശേഖരിക്കപ്പെടും.

സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു

ക്ലാസിൽ System.Stringപ്രതീക ഡാറ്റയുടെ ദൈർഘ്യം നിർണ്ണയിക്കുന്നതിനും നിലവിലെ സ്‌ട്രിംഗിൽ ഒരു സബ്‌സ്‌ട്രിംഗിനായി തിരയുന്നതിനും പ്രതീകങ്ങളെ വലിയക്ഷരത്തിൽ നിന്ന് ചെറിയക്ഷരത്തിലേക്കും തിരിച്ചും പരിവർത്തനം ചെയ്യുന്നതിനും ഒരു കൂട്ടം രീതികൾ നൽകിയിരിക്കുന്നു. അടുത്തതായി, ഈ ക്ലാസ് കൂടുതൽ വിശദമായി നോക്കാം.

ഫീൽഡ്, ഇൻഡക്സർ, സ്ട്രിംഗ് ക്ലാസ് പ്രോപ്പർട്ടി

സ്ട്രിംഗ് ക്ലാസ് ഒരൊറ്റ ഫീൽഡ് നിർവചിക്കുന്നു:

പൊതു സ്റ്റാറ്റിക് റീഡ് ഒൺലി സ്ട്രിംഗ് ശൂന്യമാണ്;

ശൂന്യമായ ഫീൽഡ് ഒരു ശൂന്യമായ സ്ട്രിംഗിനെ സൂചിപ്പിക്കുന്നു, അതായത്. പ്രതീകങ്ങളൊന്നും അടങ്ങിയിട്ടില്ലാത്ത ഒരു സ്ട്രിംഗ്. ഇത് ഒരു ശൂന്യമായ സ്ട്രിംഗ് റഫറൻസിൽ നിന്ന് വ്യത്യസ്തമാണ്, അത് നിലവിലില്ലാത്ത ഒബ്‌ജക്റ്റിലേക്ക് നിർമ്മിച്ചതാണ്.

കൂടാതെ, സ്ട്രിംഗ് ക്ലാസ് ഒരൊറ്റ വായന-മാത്രം സൂചികയെ നിർവചിക്കുന്നു:

പബ്ലിക് ചാർ ഇത് (നേടുക;)

ഒരു നിർദ്ദിഷ്ട സൂചികയിൽ ഒരു പ്രതീകം ലഭിക്കാൻ ഈ സൂചിക നിങ്ങളെ അനുവദിക്കുന്നു. അറേകൾ പോലെയുള്ള സ്ട്രിംഗുകളുടെ ഇൻഡക്‌സിംഗ് പൂജ്യത്തിൽ നിന്നാണ് ആരംഭിക്കുന്നത്. സ്‌ട്രിംഗ് ഒബ്‌ജക്റ്റുകൾ സ്ഥിരതയുള്ളതും മാറില്ല, അതിനാൽ സ്‌ട്രിംഗ് ക്ലാസ് ഒരു റീഡ്-ഒൺലി ഇൻഡെക്‌സറിനെ പിന്തുണയ്‌ക്കുന്നു എന്നത് അർത്ഥമാക്കുന്നു.

അവസാനമായി, സ്ട്രിംഗ് ക്ലാസ് ഒരൊറ്റ വായന-മാത്രം പ്രോപ്പർട്ടി നിർവചിക്കുന്നു:

പൊതു മുഴുവൻ നീളം (നേടുക;)

ദൈർഘ്യ പ്രോപ്പർട്ടി സ്ട്രിംഗിലെ പ്രതീകങ്ങളുടെ എണ്ണം നൽകുന്നു. ചുവടെയുള്ള ഉദാഹരണം സൂചികയുടെയും ദൈർഘ്യ പ്രോപ്പർട്ടിയുടെയും ഉപയോഗം കാണിക്കുന്നു:

സിസ്റ്റം ഉപയോഗിക്കുന്നു; ക്ലാസ് ഉദാഹരണം ( സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ() ( സ്ട്രിംഗ് str = "ലളിതമായ സ്ട്രിംഗ്"; // ഇൻഡെക്‌സർ കൺസോൾ ഉപയോഗിച്ച് സ്ട്രിംഗിന്റെ നീളവും ലൈനിലെ ആറാമത്തെ പ്രതീകവും നേടുക. WriteLine("സ്ട്രിംഗിന്റെ നീളം (0), 6th പ്രതീകം "(1)"" , str.നീളം, str);) )

സ്ട്രിംഗ് ക്ലാസ് ഓപ്പറേറ്റർമാർ

സ്ട്രിംഗ് ക്ലാസ് ഇനിപ്പറയുന്ന രണ്ട് ഓപ്പറേറ്റർമാരെ ഓവർലോഡ് ചെയ്യുന്നു: == ഒപ്പം !=. തുല്യതയ്ക്കായി രണ്ട് പ്രതീക സ്ട്രിംഗുകൾ പരീക്ഷിക്കാൻ == ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നു. == ഓപ്പറേറ്റർ ഒബ്‌ജക്റ്റ് റഫറൻസുകളിൽ പ്രയോഗിക്കുമ്പോൾ, രണ്ട് റഫറൻസുകളും ഒരേ ഒബ്‌ജക്റ്റിന് ആണോ എന്ന് ഇത് സാധാരണയായി പരിശോധിക്കുന്നു. സ്ട്രിംഗ് തരം ഒബ്ജക്റ്റുകളുടെ റഫറൻസുകളിൽ == ഓപ്പറേറ്റർ പ്രയോഗിക്കുമ്പോൾ, സ്ട്രിംഗുകളുടെ ഉള്ളടക്കങ്ങൾ തന്നെ തുല്യതയ്ക്കായി താരതമ്യം ചെയ്യുന്നു. != ഓപ്പറേറ്ററിനും ഇത് ബാധകമാണ്. സ്ട്രിംഗ് ടൈപ്പിലുള്ള ഒബ്‌ജക്റ്റുകളുടെ റഫറൻസുകളിൽ ഇത് പ്രയോഗിക്കുമ്പോൾ, സ്ട്രിംഗുകളുടെ ഉള്ളടക്കം തന്നെ അസമത്വവുമായി താരതമ്യം ചെയ്യുന്നു. എന്നിരുന്നാലും, = ഉൾപ്പെടെയുള്ള മറ്റ് റിലേഷണൽ ഓപ്പറേറ്റർമാർ, മറ്റ് തരത്തിലുള്ള ഒബ്‌ജക്‌റ്റുകളുമായുള്ള റഫറൻസുകളെ താരതമ്യം ചെയ്യുന്ന അതേ രീതിയിൽ സ്‌ട്രിംഗിന്റെ ഒബ്‌ജക്‌റ്റുകളിലേക്കുള്ള റഫറൻസുകളെ താരതമ്യം ചെയ്യുന്നു. ഒരു സ്ട്രിംഗ് മറ്റൊന്നിനേക്കാൾ വലുതാണോ എന്ന് പരിശോധിക്കുന്നതിന്, നിങ്ങൾ സ്ട്രിംഗ് ക്ലാസിൽ നിർവചിച്ചിരിക്കുന്ന താരതമ്യം() രീതി വിളിക്കണം.

വ്യക്തമാകുന്നതുപോലെ, പല തരത്തിലുള്ള പ്രതീക സ്ട്രിംഗ് താരതമ്യങ്ങൾ സാംസ്കാരിക വിവരങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു. എന്നാൽ ഇത് == കൂടാതെ != ഓപ്പറേറ്റർമാർക്ക് ബാധകമല്ല. എല്ലാത്തിനുമുപരി, അവർ സ്ട്രിംഗുകളിലെ പ്രതീകങ്ങളുടെ ഓർഡിനൽ മൂല്യങ്ങൾ താരതമ്യം ചെയ്യുന്നു. (മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, സാംസ്കാരിക മാനദണ്ഡങ്ങളാൽ പരിഷ്കരിക്കപ്പെടാത്ത പ്രതീകങ്ങളുടെ ബൈനറി മൂല്യങ്ങളെ അവർ താരതമ്യം ചെയ്യുന്നു, അതായത്, പ്രാദേശിക മാനദണ്ഡങ്ങൾ.) അതിനാൽ, ഈ ഓപ്പറേറ്റർമാർ കേസ്-ഇൻസെൻസിറ്റീവ്, സംസ്കാര-ഇൻസെൻസിറ്റീവ് രീതിയിൽ സ്ട്രിംഗ് താരതമ്യം ചെയ്യുന്നു.

സ്ട്രിംഗ് ക്ലാസ് രീതികൾ

ഇനിപ്പറയുന്ന പട്ടിക ഈ ക്ലാസിലെ ഏറ്റവും രസകരമായ ചില രീതികൾ പട്ടികപ്പെടുത്തുന്നു, ഉദ്ദേശ്യമനുസരിച്ച് ഗ്രൂപ്പുചെയ്യുന്നു:

സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള രീതികൾ

രീതി	ഘടനയും ഓവർലോഡുകളും	ഉദ്ദേശ്യം
സ്ട്രിംഗ് താരതമ്യം
താരതമ്യം ()	പബ്ലിക് സ്റ്റാറ്റിക് ഇന്റ് താരതമ്യം (സ്ട്രിംഗ് strA, സ്ട്രിംഗ് strB) പബ്ലിക് സ്റ്റാറ്റിക് ഇന്റ് താരതമ്യം (സ്ട്രിംഗ് സ്ട്രെഎ, സ്ട്രിംഗ് എസ്ആർബി, ബൂൾ ഇഗ്നോർകേസ്) പബ്ലിക് സ്റ്റാറ്റിക് ഇന്റ് കംപെയർ (സ്ട്രിംഗ് strA, സ്ട്രിംഗ് strB, String Comparison comparisonType) പബ്ലിക് സ്റ്റാറ്റിക് ഇന്റർ താരതമ്യം (സ്ട്രിംഗ് സ്ട്രാ, സ്‌ട്രിംഗ് സ്‌ട്രിംഗ് സ്‌ട്രിംഗ്, ബൂൾ ഇഗ്‌നോർകേസ്, കൾച്ചർ ഇൻഫോ കൾച്ചർ)	സ്റ്റാറ്റിക് രീതി സ്ട്രിംഗ് strA-യെ സ്ട്രിംഗ് strB-യുമായി താരതമ്യം ചെയ്യുന്നു. strA, strB-നേക്കാൾ വലുതാണെങ്കിൽ ഒരു പോസിറ്റീവ് മൂല്യം നൽകുന്നു; strA strB-നേക്കാൾ കുറവാണെങ്കിൽ നെഗറ്റീവ്; strA ഉം strB ഉം തുല്യമാണെങ്കിൽ പൂജ്യവും. രജിസ്റ്ററും സംസ്കാരവും അടിസ്ഥാനമാക്കിയാണ് താരതമ്യങ്ങൾ നടത്തുന്നത്. ഇഗ്‌നോർകേസ് ട്രൂ എന്ന് വിലയിരുത്തുകയാണെങ്കിൽ, വലിയക്ഷരങ്ങളും ചെറിയക്ഷരങ്ങളും തമ്മിലുള്ള വ്യത്യാസം താരതമ്യം കണക്കിലെടുക്കില്ല. അല്ലെങ്കിൽ, ഈ വ്യത്യാസങ്ങൾ കണക്കിലെടുക്കുന്നു. comparisonType പാരാമീറ്റർ സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്ന നിർദ്ദിഷ്ട രീതി വ്യക്തമാക്കുന്നു. System.Globalization നെയിംസ്പേസിൽ CultureInfo ക്ലാസ് നിർവചിച്ചിരിക്കുന്നു.
	പബ്ലിക് സ്റ്റാറ്റിക് ഇന്റക്‌സ് താരതമ്യം ചെയ്യുക (സ്ട്രിംഗ് സ്ട്രാറ്റ് എ, ഇന്റ് ഇൻഡക്‌സ്എ, സ്‌ട്രിംഗ് സ്‌ട്രിംഗ് സ്‌ട്രിംഗ് സ്‌ട്രിംഗ്, ഇന്റ് ഇൻഡക്‌സ് ബി, ഇന്റ് ലെങ്ത്) പബ്ലിക് സ്റ്റാറ്റിക് ഇന്റ് താരതമ്യം ചെയ്യുക (സ്ട്രിംഗ് strA, int indexA, string strB, int indexB, int length, boolignignCase) പബ്ലിക് സ്റ്റാറ്റിക് ഇന്റ് കംപെയർ (സ്ട്രിംഗ് strA, int indexA, string strB, int indexB, int length, String Comparison comparisonType) പബ്ലിക് സ്റ്റാറ്റിക് ഇന്റർ താരതമ്യം ചെയ്യുക (സ്ട്രിംഗ് strA, int indexA, string strB, int indexB, int length, boolignignCase, CultureInfo സംസ്കാരം)	സ്ട്രിംഗുകളുടെ ഭാഗങ്ങൾ strA, strB എന്നിവ താരതമ്യം ചെയ്യുന്നു. സ്ട്രിംഗ് ഘടകങ്ങളായ strA, strB എന്നിവയിൽ നിന്നാണ് താരതമ്യം ആരംഭിക്കുന്നത് കൂടാതെ നീളം പരാമീറ്റർ വ്യക്തമാക്കിയ പ്രതീകങ്ങളുടെ എണ്ണം ഉൾപ്പെടുന്നു. സ്ട്രിംഗ് strA യുടെ ഭാഗം string strB യുടെ ഭാഗത്തെക്കാൾ വലുതാണെങ്കിൽ രീതി ഒരു പോസിറ്റീവ് മൂല്യം നൽകുന്നു; സ്ട്രിംഗ് strA യുടെ ഭാഗം string strB യുടെ ഭാഗത്തേക്കാൾ കുറവാണെങ്കിൽ നെഗറ്റീവ് മൂല്യം; strA ഉം strB ഉം താരതമ്യം ചെയ്യുന്ന സ്ട്രിംഗുകളുടെ ഭാഗങ്ങൾ തുല്യമാണെങ്കിൽ പൂജ്യം. രജിസ്റ്ററും സംസ്കാരവും അടിസ്ഥാനമാക്കിയാണ് താരതമ്യങ്ങൾ നടത്തുന്നത്.
ഓർഡിനൽ () താരതമ്യം ചെയ്യുക	പബ്ലിക് സ്റ്റാറ്റിക് ഇൻറ്റ് താരതമ്യം ഓർഡിനൽ (സ്ട്രിംഗ് strA, സ്ട്രിംഗ് strB) പബ്ലിക് സ്റ്റാറ്റിക് ഇന്റർ ഓർഡിനൽ (സ്ട്രിംഗ് strA, int indexA, string strB, int indexB, int കൗണ്ട്)	താരതമ്യപ്പെടുത്തൽ () രീതി പോലെ തന്നെ ചെയ്യുന്നു, എന്നാൽ പ്രാദേശിക ക്രമീകരണങ്ങൾ കണക്കിലെടുക്കാതെ
താരതമ്യം ചെയ്യുക()	പബ്ലിക് ഇൻറ്റ് CompareTo(object value)	മൂല്യമുള്ള ഒബ്‌ജക്‌റ്റിന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യവുമായി കോളിംഗ് സ്‌ട്രിംഗിനെ താരതമ്യം ചെയ്യുന്നു. കോളിംഗ് സ്ട്രിംഗ് മൂല്യത്തേക്കാൾ വലുതാണെങ്കിൽ ഒരു പോസിറ്റീവ് മൂല്യം നൽകുന്നു; കോളിംഗ് സ്ട്രിംഗ് മൂല്യത്തേക്കാൾ കുറവാണെങ്കിൽ നെഗറ്റീവ്; താരതമ്യം ചെയ്ത സ്ട്രിംഗുകൾ തുല്യമാണെങ്കിൽ പൂജ്യവും
	പബ്ലിക് ഇൻറ്റ് CompareTo(string strB)	കോളിംഗ് സ്‌ട്രിംഗിനെ സ്‌ട്രിംഗ് strB-മായി താരതമ്യം ചെയ്യുന്നു
തുല്യം()	പബ്ലിക് ഓവർറൈഡ് ബൂൾ തുല്യത (ഒബ്ജക്റ്റ് ഒബ്‌ജെ)	കോളിംഗ് സ്‌ട്രിംഗിൽ obj-ന്റെ സ്‌ട്രിംഗ് പ്രാതിനിധ്യത്തിന്റെ അതേ ശ്രേണിയിലുള്ള പ്രതീകങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ ബൂളിയൻ true നൽകുന്നു. കേസ്-സെൻസിറ്റീവ് എന്നാൽ സാംസ്കാരികമായി സെൻസിറ്റീവ് ഓർഡിനൽ താരതമ്യം ചെയ്യുന്നു
	പൊതു ബൂൾ തുല്യം (സ്ട്രിംഗ് മൂല്യം) പബ്ലിക് ബൂൾ തുല്യത (സ്ട്രിംഗ് മൂല്യം, സ്ട്രിംഗ് കോമ്പരിസൺ താരതമ്യ തരം)	കോളിംഗ് സ്‌ട്രിംഗിൽ സ്‌ട്രിംഗ് മൂല്യത്തിന്റെ അതേ ശ്രേണിയിലുള്ള പ്രതീകങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ബൂളിയൻ മൂല്യം true നൽകുന്നു. കേസ് സെൻസിറ്റീവ് എന്നാൽ സാംസ്കാരികമായി സെൻസിറ്റീവ് അല്ലാത്ത ഒരു ഓർഡിനൽ താരതമ്യം നടത്തുന്നു. comparisonType പാരാമീറ്റർ സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്ന നിർദ്ദിഷ്ട രീതി വ്യക്തമാക്കുന്നു
	പൊതു സ്റ്റാറ്റിക് ബൂൾ തുല്യം (സ്ട്രിംഗ് എ, സ്ട്രിംഗ് ബി) പബ്ലിക് സ്റ്റാറ്റിക് ബൂൾ തുല്യം (സ്ട്രിംഗ് എ, സ്ട്രിംഗ് ബി, സ്ട്രിംഗ് കോംപാരിസൺ താരതമ്യ തരം)	a സ്ട്രിംഗ് b യുടെ അതേ ശ്രേണിയിലുള്ള പ്രതീകങ്ങൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ ബൂളിയൻ മൂല്യം true നൽകുന്നു. കേസ് സെൻസിറ്റീവ് എന്നാൽ സാംസ്കാരികമായി സെൻസിറ്റീവ് അല്ലാത്ത ഒരു ഓർഡിനൽ താരതമ്യം നടത്തുന്നു. comparisonType പാരാമീറ്റർ സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്ന നിർദ്ദിഷ്ട രീതി വ്യക്തമാക്കുന്നു
സ്ട്രിംഗുകളുടെ സംയോജനം (കണക്ഷൻ).
Concat()	പൊതു സ്റ്റാറ്റിക് സ്ട്രിംഗ് കോൺകാറ്റ് (സ്ട്രിംഗ് str0, സ്ട്രിംഗ് str1); പൊതു സ്റ്റാറ്റിക് സ്ട്രിംഗ് കോൺകാറ്റ് (പാരാംസ് സ്ട്രിംഗ് മൂല്യങ്ങൾ);	വ്യക്തിഗത സ്ട്രിംഗ് സംഭവങ്ങളെ ഒരൊറ്റ സ്ട്രിംഗിലേക്ക് സംയോജിപ്പിക്കുന്നു (കൺകറ്റനേഷൻ)
ഒരു സ്ട്രിംഗിൽ തിരയുക
അടങ്ങിയിരിക്കുന്നു()	പൊതു ബൂൾ അടങ്ങിയിരിക്കുന്നു (സ്ട്രിംഗ് മൂല്യം)	ഒരു സ്‌ട്രിംഗിൽ ഒരു നിശ്ചിത സബ്‌സ്ട്രിംഗ് (മൂല്യം) അടങ്ങിയിട്ടുണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു രീതി
() ഉപയോഗിച്ച് ആരംഭിക്കുന്നു	പൊതു ബൂൾ ആരംഭിക്കുന്നു(സ്ട്രിംഗ് മൂല്യം) പബ്ലിക് ബൂൾ ആരംഭിക്കുന്നു(സ്ട്രിംഗ് മൂല്യം, സ്ട്രിംഗ് കോമ്പരിസൺ താരതമ്യ തരം)	കോളിംഗ് സ്‌ട്രിംഗ് ആരംഭിക്കുന്നത് സബ്‌സ്‌ട്രിംഗ് മൂല്യത്തിൽ ആണെങ്കിൽ ബൂളിയൻ മൂല്യം true നൽകുന്നു. അല്ലെങ്കിൽ, ബൂളിയൻ മൂല്യം തെറ്റ് തിരികെ നൽകും. comparisonType പരാമീറ്റർ സെർച്ച് നടത്താനുള്ള പ്രത്യേക മാർഗം വ്യക്തമാക്കുന്നു
അവസാനം()	പബ്ലിക് ബൂൾ എൻഡ്സ് വിത്ത്(സ്ട്രിംഗ് മൂല്യം) പബ്ലിക് ബൂൾ എൻഡ്സ് വിത്ത് (സ്ട്രിംഗ് മൂല്യം, സ്ട്രിംഗ് കോമ്പരിസൺ താരതമ്യ തരം)	കോളിംഗ് സ്‌ട്രിംഗ് സബ്‌സ്‌ട്രിംഗ് മൂല്യത്തിൽ അവസാനിക്കുകയാണെങ്കിൽ ബൂളിയൻ മൂല്യം true നൽകുന്നു. അല്ലെങ്കിൽ, ബൂളിയൻ മൂല്യം തെറ്റ് നൽകുന്നു. comparisonType പരാമീറ്റർ നിർദ്ദിഷ്ട തിരയൽ രീതി വ്യക്തമാക്കുന്നു
IndexOf()	പബ്ലിക് ഇൻഡെക്സ്ഓഫ് (ചാർ മൂല്യം) പബ്ലിക് ഇൻഡെക്സ്ഓഫ്(സ്ട്രിംഗ് മൂല്യം)	ഒരു സ്‌ട്രിംഗിൽ നൽകിയിരിക്കുന്ന സബ്‌സ്‌ട്രിംഗിന്റെയോ പ്രതീകത്തിന്റെയോ ആദ്യ സംഭവം കണ്ടെത്തുന്നു. തിരഞ്ഞ പ്രതീകമോ സബ്‌സ്‌ട്രിംഗോ കണ്ടെത്തിയില്ലെങ്കിൽ, മൂല്യം -1 തിരികെ നൽകും.
	public int IndexOf(char value, int startIndex) പബ്ലിക് ഇൻറ്റ് ഇൻഡെക്സ്ഓഫ് (സ്ട്രിംഗ് മൂല്യം, ഇൻറ്റ് സ്റ്റാർട്ട് ഇൻഡക്സ്) പബ്ലിക് ഇൻറ്റ് ഇൻഡക്‌സ്ഓഫ് (ചാർ മൂല്യം, ഇൻറ്റ് സ്റ്റാർട്ട് ഇൻഡക്‌സ്, ഇൻറ്റ് കൗണ്ട്) പൊതു int IndexOf(സ്ട്രിംഗ് മൂല്യം, int startIndex, int കൗണ്ട്)	കോളിംഗ് സ്‌ട്രിംഗിലെ പ്രതീകത്തിന്റെ അല്ലെങ്കിൽ സബ്‌സ്‌ട്രിംഗ് മൂല്യത്തിന്റെ ആദ്യ സംഭവത്തിന്റെ സൂചിക നൽകുന്നു. സ്റ്റാർട്ട് ഇൻഡക്‌സ് വ്യക്തമാക്കിയ മൂലകത്തിൽ നിന്നാണ് തിരയൽ ആരംഭിക്കുന്നത്, കൂടാതെ എണ്ണത്തിൽ വ്യക്തമാക്കിയ മൂലകങ്ങളുടെ എണ്ണം (വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ) വ്യാപിക്കുന്നു. തിരഞ്ഞ പ്രതീകമോ സബ്‌സ്ട്രിംഗോ കണ്ടെത്തിയില്ലെങ്കിൽ രീതി -1 നൽകുന്നു
LastIndexOf()	ഓവർലോഡ് ചെയ്ത പതിപ്പുകൾ IndexOf() രീതിക്ക് സമാനമാണ്	IndexOf പോലെ തന്നെ, എന്നാൽ ഒരു പ്രതീകത്തിന്റെയോ സബ്‌സ്‌ട്രിംഗിന്റെയോ അവസാനത്തെ സംഭവം കണ്ടെത്തുന്നു, ആദ്യത്തേതല്ല
IndexOfAny()	പബ്ലിക് ഇൻഡെക്‌സ്ഓഫ്ആനി (ചാർ ഏതെങ്കിലും) പബ്ലിക് ഇന്റക്‌സ് ഇൻഡക്‌സ്ഓഫ്ആനി (ചാർ ഏതെങ്കിലും ഓഫ്, ഇൻറ്റ് സ്റ്റാർട്ട് ഇൻഡക്‌സ്) പബ്ലിക് ഇന്റക്‌സ് ഇൻഡക്‌സ്ഓഫ്ആനി (ചാർ ഏനി ഓഫ്, ഇൻറ്റ് സ്റ്റാർട്ട് ഇൻഡക്‌സ്, ഇൻറ്റ് കൗണ്ട്)	കോളിംഗ് സ്‌ട്രിംഗിൽ കാണുന്ന ഏതെങ്കിലും അറേയിൽ നിന്ന് ഏതെങ്കിലും പ്രതീകത്തിന്റെ ആദ്യ സംഭവത്തിന്റെ സൂചിക നൽകുന്നു. സ്റ്റാർട്ട് ഇൻഡക്‌സ് വ്യക്തമാക്കിയ മൂലകത്തിൽ നിന്ന് തിരയൽ ആരംഭിക്കുന്നു, കൂടാതെ എണ്ണത്തിൽ വ്യക്തമാക്കിയ മൂലകങ്ങളുടെ എണ്ണം (വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ) വ്യാപിക്കുന്നു. ഏതെങ്കിലും അറേയിൽ ഒരു പ്രതീകവും പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ രീതി -1 നൽകുന്നു. ഓർഡിനൽ രീതിയിലാണ് തിരച്ചിൽ നടക്കുന്നത്
ലാസ്റ്റ് ഇൻഡക്സ്ഓഫ്ആനി	ഓവർലോഡ് ചെയ്ത പതിപ്പുകൾ IndexOfAny() രീതിക്ക് സമാനമാണ്	കോളിംഗ് സ്‌ട്രിംഗിൽ കാണുന്ന ഏതെങ്കിലും അറേയിൽ നിന്ന് ഏതെങ്കിലും പ്രതീകത്തിന്റെ അവസാന സംഭവത്തിന്റെ സൂചിക നൽകുന്നു
സ്ട്രിംഗുകൾ പിളർന്ന് ചേരുന്നു
രണ്ടായി പിരിയുക	പൊതു സ്ട്രിംഗ് സ്പ്ലിറ്റ് (പാരാം ചാർ സെപ്പറേറ്റർ) പബ്ലിക് സ്ട്രിംഗ് സ്പ്ലിറ്റ് (പാരാംസ് ചാർ സെപ്പറേറ്റർ, ഇൻറ്റ് കൗണ്ട്)	നിർദ്ദിഷ്‌ട ചാറിൽ നിന്നോ സ്‌ട്രിംഗ് അറേയിൽ നിന്നോ ഉള്ള ഘടകങ്ങൾ ഉപയോഗിച്ച് പരസ്പരം വേർതിരിക്കുന്ന ഈ സന്ദർഭത്തിൽ ഉള്ളിലെ സബ്‌സ്‌ട്രിംഗുകളുള്ള ഒരു സ്‌ട്രിംഗ് അറേ തിരികെ നൽകുന്ന ഒരു രീതി. സ്പ്ലിറ്റ്() രീതിയുടെ ആദ്യ രൂപം കോളിംഗ് സ്ട്രിംഗിനെ അതിന്റെ ഘടക ഭാഗങ്ങളായി വിഭജിക്കുന്നു. കോളിംഗ് സ്‌ട്രിംഗിൽ നിന്ന് ലഭിച്ച സബ്‌സ്‌ട്രിംഗുകൾ അടങ്ങുന്ന ഒരു അറേയാണ് ഫലം. ഈ സബ്‌സ്‌ട്രിംഗുകളെ ഡിലിമിറ്റ് ചെയ്യുന്ന പ്രതീകങ്ങൾ സെപ്പറേറ്റർ അറേയിൽ കൈമാറുന്നു. സെപ്പറേറ്റർ അറേ ശൂന്യമാണെങ്കിൽ അല്ലെങ്കിൽ ശൂന്യമായ സ്‌ട്രിംഗിനെ പരാമർശിക്കുന്നുവെങ്കിൽ, സബ്‌സ്‌ട്രിംഗ് സെപ്പറേറ്ററായി ഒരു സ്‌പെയ്‌സ് ഉപയോഗിക്കുന്നു. ഈ രീതിയുടെ രണ്ടാമത്തെ രൂപത്തിൽ, കൗണ്ട് പാരാമീറ്റർ നിർണ്ണയിക്കുന്ന സബ്‌സ്ട്രിംഗുകളുടെ എണ്ണം നൽകുന്നു.
	പൊതു സ്ട്രിംഗ് സ്പ്ലിറ്റ് (പാരാം ചാർ സെപ്പറേറ്റർ, StringSplitOptions ഓപ്ഷനുകൾ) പൊതു സ്ട്രിംഗ് സ്പ്ലിറ്റ് (സ്ട്രിംഗ് സെപ്പറേറ്റർ, StringSplitOptions ഓപ്ഷനുകൾ) പബ്ലിക് സ്ട്രിംഗ് സ്പ്ലിറ്റ് (പാരാം ചാർ സെപ്പറേറ്റർ, ഇൻറ്റ് കൗണ്ട്, സ്ട്രിംഗ്സ്പ്ലിറ്റ് ഓപ്‌ഷൻസ് ഓപ്ഷനുകൾ) പൊതു സ്ട്രിംഗ് സ്പ്ലിറ്റ് (സ്ട്രിംഗ് സെപ്പറേറ്റർ, ഇന്റ് കൗണ്ട്, StringSplitOptions ഓപ്ഷനുകൾ)	സ്പ്ലിറ്റ്() രീതിയുടെ ആദ്യ രണ്ട് രൂപങ്ങളിൽ, കോളിംഗ് സ്‌ട്രിംഗിനെ ഭാഗങ്ങളായി വിഭജിക്കുകയും കോളിംഗ് സ്‌ട്രിംഗിൽ നിന്ന് ലഭിച്ച സബ്‌സ്‌ട്രിംഗുകൾ അടങ്ങുന്ന ഒരു അറേ തിരികെ നൽകുകയും ചെയ്യുന്നു. ഈ സബ്‌സ്‌ട്രിംഗുകളെ വേർതിരിക്കുന്ന പ്രതീകങ്ങൾ സെപ്പറേറ്റർ അറേയിൽ കൈമാറുന്നു. സെപ്പറേറ്റർ അറേ ശൂന്യമാണെങ്കിൽ, ഒരു സ്പേസ് ഒരു സെപ്പറേറ്ററായി ഉപയോഗിക്കുന്നു. ഈ രീതിയുടെ മൂന്നാമത്തെയും നാലാമത്തെയും രൂപങ്ങളിൽ, എണ്ണം പാരാമീറ്റർ പരിമിതപ്പെടുത്തിയിരിക്കുന്ന വരികളുടെ എണ്ണം നൽകുന്നു. എന്നാൽ എല്ലാ രൂപങ്ങളിലും, രണ്ട് ഡിലിമിറ്ററുകൾ തൊട്ടടുത്തായിരിക്കുമ്പോൾ ഉണ്ടാകുന്ന ശൂന്യമായ ലൈനുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു പ്രത്യേക മാർഗം ഓപ്ഷനുകൾ പരാമീറ്റർ വ്യക്തമാക്കുന്നു. StringSplitOptions എണ്ണൽ രണ്ട് മൂല്യങ്ങൾ മാത്രം നിർവചിക്കുന്നു: ഒന്നുമില്ലഒപ്പം EmptyEntries നീക്കം ചെയ്യുക. ഓപ്‌ഷനുകൾ ഒന്നുമല്ലെങ്കിൽ, യഥാർത്ഥ സ്‌ട്രിംഗിന്റെ അന്തിമ വിഭജന ഫലത്തിൽ ശൂന്യമായ സ്‌ട്രിംഗുകൾ ഉൾപ്പെടുത്തും. കൂടാതെ, ഓപ്‌ഷൻ പാരാമീറ്റർ RemoveEmptyEntries-ലേക്ക് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, യഥാർത്ഥ സ്ട്രിംഗ് വിഭജിക്കുന്നതിന്റെ അന്തിമ ഫലത്തിൽ നിന്ന് ശൂന്യമായ വരികൾ ഒഴിവാക്കപ്പെടും.
ചേരുക()	പൊതു സ്റ്റാറ്റിക് സ്ട്രിംഗ് ജോയിൻ (സ്ട്രിംഗ് സെപ്പറേറ്റർ, സ്ട്രിംഗ് മൂല്യം) പബ്ലിക് സ്റ്റാറ്റിക് സ്ട്രിംഗ് ജോയിൻ (സ്ട്രിംഗ് സെപ്പറേറ്റർ, സ്ട്രിംഗ് മൂല്യം, int startIndex, int കൗണ്ട്)	സ്ട്രിംഗുകളുടെ ഒരു നിരയിലെ ഉള്ളടക്കങ്ങൾ സംയോജിപ്പിച്ച് ഒരു പുതിയ സ്ട്രിംഗ് നിർമ്മിക്കുന്നു. Join() രീതിയുടെ ആദ്യ രൂപം മൂല്യ ശ്രേണിയിൽ പാസ്സാക്കിയ സംയോജിത സബ്‌സ്‌ട്രിംഗുകൾ അടങ്ങുന്ന ഒരു സ്‌ട്രിംഗ് നൽകുന്നു. രണ്ടാമത്തെ ഫോം മൂല്യ ശ്രേണിയിൽ പാസാക്കിയ സബ്‌സ്‌ട്രിംഗുകൾ അടങ്ങുന്ന ഒരു സ്‌ട്രിംഗും നൽകുന്നു, പക്ഷേ അവ മൂല്യ അറേ ഘടകത്തിൽ നിന്ന് ആരംഭിക്കുന്ന ഒരു നിശ്ചിത സംഖ്യയുടെ എണ്ണത്തിൽ സംയോജിപ്പിച്ചിരിക്കുന്നു. രണ്ട് ഫോമുകളിലും, ഓരോ തുടർന്നുള്ള വരിയും മുമ്പത്തെ വരിയിൽ നിന്ന് സെപ്പറേറ്റർ പാരാമീറ്റർ വ്യക്തമാക്കിയ ഒരു സെപ്പറേറ്റർ ലൈൻ ഉപയോഗിച്ച് വേർതിരിക്കുന്നു.
വരികൾ പൂരിപ്പിക്കുകയും ട്രിം ചെയ്യുകയും ചെയ്യുന്നു
ട്രിം()	പൊതു സ്ട്രിംഗ് ട്രിം() പബ്ലിക് സ്ട്രിംഗ് ട്രിം (പാരാംസ് ചാർ ട്രിംചറുകൾ)	നിലവിലെ വരിയുടെ തുടക്കത്തിലും അവസാനത്തിലും നിന്ന് ഒരു നിർദ്ദിഷ്ട പ്രതീകങ്ങളുടെ എല്ലാ സംഭവങ്ങളും നീക്കം ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു രീതി. ട്രിം() രീതിയുടെ ആദ്യ രൂപം കോളിംഗ് സ്‌ട്രിംഗിൽ നിന്ന് ലീഡിംഗ്, ട്രെയിലിംഗ് സ്‌പെയ്‌സുകൾ നീക്കം ചെയ്യുന്നു. ഈ രീതിയുടെ രണ്ടാമത്തെ ഫോം ട്രിംചാർസ് അറേയിൽ നിന്ന് കോളിംഗ് ക്യാരക്ടർ സ്‌ട്രിംഗിന്റെ ലീഡിംഗും പിന്നിലുള്ള സംഭവങ്ങളും നീക്കംചെയ്യുന്നു. രണ്ട് ഫോമുകളും ഫലമായുണ്ടാകുന്ന സ്ട്രിംഗ് തിരികെ നൽകുന്നു.
PadLeft()	പൊതു സ്ട്രിംഗ് PadLeft (int total Width) പൊതു സ്ട്രിംഗ് PadLeft (int totalWidth, char paddingChar)	ഇടതുവശത്ത് പ്രതീകങ്ങളുള്ള ഒരു സ്ട്രിംഗ് പാഡ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. PadLeft() രീതിയുടെ ആദ്യ രൂപം കോളിംഗ് സ്‌ട്രിംഗിന്റെ ഇടതുവശത്തുള്ള സ്‌പെയ്‌സുകൾ അവതരിപ്പിക്കുന്നു, അങ്ങനെ അതിന്റെ മൊത്തം നീളം totalWidth പാരാമീറ്ററിന്റെ മൂല്യത്തിന് തുല്യമാകും. ഈ രീതിയുടെ രണ്ടാമത്തെ രൂപത്തിൽ, കോളിംഗ് സ്ട്രിംഗിന്റെ ഇടതുവശത്ത് paddingChar പാരാമീറ്റർ സൂചിപ്പിക്കുന്ന പ്രതീകങ്ങൾ നൽകിയതിനാൽ അതിന്റെ മൊത്തം നീളം totalWidth പാരാമീറ്ററിന്റെ മൂല്യത്തിന് തുല്യമാകും. രണ്ട് ഫോമുകളും ഫലമായുണ്ടാകുന്ന സ്ട്രിംഗ് തിരികെ നൽകുന്നു. ടോട്ടൽ വിഡ്ത്ത് പാരാമീറ്ററിന്റെ മൂല്യം കോളിംഗ് സ്‌ട്രിംഗിന്റെ ദൈർഘ്യത്തേക്കാൾ കുറവാണെങ്കിൽ, മാറ്റമില്ലാത്ത കോളിംഗ് സ്‌ട്രിംഗിന്റെ ഒരു പകർപ്പ് തിരികെ നൽകും.
പാഡ് റൈറ്റ്()	PadLeft() പോലെ തന്നെ	വലതുവശത്ത് പ്രതീകങ്ങളുള്ള ഒരു സ്ട്രിംഗ് കൂട്ടിച്ചേർക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
വരികൾ ചേർക്കുന്നു, ഇല്ലാതാക്കുന്നു, മാറ്റിസ്ഥാപിക്കുന്നു
തിരുകുക()	പബ്ലിക് സ്ട്രിംഗ് ഇൻസേർട്ട് (ഇന്റ് സ്റ്റാർട്ട് ഇൻഡക്സ്, സ്ട്രിംഗ് മൂല്യം)	ഒരു വരി മറ്റൊന്നിലേക്ക് തിരുകാൻ ഉപയോഗിക്കുന്നു, ഇവിടെ മൂല്യം എന്നത് ആരംഭ സൂചികയിലെ കോളിംഗ് വരിയിലേക്ക് തിരുകേണ്ട വരിയെ സൂചിപ്പിക്കുന്നു. തത്ഫലമായുണ്ടാകുന്ന സ്ട്രിംഗ് രീതി തിരികെ നൽകുന്നു.
നീക്കം ചെയ്യുക()	പൊതു സ്ട്രിംഗ് നീക്കം ചെയ്യുക (ഇന്റ് സ്റ്റാർട്ട് ഇൻഡക്സ്) പബ്ലിക് സ്‌ട്രിംഗ് നീക്കം ചെയ്യുക(int startIndex, int count)	ഒരു സ്ട്രിംഗിന്റെ ഭാഗം നീക്കം ചെയ്യാൻ ഉപയോഗിക്കുന്നു. Remove() രീതിയുടെ ആദ്യ രൂപത്തിൽ, startIndex സൂചിപ്പിക്കുന്ന സ്ഥലത്ത് നീക്കംചെയ്യൽ ആരംഭിക്കുകയും വരിയുടെ അവസാനം വരെ തുടരുകയും ചെയ്യുന്നു. ഈ രീതിയുടെ രണ്ടാമത്തെ രൂപത്തിൽ, സ്റ്റാർട്ട്ഇൻഡക്സ് സൂചിക സൂചിപ്പിക്കുന്ന സ്ഥലത്ത് നിന്ന് ആരംഭിച്ച്, കൗണ്ട് പാരാമീറ്റർ നിർണ്ണയിക്കുന്ന പ്രതീകങ്ങളുടെ എണ്ണം സ്ട്രിംഗിൽ നിന്ന് നീക്കംചെയ്യുന്നു.
മാറ്റിസ്ഥാപിക്കുക()	പൊതു സ്ട്രിംഗ് മാറ്റിസ്ഥാപിക്കുക (char oldChar, char newChar) പൊതു സ്ട്രിംഗ് മാറ്റിസ്ഥാപിക്കുക (സ്ട്രിംഗ് പഴയ മൂല്യം, സ്ട്രിംഗ് പുതിയ മൂല്യം)	ഒരു സ്ട്രിംഗിന്റെ ഭാഗം മാറ്റിസ്ഥാപിക്കാൻ ഉപയോഗിക്കുന്നു. Replace() രീതിയുടെ ആദ്യ രൂപത്തിൽ, കോളിംഗ് സ്‌ട്രിംഗിലെ oldChar എന്ന പ്രതീകത്തിന്റെ എല്ലാ സംഭവങ്ങളും newChar എന്ന പ്രതീകം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. ഈ രീതിയുടെ രണ്ടാമത്തെ രൂപത്തിൽ, കോളിംഗ് ലൈനിലെ പഴയ മൂല്യത്തിന്റെ എല്ലാ സംഭവങ്ങളും പുതിയ മൂല്യം എന്ന സ്ട്രിംഗ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു.
കേസ് മാറ്റുക
Toupper()	പൊതു സ്ട്രിംഗ് Toupper()	കോളിംഗ് സ്‌ട്രിംഗിലെ എല്ലാ അക്ഷരങ്ങളും വലിയക്ഷരമാക്കുന്നു.
ടോലോവർ()	പൊതു സ്ട്രിംഗ് ToLower()	കോളിംഗ് സ്ട്രിംഗിലെ എല്ലാ അക്ഷരങ്ങളും ചെറിയക്ഷരമാക്കുക.
ഒരു സ്ട്രിംഗിൽ നിന്ന് ഒരു സബ്‌സ്ട്രിംഗ് ലഭിക്കുന്നു
സബ്‌സ്ട്രിംഗ്()	പൊതു സ്ട്രിംഗ് സബ്‌സ്ട്രിംഗ് (ഇന്റ് സ്റ്റാർട്ട് ഇൻഡക്സ്) പബ്ലിക് സ്ട്രിംഗ് സബ്‌സ്ട്രിംഗ് (ഇന്റ് സ്റ്റാർട്ട് ഇൻഡക്‌സ്, ഇന്റ് ലെങ്ത്)	സബ്‌സ്ട്രിംഗ്() രീതിയുടെ ആദ്യ രൂപത്തിൽ, സ്റ്റാർട്ട്‌ഇൻഡക്സ് പാരാമീറ്റർ സൂചിപ്പിക്കുന്ന സ്ഥലത്ത് നിന്ന് ആരംഭിച്ച് കോളിംഗ് സ്ട്രിംഗിന്റെ അവസാനം വരെ സബ്‌സ്ട്രിംഗ് വീണ്ടെടുക്കുന്നു. ഈ രീതിയുടെ രണ്ടാമത്തെ രൂപത്തിൽ, സ്റ്റാർട്ട്ഇൻഡക്സ് പാരാമീറ്റർ സൂചിപ്പിക്കുന്ന സ്ഥലത്ത് നിന്ന് ആരംഭിച്ച് നീളം പാരാമീറ്റർ നിർണ്ണയിക്കുന്ന പ്രതീകങ്ങളുടെ എണ്ണം അടങ്ങുന്ന ഒരു സബ്‌സ്ട്രിംഗ് വേർതിരിച്ചെടുക്കുന്നു.

താഴെപ്പറയുന്ന ഉദാഹരണ പ്രോഗ്രാം മുകളിൽ പറഞ്ഞ പല രീതികളും ഉപയോഗിക്കുന്നു:

സിസ്റ്റം ഉപയോഗിക്കുന്നു; System.Collections.Generic ഉപയോഗിക്കുന്നത്; System.Linq ഉപയോഗിക്കുന്നു; System.Text ഉപയോഗിക്കുന്നത്; namespace ConsoleApplication1 ( ക്ലാസ് പ്രോഗ്രാം ( സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ (സ്ട്രിംഗ് ആർഗുകൾ) ( // ആദ്യത്തെ രണ്ട് വരികൾ താരതമ്യം ചെയ്യുക s1 = "ഇതൊരു സ്ട്രിംഗ്"; സ്ട്രിംഗ് s2 = "ഇത് ടെക്‌സ്‌റ്റാണ്, ഇതൊരു സ്ട്രിംഗ് ആണ്"; എങ്കിൽ (സ്ട്രിംഗ്. Ordinal(s1, s2) താരതമ്യം ചെയ്യുക ("എന്നിരുന്നാലും, അവയിൽ ഒരേ വാചകം അടങ്ങിയിരിക്കുന്നു"); // സ്ട്രിംഗുകളുടെ സംയോജനം Console.WriteLine(String.Concat("\n" + "One, two ","three, four")); // ഒരു സ്ട്രിംഗിൽ തിരയുക / / എങ്കിൽ (s2. IndexOf("this") != -1) Console.WriteLine("ഇത് \" എന്ന വാക്ക് വരിയിൽ കാണപ്പെടുന്നു, അത് "+ "ഇതാണ്: (0) സ്ഥാനത്ത്" , s2.IndexOf("ഇത്")); / / സബ്‌സ്‌ട്രിംഗിന്റെ അവസാന ആവിർഭാവം എങ്കിൽ (s2.LastIndexOf("ഇത്") " + "(0) സ്ഥാനത്ത്", s2.LastIndexOf("ഇത്" )); // പ്രതീകങ്ങളുടെ ഒരു നിരയിൽ നിന്ന് തിരയുക char myCh = ("ы","x","t"); എങ്കിൽ (s2.IndexOfAny (myCh) != -1) Console.WriteLine("അറേ ch "+ "നിലവിലെ വരിയിൽ (0)", s2.IndexOfAny(myCh) എന്ന അറേയിൽ നിന്നുള്ള പ്രതീകങ്ങളിൽ ഒന്ന് കണ്ടെത്തി", s2.IndexOfAny(myCh)); // (s2.StartsWith("ഇത് വാചകമാണ്") == true) Console.WriteLine("സബ്‌സ്ട്രിംഗ് കണ്ടെത്തി!") നൽകിയിട്ടുള്ള സബ്‌സ്‌ട്രിംഗിൽ ആണോ ലൈൻ ആരംഭിക്കുന്നത് എന്ന് നിർണ്ണയിക്കുക; // ഉപയോക്താവിന്റെ OS സ്ട്രിംഗ് myOS = Environment.OSVersion.ToString(); എങ്കിൽ (myOS.Contains("NT 5.1")) Console.WriteLine("നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം Windows XP ആണ്"); അല്ലെങ്കിൽ (myOS.Contains("NT 6.1")) Console.WriteLine("നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം Windows 7 ആണ്"); Console.ReadLine(); )))

C# ലെ സ്ട്രിംഗ് താരതമ്യത്തെക്കുറിച്ച് അൽപ്പം

ഒരുപക്ഷേ എല്ലാ പ്രതീക സ്ട്രിംഗ് പ്രവർത്തനങ്ങളിലും ഏറ്റവും സാധാരണമായത് ഒരു സ്ട്രിംഗിനെ മറ്റൊന്നുമായി താരതമ്യം ചെയ്യുക എന്നതാണ്. ഏതെങ്കിലും സ്ട്രിംഗ് താരതമ്യ രീതികൾ നോക്കുന്നതിന് മുമ്പ്, ഇനിപ്പറയുന്നവ ഊന്നിപ്പറയുന്നത് മൂല്യവത്താണ്: സ്ട്രിംഗ് താരതമ്യങ്ങൾ .NET ഫ്രെയിംവർക്കിൽ രണ്ട് പ്രധാന വഴികളിൽ ചെയ്യാം:

ആദ്യം, താരതമ്യം ഒരു പ്രത്യേക സാംസ്കാരിക പരിതസ്ഥിതിയുടെ ആചാരങ്ങളെയും മാനദണ്ഡങ്ങളെയും പ്രതിഫലിപ്പിച്ചേക്കാം, അവ പ്രോഗ്രാം നടപ്പിലാക്കുമ്പോൾ പലപ്പോഴും സാംസ്കാരിക ക്രമീകരണങ്ങളാണ്. ഇത് ചിലർക്ക് സാധാരണ സ്വഭാവമാണ്, എന്നാൽ എല്ലാ താരതമ്യ രീതികളും അല്ല.

രണ്ടാമതായി, സാംസ്കാരിക ക്രമീകരണങ്ങൾ കണക്കിലെടുക്കാതെ, സ്ട്രിംഗ് നിർമ്മിക്കുന്ന പ്രതീകങ്ങളുടെ ഓർഡിനൽ മൂല്യങ്ങൾ ഉപയോഗിച്ച് മാത്രമേ താരതമ്യം ചെയ്യാൻ കഴിയൂ. പൊതുവായി പറഞ്ഞാൽ, സ്ട്രിംഗുകളുടെ സാംസ്കാരികമല്ലാത്ത താരതമ്യങ്ങൾ ഒരു സ്ട്രിംഗിനെക്കാൾ വലുതാണോ കുറവാണോ അല്ലെങ്കിൽ തുല്യമാണോ എന്ന് നിർണ്ണയിക്കാൻ നിഘണ്ടു ക്രമം (ഭാഷാപരമായ സവിശേഷതകൾ) ഉപയോഗിക്കുന്നു. ഓർഡിനൽ താരതമ്യത്തിൽ, ഓരോ പ്രതീകത്തിന്റെയും പരിഷ്‌ക്കരിക്കാത്ത മൂല്യത്തെ അടിസ്ഥാനമാക്കി സ്ട്രിംഗുകൾ ക്രമീകരിച്ചിരിക്കുന്നു.

കൾച്ചറൽ സ്ട്രിംഗ് താരതമ്യങ്ങളും ഓർഡിനൽ താരതമ്യങ്ങളും വ്യത്യസ്തമാകുന്ന രീതിയിലുള്ള വ്യത്യാസങ്ങളും അത്തരം ഓരോ താരതമ്യത്തിന്റെയും അനന്തരഫലങ്ങളും കാരണം, നിലവിൽ Microsoft വാഗ്ദാനം ചെയ്യുന്ന മികച്ച രീതികൾ പിന്തുടരാൻ ഞങ്ങൾ ശക്തമായി ശുപാർശ ചെയ്യുന്നു. എല്ലാത്തിനുമുപരി, സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നതിനുള്ള തെറ്റായ രീതി തിരഞ്ഞെടുക്കുന്നത്, അത് വികസിപ്പിച്ചതിൽ നിന്ന് വ്യത്യസ്തമായ ഒരു പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കുമ്പോൾ പ്രോഗ്രാമിന്റെ തെറ്റായ പ്രവർത്തനത്തിലേക്ക് നയിച്ചേക്കാം.

പ്രതീക സ്ട്രിംഗുകൾ എങ്ങനെ താരതമ്യം ചെയ്യണമെന്ന് തിരഞ്ഞെടുക്കുന്നത് വളരെ പ്രധാനപ്പെട്ട തീരുമാനമാണ്. ഒരു പൊതുനിയമം എന്ന നിലയിൽ, ഒഴിവാക്കലില്ലാതെ, ഉപയോക്താവിന് ഫലം പ്രദർശിപ്പിക്കുന്നതിനുവേണ്ടിയാണ് ഇത് ചെയ്യുന്നതെങ്കിൽ, സാംസ്കാരികമായി സെൻസിറ്റീവ് രീതിയിൽ സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യാൻ നിങ്ങൾ തിരഞ്ഞെടുക്കണം (ഉദാഹരണത്തിന്, ലെക്സിക്കോഗ്രാഫിക്കൽ ക്രമത്തിൽ അടുക്കിയിരിക്കുന്ന സ്ട്രിംഗുകളുടെ ഒരു ശ്രേണി പ്രദർശിപ്പിക്കുന്നതിന്). എന്നാൽ ഫയലിന്റെ പേര്, കീവേഡ്, വെബ്‌സൈറ്റ് വിലാസം അല്ലെങ്കിൽ സുരക്ഷാ മൂല്യം പോലുള്ള സാംസ്കാരിക വ്യത്യാസങ്ങൾക്കായി പരിഷ്‌ക്കരിക്കാൻ ഉദ്ദേശിക്കാത്ത സ്ഥിരമായ വിവരങ്ങൾ സ്ട്രിംഗുകളിൽ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ ഓർഡിനൽ സ്ട്രിംഗ് താരതമ്യം തിരഞ്ഞെടുക്കണം. തീർച്ചയായും, വികസിപ്പിച്ചെടുക്കുന്ന പ്രത്യേക ആപ്ലിക്കേഷന്റെ സ്വഭാവസവിശേഷതകൾ പ്രതീക സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നതിനുള്ള ഉചിതമായ രീതി തിരഞ്ഞെടുക്കാൻ നിർദ്ദേശിക്കും.

സ്ട്രിംഗ് ക്ലാസ് വിവിധ സ്ട്രിംഗ് താരതമ്യ രീതികൾ നൽകുന്നു, അവ മുകളിലെ പട്ടികയിൽ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു. അവയിൽ ഏറ്റവും സാർവത്രികമായത് താരതമ്യം () രീതിയാണ്. ടൈപ്പ് പാരാമീറ്റർ വ്യക്തമാക്കിയ രീതിയിൽ രണ്ട് സ്ട്രിംഗുകളെ പൂർണ്ണമായോ ഭാഗികമായോ, കേസ്-സെൻസിറ്റീവ് അല്ലെങ്കിൽ കേസ്-സെൻസിറ്റീവ് താരതമ്യം ചെയ്യാൻ ഇത് അനുവദിക്കുന്നു. സ്ട്രിംഗ് താരതമ്യം, അതുപോലെ തരം പരാമീറ്റർ നൽകുന്ന സാംസ്കാരിക വിവരങ്ങൾ സംസ്കാര വിവരം.

Compare() രീതിയുടെ ആ ഓവർലോഡുകൾ, StringComparison എന്ന തരത്തിന്റെ ഒരു പരാമീറ്റർ ഉൾപ്പെടാത്ത, പ്രതീക സ്ട്രിംഗുകളുടെ ഒരു കേസും സംസ്കാരവും സെൻസിറ്റീവ് താരതമ്യവും നടത്തുന്നു. CultureInfo ടൈപ്പ് പാരാമീറ്റർ അടങ്ങാത്ത ഓവർലോഡ് ചെയ്ത വേരിയന്റുകളിൽ, സാംസ്കാരിക പരിതസ്ഥിതിയെക്കുറിച്ചുള്ള വിവരങ്ങൾ നിർണ്ണയിക്കുന്നത് നിലവിലെ റൺടൈം പരിതസ്ഥിതിയാണ്.

താഴെയുള്ള പട്ടികയിൽ കാണിച്ചിരിക്കുന്ന മൂല്യങ്ങളെ നിർവചിക്കുന്ന ഒരു എണ്ണമാണ് StringComparison തരം. ഈ മൂല്യങ്ങൾ ഉപയോഗിച്ച്, നിങ്ങളുടെ നിർദ്ദിഷ്ട ആപ്ലിക്കേഷന്റെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ സ്ട്രിംഗ് താരതമ്യങ്ങൾ നിങ്ങൾക്ക് സൃഷ്ടിക്കാൻ കഴിയും. ആയതിനാൽ, StringComparison എന്ന തരത്തിന്റെ ഒരു പരാമീറ്റർ ചേർക്കുന്നത്, Compare() രീതിയുടെയും Equals() പോലുള്ള മറ്റ് താരതമ്യ രീതികളുടെയും കഴിവുകൾ വർദ്ധിപ്പിക്കുന്നു. സ്ട്രിംഗുകൾ എങ്ങനെ താരതമ്യം ചെയ്യാൻ ഉദ്ദേശിക്കുന്നുവെന്ന് അവ്യക്തമായി സൂചിപ്പിക്കാനും ഇത് സാധ്യമാക്കുന്നു.

സാംസ്കാരികമായി സെൻസിറ്റീവ് സ്ട്രിംഗ് താരതമ്യങ്ങളും ഓർഡിനൽ താരതമ്യങ്ങളും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ കാരണം, ഇക്കാര്യത്തിൽ കഴിയുന്നത്ര കൃത്യത പുലർത്തേണ്ടത് പ്രധാനമാണ്.

String Comparison എണ്ണത്തിൽ നിർവചിച്ചിരിക്കുന്ന മൂല്യങ്ങൾ

അർത്ഥം	വിവരണം
നിലവിലെ സംസ്കാരം	നിലവിലെ സാംസ്കാരിക പരിസ്ഥിതി ക്രമീകരണങ്ങൾ ഉപയോഗിച്ചാണ് സ്ട്രിംഗ് താരതമ്യങ്ങൾ നടത്തുന്നത്
CurrentCultureIgnoreCase	നിലവിലെ സംസ്‌കാര ക്രമീകരണങ്ങൾ ഉപയോഗിച്ചാണ് സ്‌ട്രിംഗ് താരതമ്യങ്ങൾ നടത്തുന്നത്, പക്ഷേ അവ കേസ് സെൻസിറ്റീവ് അല്ല
മാറ്റമില്ലാത്ത സംസ്കാരം	മാറ്റമില്ലാത്തവ ഉപയോഗിച്ചാണ് സ്ട്രിംഗ് താരതമ്യങ്ങൾ നടത്തുന്നത്, അതായത്. സാംസ്കാരിക പരിസ്ഥിതിയെക്കുറിച്ചുള്ള സാർവത്രിക ഡാറ്റ
മാറ്റമില്ലാത്ത സംസ്കാരം അവഗണിക്കുക	മാറ്റമില്ലാത്തവ ഉപയോഗിച്ചാണ് സ്ട്രിംഗ് താരതമ്യങ്ങൾ നടത്തുന്നത്, അതായത്. സാർവത്രിക സാംസ്കാരിക ഡാറ്റയും കേസ്-ഇൻസെൻസിറ്റീവും
ഓർഡിനൽ	സ്ട്രിംഗിലെ പ്രതീകങ്ങളുടെ ഓർഡിനൽ മൂല്യങ്ങൾ ഉപയോഗിച്ചാണ് സ്ട്രിംഗ് താരതമ്യങ്ങൾ നടത്തുന്നത്. ഈ സാഹചര്യത്തിൽ, ലെക്സിക്കോഗ്രാഫിക് ക്രമം തടസ്സപ്പെട്ടേക്കാം, ഒരു പ്രത്യേക സാംസ്കാരിക അന്തരീക്ഷത്തിൽ സ്വീകരിച്ച കൺവെൻഷനുകൾ അവഗണിക്കപ്പെടും.
ഓർഡിനൽ ഇഗ്നോർകേസ്	സ്ട്രിംഗിലെ പ്രതീകങ്ങളുടെ ഓർഡിനൽ മൂല്യങ്ങൾ ഉപയോഗിച്ചാണ് സ്ട്രിംഗ് താരതമ്യങ്ങൾ നടത്തുന്നത്, പക്ഷേ അവ കേസ് സെൻസിറ്റീവ് അല്ല

ഏത് സാഹചര്യത്തിലും, താരതമ്യം ചെയ്ത ആദ്യ സ്ട്രിംഗ് രണ്ടാമത്തേതിനേക്കാൾ കുറവാണെങ്കിൽ Compare() രീതി നെഗറ്റീവ് മൂല്യം നൽകുന്നു; താരതമ്യം ചെയ്ത ആദ്യ സ്ട്രിംഗ് രണ്ടാമത്തേതിനേക്കാൾ വലുതാണെങ്കിൽ പോസിറ്റീവ്; അവസാനമായി, താരതമ്യം ചെയ്യുമ്പോൾ രണ്ട് സ്ട്രിംഗുകളും തുല്യമാണെങ്കിൽ പൂജ്യം. താരതമ്യം ചെയ്യുന്ന സ്ട്രിംഗുകൾ തുല്യമാണെങ്കിൽ Compare() രീതി പൂജ്യം നൽകുന്നുവെങ്കിലും, പ്രതീക സ്ട്രിംഗുകൾ തുല്യമാണോ എന്ന് നിർണ്ണയിക്കാൻ Equals() രീതി അല്ലെങ്കിൽ == ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നതാണ് നല്ലത്.

താരതമ്യം ചെയ്‌ത സ്ട്രിംഗുകളുടെ ക്രമം അനുസരിച്ച് അവയുടെ തുല്യത താരതമ്യം ചെയ്യുന്നത് () രീതിയാണ് എന്നതാണ് വസ്തുത. അതിനാൽ, ചരടുകൾക്കിടയിൽ ഒരു സാംസ്കാരിക താരതമ്യം നടത്തുകയാണെങ്കിൽ, രണ്ട് സ്ട്രിംഗുകളും അവയുടെ ക്രമത്തിൽ ഒരുപോലെയായിരിക്കാം, എന്നാൽ പദാർത്ഥത്തിൽ തുല്യമല്ല. സ്ഥിരസ്ഥിതിയായി, പ്രതീകങ്ങളുടെ ഓർഡിനൽ മൂല്യങ്ങളെ അടിസ്ഥാനമാക്കിയും സാംസ്കാരിക അന്തരീക്ഷം കണക്കിലെടുക്കാതെയും തുല്യത () രീതിയിലാണ് സ്ട്രിംഗ് സമത്വം നിർണ്ണയിക്കുന്നത്. അതിനാൽ, ഡിഫോൾട്ടായി, രണ്ട് സ്ട്രിംഗുകളും ഈ രീതിയിൽ സമ്പൂർണ്ണ, പ്രതീകം അനുസരിച്ച് തുല്യതയ്ക്കായി താരതമ്യം ചെയ്യുന്നു, ഇത് == ഓപ്പറേറ്ററിൽ എങ്ങനെ ചെയ്യുന്നു എന്നതിന് സമാനമാണ്.

Compare() രീതിയുടെ മികച്ച വൈദഗ്ധ്യം ഉണ്ടായിരുന്നിട്ടും, പ്രതീക സ്ട്രിംഗുകളുടെ ലളിതമായ ഓർഡിനൽ താരതമ്യത്തിനായി CompareOrdinal() രീതി ഉപയോഗിക്കുന്നത് എളുപ്പമാണ്. അവസാനമായി, CompareTo() രീതി സാംസ്കാരികമായി സെൻസിറ്റീവ് സ്ട്രിംഗ് താരതമ്യങ്ങൾ മാത്രമേ നടത്തൂ എന്ന് ഓർമ്മിക്കുക.

ക്യാരക്ടർ സ്‌ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നതിനായി Compare(), Equals(), CompareOrdinal() രീതികൾ, ==, != ഓപ്പറേറ്റർമാർ എന്നിവയുടെ ഉപയോഗം ഇനിപ്പറയുന്ന പ്രോഗ്രാം കാണിക്കുന്നു. ആദ്യത്തെ രണ്ട് താരതമ്യ ഉദാഹരണങ്ങൾ ഇംഗ്ലീഷ് സംസാരിക്കുന്ന പരിതസ്ഥിതിയിൽ സാംസ്കാരികമായി സെൻസിറ്റീവ് സ്ട്രിംഗ് താരതമ്യങ്ങളും ഓർഡിനൽ താരതമ്യങ്ങളും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ വ്യക്തമായി കാണിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക:

സിസ്റ്റം ഉപയോഗിക്കുന്നു; ക്ലാസ് ഉദാഹരണം ( സ്റ്റാറ്റിക് ശൂന്യമായ Main() ( string str1 = "alpha"; string str2 = "Alpha"; string str3 = "Beta"; string str4 = "alpha"; string str5 = "alpha, beta"; int result; / / ആദ്യം, സംസ്‌കാര-സെൻസിറ്റീവ് സ്ട്രിംഗ് താരതമ്യവും // ഓർഡിനൽ താരതമ്യ ഫലം = String.Compare(str1, str2, StringComparison.CurrentCulture); Console.Write("സാംസ്‌കാരികമായി സെൻസിറ്റീവ് സ്ട്രിംഗ് താരതമ്യം: "); എങ്കിൽ (ഫലം 0 ) Console.WriteLine(str1 + "" + str2 നേക്കാൾ വലുത്); മറ്റുള്ളവ Console.WriteLine(str1 + "തുല്യം " + str2); ഫലം = String.Compare(str1, str2, StringComparison.Ordinal); Console.Write(" ഓർഡിനൽ താരതമ്യ വരികൾ: "); എങ്കിൽ (ഫലം 0) Console.WriteLine (str1 + "" + str2 നേക്കാൾ വലുത്); മറ്റുള്ളവ Console.WriteLine(str1 + " തുല്യമായ " + str4); // CompareOrdinal() രീതി ഫലം ഉപയോഗിക്കുക = String.CompareOrdinal(str1, str2); Console.Write("ComareOrdinal() രീതി ഉപയോഗിച്ച് സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നു:\n"); എങ്കിൽ (ഫലം 0) Console.WriteLine(str1 + "" + str2 നേക്കാൾ വലുത്); മറ്റുള്ളവ കൺസോൾ .WriteLine(str1 + " സമം " + str4); Console.WriteLine(); // == ഓപ്പറേറ്റർ ഉപയോഗിച്ച് സ്ട്രിംഗ് സമത്വം നിർണ്ണയിക്കുക // ഇത് (str1 == str4) കൺസോൾ ആണെങ്കിൽ പ്രതീക സ്ട്രിംഗുകളുടെ ഒരു ഓർഡിനൽ താരതമ്യമാണ്.WriteLine(str1 + " == " + str4); // != ഓപ്പറേറ്റർ if(str1 != str3) കൺസോൾ ഉപയോഗിച്ച് ലൈൻ അസമത്വം നിർവചിക്കുക.WriteLine(str1 + "!= " + str3); if(str1 != str2) Console.WriteLine(str1 + "!= " + str2); Console.WriteLine(); // സ്ട്രിംഗുകളുടെ ഒരു കേസ്-ഇൻസെൻസിറ്റീവ് ഓർഡിനൽ താരതമ്യം നടത്തുക // Equals() രീതി ഉപയോഗിച്ച് if(String.Equals(str1, str2, StringComparison.OrdinalIgnoreCase)) Console.WriteLine("Equals() രീതി ഉപയോഗിച്ച് സ്ട്രിംഗുകളുടെ താരതമ്യം " + "OrdinalIgnoreCase പരാമീറ്റർ: \n" + str1 + " സമം " + str2); Console.WriteLine(); // സ്ട്രിംഗുകളുടെ ഭാഗങ്ങൾ താരതമ്യം ചെയ്യുകയാണെങ്കിൽ (String.Campare(str2, 0, str5, 0, 3, StringComparison.CurrentCulture) > 0) ( Console.WriteLine("നിലവിലെ സാംസ്കാരിക അന്തരീക്ഷം കണക്കിലെടുത്ത് സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുക:" + "\n3 സ്ട്രിംഗിന്റെ ആദ്യ പ്രതീകങ്ങൾ " + str2 + " എന്ന വരിയിലെ ആദ്യത്തെ 3 പ്രതീകങ്ങളേക്കാൾ കൂടുതൽ " + str5); ) )

ഈ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നത് ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് ഉണ്ടാക്കുന്നു:

ഹബ്ര, ഹലോ!

കുറച്ചുകാലം മുമ്പ്, ഒരു കമ്പ്യൂട്ടർ സയൻസ് കോളേജിലെ അദ്ധ്യാപകരിൽ ഒരാൾ ഉൾപ്പെട്ട രസകരമായ ഒരു സംഭവം എനിക്ക് സംഭവിച്ചു.

ലിനക്‌സ് പ്രോഗ്രാമിംഗിനെക്കുറിച്ചുള്ള സംഭാഷണം ഈ വ്യക്തിയിലേക്ക് പതുക്കെ പുരോഗമിക്കുന്നു, സിസ്റ്റം പ്രോഗ്രാമിംഗിന്റെ സങ്കീർണ്ണത യഥാർത്ഥത്തിൽ അതിശയോക്തിപരമാണെന്ന് വാദിച്ചു. സി ഭാഷ ഒരു പൊരുത്തം പോലെ ലളിതമാണ്, വാസ്തവത്തിൽ, ലിനക്സ് കേർണൽ പോലെ (അദ്ദേഹത്തിന്റെ വാക്കുകളിൽ).

സി ഭാഷയിൽ (gcc, vim, make, valgrind, gdb) വികസനത്തിനായി ഒരു മാന്യന്റെ ഒരു കൂട്ടം യൂട്ടിലിറ്റികൾ അടങ്ങിയ, Linux ഉള്ള ഒരു ലാപ്‌ടോപ്പ് എന്റെ പക്കൽ ഉണ്ടായിരുന്നു. അപ്പോൾ ഞങ്ങൾ എന്താണ് ലക്ഷ്യം വെച്ചതെന്ന് എനിക്ക് ഓർമയില്ല, പക്ഷേ കുറച്ച് മിനിറ്റുകൾക്ക് ശേഷം എന്റെ എതിരാളി ഈ ലാപ്‌ടോപ്പിൽ സ്വയം കണ്ടെത്തി, പ്രശ്നം പരിഹരിക്കാൻ പൂർണ്ണമായും തയ്യാറാണ്.

അക്ഷരാർത്ഥത്തിൽ ആദ്യ വരികളിൽ തന്നെ ഒരു വരിയിലേക്ക് മെമ്മറി അനുവദിക്കുമ്പോൾ അദ്ദേഹം ഗുരുതരമായ തെറ്റ് ചെയ്തു.

Char *str = (char *) malloc(sizeof(char) * strlen(buffer));
ബഫർ - കീബോർഡിൽ നിന്നുള്ള ഡാറ്റ എഴുതിയ ഒരു സ്റ്റാക്ക് വേരിയബിൾ.

"ഇതിൽ എന്തെങ്കിലും തെറ്റ് എങ്ങനെ ഉണ്ടാകും?" എന്ന് ചോദിക്കുന്ന ആളുകൾ തീർച്ചയായും ഉണ്ടാകുമെന്ന് ഞാൻ കരുതുന്നു.
എന്നെ വിശ്വസിക്കൂ, അതിന് കഴിയും.

കൃത്യമായി എന്താണ് - പൂച്ചയെക്കുറിച്ച് വായിക്കുക.

ഒരു ചെറിയ സിദ്ധാന്തം - ഒരുതരം LikBez.

നിങ്ങൾക്കറിയാമെങ്കിൽ, അടുത്ത തലക്കെട്ടിലേക്ക് സ്ക്രോൾ ചെയ്യുക.

C-യിലെ ഒരു സ്ട്രിംഗ് എന്നത് പ്രതീകങ്ങളുടെ ഒരു നിരയാണ്, അത് എല്ലായ്പ്പോഴും "\0"-ൽ അവസാനിക്കണം - വരിയുടെ അവസാന പ്രതീകം. സ്റ്റാക്കിലെ (സ്റ്റാറ്റിക്) സ്ട്രിംഗുകൾ ഇതുപോലെ പ്രഖ്യാപിച്ചു:

Char str[n] = (0 );
n എന്നത് പ്രതീക ശ്രേണിയുടെ വലുപ്പമാണ്, സ്ട്രിംഗിന്റെ ദൈർഘ്യത്തിന് തുല്യമാണ്.

അസൈൻമെന്റ് ( 0 ) - സ്ട്രിംഗ് "പൂജ്യം ചെയ്യുക" (ഓപ്ഷണൽ, നിങ്ങൾക്കത് കൂടാതെ അത് പ്രഖ്യാപിക്കാം). മെംസെറ്റ്(str, 0, sizeof(str)), bzero(str, sizeof(str)) എന്നീ ഫംഗ്‌ഷനുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് തുല്യമാണ് ഫലം. അൺഇനിഷ്യലൈസ്ഡ് വേരിയബിളുകളിൽ മാലിന്യം ഉപേക്ഷിക്കുന്നത് തടയാൻ ഇത് ഉപയോഗിക്കുന്നു.

നിങ്ങൾക്ക് ഉടനടി സ്റ്റാക്കിൽ ഒരു സ്ട്രിംഗ് ആരംഭിക്കാനും കഴിയും:

ചാർ ബഫ് = "ഡിഫോൾട്ട് ബഫർ ടെക്സ്റ്റ്\n";
കൂടാതെ, ഒരു സ്ട്രിംഗ് ഒരു പോയിന്ററായി പ്രഖ്യാപിക്കുകയും കൂമ്പാരത്തിൽ അതിനായി മെമ്മറി അനുവദിക്കുകയും ചെയ്യാം:

Char *str = malloc(size);
വലിപ്പം - സ്ട്രിങ്ങിനായി ഞങ്ങൾ അനുവദിക്കുന്ന ബൈറ്റുകളുടെ എണ്ണം. അത്തരം സ്ട്രിംഗുകളെ ഡൈനാമിക് എന്ന് വിളിക്കുന്നു (ആവശ്യമായ വലുപ്പം ചലനാത്മകമായി കണക്കാക്കുന്നതിനാൽ + റിയലോക്ക്() ഫംഗ്ഷൻ ഉപയോഗിച്ച് എപ്പോൾ വേണമെങ്കിലും അനുവദിച്ച മെമ്മറി വലുപ്പം വർദ്ധിപ്പിക്കാൻ കഴിയും).

ഒരു സ്റ്റാക്ക് വേരിയബിളിന്റെ കാര്യത്തിൽ, അറേയുടെ വലുപ്പം നിർണ്ണയിക്കാൻ ഞാൻ n എന്ന നൊട്ടേഷൻ ഉപയോഗിച്ചു; ഒരു ഹീപ്പ് വേരിയബിളിന്റെ കാര്യത്തിൽ, ഞാൻ നൊട്ടേഷൻ വലുപ്പം ഉപയോഗിച്ചു. സ്റ്റാക്കിലെ ഒരു ഡിക്ലറേഷനും കൂമ്പാരത്തിൽ മെമ്മറി അലോക്കേഷനുള്ള ഒരു പ്രഖ്യാപനവും തമ്മിലുള്ള വ്യത്യാസത്തിന്റെ യഥാർത്ഥ സത്തയെ ഇത് തികച്ചും പ്രതിഫലിപ്പിക്കുന്നു, കാരണം മൂലകങ്ങളുടെ എണ്ണത്തെക്കുറിച്ച് സംസാരിക്കുമ്പോൾ n സാധാരണയായി ഉപയോഗിക്കുന്നു. വലിപ്പം തികച്ചും വ്യത്യസ്തമായ കഥയാണ്...

Valgrind ഞങ്ങളെ സഹായിക്കും

എന്റെ മുൻ ലേഖനത്തിലും ഞാൻ അത് സൂചിപ്പിച്ചിരുന്നു. Valgrind ( , two - a small how-to) എന്നത് പ്രോഗ്രാമർ മെമ്മറി ലീക്കുകളും സന്ദർഭ പിശകുകളും ട്രാക്ക് ചെയ്യാൻ സഹായിക്കുന്ന വളരെ ഉപയോഗപ്രദമായ ഒരു പ്രോഗ്രാമാണ് - സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ മിക്കപ്പോഴും പോപ്പ് അപ്പ് ചെയ്യുന്ന കാര്യങ്ങൾ.

ഞാൻ സൂചിപ്പിച്ച പ്രോഗ്രാമിന് സമാനമായ ഒന്ന് നടപ്പിലാക്കുന്ന ഒരു ചെറിയ ലിസ്റ്റിംഗ് നോക്കാം, അത് valgrind വഴി പ്രവർത്തിപ്പിക്കുക:

#ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #HELLO_STRING "ഹലോ, Habr!\n" അസാധുവായ മെയിൻ() (char *str = malloc(sizeof(char) * strlen(HELLO_STRING)); strcpy(str, HELLO_STRING); printf("->\t%s" , str); free(str); )
കൂടാതെ, വാസ്തവത്തിൽ, പ്രോഗ്രാമിന്റെ ഫലം:

$ gcc main.c $ ./a.out -> ഹലോ, ഹബ്ർ!
ഇതുവരെ അസാധാരണമായി ഒന്നുമില്ല. ഇനി നമുക്ക് ഈ പ്രോഗ്രാം valgrind ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കാം!

$ valgrind --tool=memcheck ./a.out ==3892== Memcheck, ഒരു മെമ്മറി പിശക് കണ്ടെത്തൽ ==3892== പകർപ്പവകാശം (C) 2002-2015, ഒപ്പം GNU GPL"d, ജൂലിയൻ സെവാർഡ് മറ്റുള്ളവരും. == 3892== Valgrind-3.12.0 ഉം LibVEX ഉം ഉപയോഗിക്കുന്നു; പകർപ്പവകാശ വിവരങ്ങൾക്കായി -h ഉപയോഗിച്ച് വീണ്ടും പ്രവർത്തിപ്പിക്കുക ==3892== കമാൻഡ്: ./a.out ==3892== ==3892== 2 വലുപ്പത്തിന്റെ അസാധുവായ എഴുത്ത് ==3892= = 0x4005B4-ൽ: പ്രധാനം (/home/indever/prg/C/public/a.out) ==3892== വിലാസം 0x520004c 13 alloc"d ==3892== 0x4C2DocB9D-ൽ ഒരു ബ്ലോക്കിനുള്ളിൽ 12 ബൈറ്റുകളാണ്: mall (vg_replace_malloc.c:299) ==3892== by 0x400597: പ്രധാനം (/home/indever/prg/C/public/a.out) ==3892== ==3892== വലുപ്പം 1 == എന്നതിന്റെ വായന അസാധുവാണ് 3892== 0x4C30BC4-ൽ: strlen (vg_replace_strmem.c:454) ==3892== by 0x4E89AD0: vfprintf (in /usr/lib64/libc-2.24.so) ==3892== 0x8 0x8/f-ൽ 0x8 lib64/libc-2.24.so) ==3892== by 0x4005CF: പ്രധാനം (/home/indever/prg/C/public/a.out) ==3892== വിലാസം 0x520004d വലുപ്പം 13-ന്റെ ഒരു ബ്ലോക്കിന് ശേഷം 0 ബൈറ്റുകൾ ആണ് alloc"d ==3892== 0x4C2DB9D-ൽ: malloc (vg_replace_malloc.c:299) ==3892== by 0x400597: പ്രധാനം (/home/indever/prg/C/public/a.out) ==3892== -> ഹലോ, ഹബ്ർ! ==3892== ==3892== ഹീപ്പ് സംഗ്രഹം: ==3892== പുറത്തുകടക്കുമ്പോൾ ഉപയോഗിക്കുന്നു: 0 ബ്ലോക്കുകളിൽ 0 ബൈറ്റുകൾ ==3892== മൊത്തം ഹീപ്പ് ഉപയോഗം: 2 അലോക്കുകൾ, 2 ഫ്രീകൾ, 1,037 ബൈറ്റുകൾ അനുവദിച്ചു ==3892= = ==3892== എല്ലാ ഹീപ്പ് ബ്ലോക്കുകളും സ്വതന്ത്രമാക്കി -- ചോർച്ചകൾ സാധ്യമല്ല ==3892== ==3892== കണ്ടെത്തിയതും അടിച്ചമർത്തപ്പെട്ടതുമായ പിശകുകളുടെ എണ്ണത്തിന്, ഉപയോഗിച്ച് വീണ്ടും പ്രവർത്തിപ്പിക്കുക: -v ==3892== പിശക് സംഗ്രഹം: 3 പിശകുകൾ 2 സന്ദർഭങ്ങളിൽ നിന്ന് (അടച്ചത്: 0 മുതൽ 0)
==3892== എല്ലാ ഹീപ്പ് ബ്ലോക്കുകളും സ്വതന്ത്രമാക്കി - ചോർച്ച സാധ്യമല്ല- ചോർച്ചകളൊന്നുമില്ല, അത് നല്ല വാർത്തയാണ്. എന്നാൽ നിങ്ങളുടെ കണ്ണുകൾ കുറച്ചുകൂടി താഴ്ത്തുന്നത് മൂല്യവത്താണ് (എന്നിരുന്നാലും, ഞാൻ ശ്രദ്ധിക്കാൻ ആഗ്രഹിക്കുന്നു, ഇത് സംഗ്രഹം മാത്രമാണ്, പ്രധാന വിവരങ്ങൾ അല്പം വ്യത്യസ്തമായ സ്ഥലമാണ്):

==3892== പിശക് സംഗ്രഹം: 2 സന്ദർഭങ്ങളിൽ നിന്ന് 3 പിശകുകൾ (അടച്ചു: 0 മുതൽ 0)
3 തെറ്റുകൾ. 2 സന്ദർഭങ്ങളിൽ. അത്തരമൊരു ലളിതമായ പ്രോഗ്രാമിൽ. എങ്ങനെ!?

അതെ, വളരെ ലളിതമാണ്. "\0" എന്ന എൻഡ്-ഓഫ്-ലൈൻ പ്രതീകത്തെ strlen ഫംഗ്ഷൻ കണക്കിലെടുക്കുന്നില്ല എന്നതാണ് മുഴുവൻ "തമാശ". നിങ്ങൾ അത് ഇൻകമിംഗ് ലൈനിൽ വ്യക്തമായി വ്യക്തമാക്കിയാലും (#define HELLO_STRING “Hello, Habr!\n\0”), അത് അവഗണിക്കപ്പെടും.

പ്രോഗ്രാം എക്സിക്യൂഷന്റെ ഫലത്തിന് തൊട്ടുമുകളിൽ, ലൈൻ -> ഹലോ, ഹബ്ർ!ഞങ്ങളുടെ വിലയേറിയ വാൽഗ്രൈന്റിന് എന്താണ്, എവിടെ ഇഷ്ടപ്പെട്ടില്ല എന്നതിന്റെ വിശദമായ റിപ്പോർട്ട് ഉണ്ട്. ഈ വരികൾ സ്വയം നോക്കി നിങ്ങളുടെ സ്വന്തം നിഗമനങ്ങളിൽ എത്തിച്ചേരാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു.

യഥാർത്ഥത്തിൽ, പ്രോഗ്രാമിന്റെ ശരിയായ പതിപ്പ് ഇതുപോലെ കാണപ്പെടും:

#ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #HELLO_STRING "ഹലോ, Habr!\n" അസാധുവായ മെയിൻ() ( char *str = malloc(sizeof(char) * (strlen(HELLO_STRING) + 1)); strcpy(str, HELLO_STRING); printf("->\) t%s", str); free(str); )
നമുക്ക് ഇത് valgrind വഴി പ്രവർത്തിപ്പിക്കാം:

$ valgrind --tool=memcheck ./a.out -> ഹലോ, Habr! ==3435== ==3435== ഹീപ്പ് സംഗ്രഹം: ==3435== പുറത്തുകടക്കുമ്പോൾ ഉപയോഗിക്കുന്നു: 0 ബ്ലോക്കുകളിൽ 0 ബൈറ്റുകൾ ==3435== മൊത്തം ഹീപ്പ് ഉപയോഗം: 2 അലോക്കുകൾ, 2 ഫ്രീകൾ, 1,038 ബൈറ്റുകൾ അനുവദിച്ചു ==3435= ===3435== എല്ലാ ഹീപ്പ് ബ്ലോക്കുകളും സ്വതന്ത്രമാക്കി -- ചോർച്ചകൾ സാധ്യമല്ല ==3435== ==3435== കണ്ടെത്തിയതും അടിച്ചമർത്തപ്പെട്ടതുമായ പിശകുകളുടെ എണ്ണത്തിന്, ഉപയോഗിച്ച് വീണ്ടും പ്രവർത്തിപ്പിക്കുക: -v ==3435== പിശക് സംഗ്രഹം: 0 പിശകുകൾ 0 സന്ദർഭങ്ങളിൽ നിന്ന് (അടച്ചത്: 0 മുതൽ 0)
കൊള്ളാം. പിശകുകളൊന്നുമില്ല, +1 ബൈറ്റ് അനുവദിച്ച മെമ്മറി പ്രശ്നം പരിഹരിക്കാൻ സഹായിച്ചു.

രസകരം എന്തെന്നാൽ, മിക്ക കേസുകളിലും ഒന്നും രണ്ടും പ്രോഗ്രാമുകൾ ഒരേപോലെ പ്രവർത്തിക്കും, എന്നാൽ അവസാനിക്കുന്ന പ്രതീകം യോജിക്കാത്ത വരിയ്‌ക്കായി നീക്കിവച്ചിരിക്കുന്ന മെമ്മറി പൂജ്യമല്ലെങ്കിൽ, അത്തരം ഒരു ലൈൻ ഔട്ട്‌പുട്ട് ചെയ്യുമ്പോൾ printf() ഫംഗ്‌ഷൻ , ഈ ലൈനിനു ശേഷമുള്ള എല്ലാ മാലിന്യങ്ങളും ഔട്ട്പുട്ട് ചെയ്യും - ഒരു വരി അവസാനിക്കുന്ന പ്രതീകം printf() ന്റെ വഴിയിൽ വരുന്നതുവരെ എല്ലാം പ്രിന്റ് ചെയ്യപ്പെടും.

എന്നിരുന്നാലും, നിങ്ങൾക്കറിയാമോ, (strlen(str) + 1) അത്തരമൊരു പരിഹാരമാണ്. ഞങ്ങൾ 2 പ്രശ്നങ്ങൾ നേരിടുന്നു:

1. ഉദാഹരണത്തിന്, s(n)printf(..) ഉപയോഗിച്ച് സൃഷ്ടിക്കുന്ന ഒരു സ്‌ട്രിംഗിനായി നമുക്ക് മെമ്മറി അനുവദിക്കണമെങ്കിൽ എന്തുചെയ്യും? ഞങ്ങൾ വാദങ്ങളെ പിന്തുണയ്ക്കുന്നില്ല.
2. രൂപഭാവം. വേരിയബിൾ ഡിക്ലറേഷൻ ലൈൻ വളരെ മോശമായി തോന്നുന്നു. ചില ആൺകുട്ടികൾ പ്ലസുകൾക്ക് കീഴിൽ എഴുതുന്നതുപോലെ (char *) malloc-ലേക്ക് അറ്റാച്ചുചെയ്യുന്നു. നിങ്ങൾ പതിവായി സ്ട്രിംഗുകൾ പ്രോസസ്സ് ചെയ്യേണ്ട ഒരു പ്രോഗ്രാമിൽ, കൂടുതൽ ഗംഭീരമായ ഒരു പരിഹാരം കണ്ടെത്തുന്നതിന് അർത്ഥമുണ്ട്.

നമ്മളെ രണ്ടുപേരെയും തൃപ്തിപ്പെടുത്തുന്നതും വാൽഗ്രൈൻഡ് ചെയ്യുന്നതുമായ ഒരു പരിഹാരവുമായി വരാം.

snprintf()

int snprintf(char *str, size_t വലുപ്പം, കോൺസ്റ്റ് ചാർ * ഫോർമാറ്റ്, ...);- ഒരു ഫംഗ്‌ഷൻ - സ്‌പ്രിന്റ്‌എഫിന്റെ ഒരു വിപുലീകരണം, ഇത് ഒരു സ്ട്രിംഗ് ഫോർമാറ്റ് ചെയ്യുകയും ആദ്യത്തെ ആർഗ്യുമെന്റായി പാസ്സാക്കിയ പോയിന്ററിലേക്ക് എഴുതുകയും ചെയ്യുന്നു. ഇത് sprintf() ൽ നിന്ന് വ്യത്യാസപ്പെട്ടിരിക്കുന്നു, അതിൽ str വലിപ്പത്തിൽ വ്യക്തമാക്കിയതിനേക്കാൾ വലിയ ഒരു ബൈറ്റ് എഴുതില്ല.

ഫംഗ്‌ഷന് രസകരമായ ഒരു സവിശേഷതയുണ്ട് - ഏത് സാഹചര്യത്തിലും, ഇത് ജനറേറ്റുചെയ്‌ത സ്ട്രിംഗിന്റെ വലുപ്പം നൽകുന്നു (ലൈൻ പ്രതീകത്തിന്റെ അവസാനം കണക്കിലെടുക്കാതെ). സ്ട്രിംഗ് ശൂന്യമാണെങ്കിൽ, 0 തിരികെ നൽകും.

strlen ഉപയോഗിക്കുന്നതിൽ ഞാൻ വിവരിച്ച പ്രശ്നങ്ങളിലൊന്ന് sprintf(), snprintf() ഫംഗ്ഷനുകളുമായി ബന്ധപ്പെട്ടതാണ്. സ്ട്രിംഗിൽ എന്തെങ്കിലും എഴുതേണ്ടതുണ്ടെന്ന് നമുക്ക് അനുമാനിക്കാം. അവസാന വരിയിൽ മറ്റ് വേരിയബിളുകളുടെ മൂല്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ഞങ്ങളുടെ പ്രവേശനം ഇതുപോലെയായിരിക്കണം:

Char * str = /* ഇവിടെ മെമ്മറി അനുവദിക്കുക */; sprintf(str, "ഹലോ, %s\n", "Habr!");
ചോദ്യം ഉയർന്നുവരുന്നു: സ്‌ട്രിംഗ് സ്‌ട്രിംഗിനായി എത്ര മെമ്മറി അനുവദിക്കണമെന്ന് എങ്ങനെ നിർണ്ണയിക്കും?

Char * str = malloc(sizeof(char) * (strlen(str, "Hello, %s\n", "Habr!") + 1)); - അത് പ്രവർത്തിക്കില്ല. strlen() ഫംഗ്ഷൻ പ്രോട്ടോടൈപ്പ് ഇതുപോലെ കാണപ്പെടുന്നു:

#ഉൾപ്പെടുന്നു size_t strlen (const char *s);
const char *s എന്നത് s-ലേക്ക് കൈമാറിയ സ്ട്രിംഗ് ഒരു variadic ഫോർമാറ്റ് സ്ട്രിംഗ് ആയിരിക്കുമെന്ന് അർത്ഥമാക്കുന്നില്ല.

ഞാൻ മുകളിൽ സൂചിപ്പിച്ച snprintf() ഫംഗ്‌ഷന്റെ ഉപയോഗപ്രദമായ പ്രോപ്പർട്ടി ഇവിടെ ഞങ്ങളെ സഹായിക്കും. ഇനിപ്പറയുന്ന പ്രോഗ്രാമിന്റെ കോഡ് നോക്കാം:

#ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു void main() ( /* snprintf() വരിയുടെ പ്രതീകത്തിന്റെ അവസാനം കണക്കിലെടുക്കാത്തതിനാൽ, അതിന്റെ വലുപ്പം ഞങ്ങൾ ഫലത്തിലേക്ക് ചേർക്കുന്നു */ size_t need_mem = snprintf(NULL, 0, "ഹലോ, %s!\n", "Habr") + sizeof("\0"); char *str = malloc(needed_mem); snprintf(str, need_mem, "Hello, %s!\n", "Habr"); printf("->\t %s", str); free(str); )
valgrind-ൽ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക:

$ valgrind --tool=memcheck ./a.out -> ഹലോ, Habr! ==4132== ==4132== ഹീപ്പ് സംഗ്രഹം: ==4132== പുറത്തുകടക്കുമ്പോൾ ഉപയോഗത്തിലാണ്: 0 ബ്ലോക്കുകളിൽ 0 ബൈറ്റുകൾ ==4132== മൊത്തം ഹീപ്പ് ഉപയോഗം: 2 അലോക്കുകൾ, 2 ഫ്രീകൾ, 1,041 ബൈറ്റുകൾ അനുവദിച്ചു ==4132= ===4132== എല്ലാ ഹീപ്പ് ബ്ലോക്കുകളും സ്വതന്ത്രമാക്കി -- ചോർച്ചകൾ സാധ്യമല്ല ==4132== ==4132== കണ്ടെത്തിയതും അടിച്ചമർത്തപ്പെട്ടതുമായ പിശകുകളുടെ എണ്ണത്തിന്, ഉപയോഗിച്ച് വീണ്ടും പ്രവർത്തിപ്പിക്കുക: -v ==4132== പിശക് സംഗ്രഹം: 0 പിശകുകൾ 0 സന്ദർഭങ്ങളിൽ നിന്ന് (അടച്ചത്: 0 മുതൽ 0) $
കൊള്ളാം. ഞങ്ങൾക്ക് വാദത്തിന്റെ പിന്തുണയുണ്ട്. snprintf() ഫംഗ്‌ഷനിലേക്കുള്ള രണ്ടാമത്തെ ആർഗ്യുമെന്റായി നമ്മൾ null പാസ് ചെയ്യുന്നതിനാൽ, ഒരു നൾ പോയിന്ററിലേക്ക് എഴുതുന്നത് ഒരിക്കലും ഒരു സീഗ്‌ഫോൾട്ടിന് കാരണമാകില്ല. എന്നിരുന്നാലും, ഇതൊക്കെയാണെങ്കിലും, ഫംഗ്ഷൻ സ്ട്രിങ്ങിന് ആവശ്യമായ വലുപ്പം നൽകും.

എന്നാൽ മറുവശത്ത്, ഞങ്ങൾക്ക് ഒരു അധിക വേരിയബിളും ഡിസൈനും അവതരിപ്പിക്കേണ്ടി വന്നു

Size_t need_mem = snprintf(NULL, 0, "ഹലോ, %s!\n", "Habr") + sizeof("\0");
strlen() ന്റെ കാര്യത്തേക്കാൾ മോശമായി തോന്നുന്നു.

പൊതുവായി, ഫോർമാറ്റ് ലൈനിന്റെ അവസാനത്തിൽ നിങ്ങൾ "\0" വ്യക്തമായി വ്യക്തമാക്കിയാൽ + sizeof("\0") നീക്കം ചെയ്യാവുന്നതാണ് (size_t need_mem = snprintf(NULL, 0, "Hello, %s!\n \0 ", "Habr");), എന്നാൽ ഇത് എല്ലായ്‌പ്പോഴും സാധ്യമല്ല (സ്ട്രിംഗ് പ്രോസസ്സിംഗ് മെക്കാനിസത്തെ ആശ്രയിച്ച്, ഞങ്ങൾക്ക് ഒരു അധിക ബൈറ്റ് അനുവദിക്കാം).

നമ്മൾ എന്തെങ്കിലും ചെയ്യണം. ഞാൻ അൽപ്പം ചിന്തിച്ചു, പഴമക്കാരുടെ ജ്ഞാനത്തെ ആകർഷിക്കാനുള്ള സമയമാണിതെന്ന് ഞാൻ തീരുമാനിച്ചു. നൾ പോയിന്റർ ഉപയോഗിച്ച് snprintf() നെ ആദ്യത്തെ ആർഗ്യുമെന്റ് എന്നും null നെ രണ്ടാമത്തേത് എന്നും വിളിക്കുന്ന ഒരു മാക്രോ ഫംഗ്‌ഷൻ വിവരിക്കാം. വരിയുടെ അവസാനത്തെക്കുറിച്ച് മറക്കരുത്!

#define strsize(args...) snprintf(NULL, 0, args) + sizeof("\0")
അതെ, ഇത് ചിലർക്ക് വാർത്തയായിരിക്കാം, എന്നാൽ സി മാക്രോകൾ ഒരു വേരിയബിൾ ആർഗ്യുമെന്റുകളെ പിന്തുണയ്ക്കുന്നു, കൂടാതെ നിർദ്ദിഷ്ട മാക്രോ ഫംഗ്ഷൻ ആർഗ്യുമെന്റ് (ഞങ്ങളുടെ കാര്യത്തിൽ, ആർഗ്സ്) നിരവധി യഥാർത്ഥ ആർഗ്യുമെന്റുകളുമായി പൊരുത്തപ്പെടുന്നതായി എലിപ്സിസ് പ്രീപ്രൊസസറോട് പറയുന്നു.

പ്രായോഗികമായി നമ്മുടെ പരിഹാരം പരിശോധിക്കാം:

#ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #define strsize(args...) snprintf(NULL, 0, args) + sizeof("\0") void main() ( char *str = malloc(strsize("Hello, %s\n", "Habr! ")); sprintf(str, "ഹലോ, %s\n", "Habr!"); printf("->\t%s", str); free(str); )
നമുക്ക് വാൽഗ്രണ്ടിൽ നിന്ന് ആരംഭിക്കാം:

$ valgrind --tool=memcheck ./a.out -> ഹലോ, Habr! ==6432== ==6432== ഹീപ്പ് സംഗ്രഹം: ==6432== പുറത്തുകടക്കുമ്പോൾ ഉപയോഗത്തിലാണ്: 0 ബ്ലോക്കുകളിൽ 0 ബൈറ്റുകൾ ==6432== മൊത്തം ഹീപ്പ് ഉപയോഗം: 2 അലോക്കുകൾ, 2 ഫ്രീകൾ, 1,041 ബൈറ്റുകൾ അനുവദിച്ചു ==6432= = ==6432== എല്ലാ ഹീപ്പ് ബ്ലോക്കുകളും സ്വതന്ത്രമാക്കി -- ചോർച്ചകൾ സാധ്യമല്ല ==6432== ==6432== കണ്ടെത്തിയതും അടിച്ചമർത്തപ്പെട്ടതുമായ പിശകുകളുടെ എണ്ണത്തിന്, ഉപയോഗിച്ച് വീണ്ടും പ്രവർത്തിപ്പിക്കുക: -v ==6432== പിശക് സംഗ്രഹം: 0 പിശകുകൾ 0 സന്ദർഭങ്ങളിൽ നിന്ന് (അടച്ചത്: 0 മുതൽ 0)
അതെ, പിശകുകളൊന്നുമില്ല. എല്ലാം ശരിയാണ്. valgrind സന്തോഷവാനാണ്, പ്രോഗ്രാമർക്ക് ഒടുവിൽ ഉറങ്ങാൻ കഴിയും.

എന്നാൽ അവസാനമായി, ഞാൻ ഒരു കാര്യം കൂടി പറയാം. ഏതെങ്കിലും സ്‌ട്രിങ്ങിന് (ആർഗ്യുമെന്റുകൾക്കൊപ്പം പോലും) മെമ്മറി അനുവദിക്കണമെങ്കിൽ, ഇതിനകം തന്നെ ഉണ്ട് പൂർണ്ണമായും പ്രവർത്തിക്കുന്ന തയ്യാറായ പരിഹാരം.

നമ്മൾ സംസാരിക്കുന്നത് asprintf ഫംഗ്ഷനെക്കുറിച്ചാണ്:

#നിർവ്വചിക്കുക _GNU_SOURCE /* ഫീച്ചർ_ടെസ്റ്റ്_മാക്രോസ് (7) */ #ഉൾപ്പെടുത്തുക int asprintf(char **strp, const char *fmt, ...);
ഇത് അതിന്റെ ആദ്യ ആർഗ്യുമെന്റായി ഒരു സ്ട്രിംഗിലേക്ക് (**strp) ഒരു പോയിന്റർ എടുക്കുകയും ഡീറഫറൻസ് ചെയ്ത പോയിന്ററിലേക്ക് മെമ്മറി അനുവദിക്കുകയും ചെയ്യുന്നു.

asprintf() ഉപയോഗിച്ച് എഴുതിയ ഞങ്ങളുടെ പ്രോഗ്രാം ഇതുപോലെ കാണപ്പെടും:

#ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു void main() ( char *str; asprintf(&str, "ഹലോ, %s!\n", "Habr"); printf("->\t%s", str); free(str); )
വാസ്തവത്തിൽ, വാൽഗ്രൈൻഡിൽ:

$ valgrind --tool=memcheck ./a.out -> ഹലോ, Habr! ==6674== ==6674== ഹീപ്പ് സംഗ്രഹം: ==6674== പുറത്തുകടക്കുമ്പോൾ ഉപയോഗിക്കുന്നു: 0 ബ്ലോക്കുകളിൽ 0 ബൈറ്റുകൾ ==6674== മൊത്തം ഹീപ്പ് ഉപയോഗം: 3 അലോക്കുകൾ, 3 ഫ്രീകൾ, 1,138 ബൈറ്റുകൾ അനുവദിച്ചു ==6674= ===6674== എല്ലാ ഹീപ്പ് ബ്ലോക്കുകളും സ്വതന്ത്രമാക്കി -- ചോർച്ചകൾ സാധ്യമല്ല ==6674== ==6674== കണ്ടെത്തിയതും അടിച്ചമർത്തപ്പെട്ടതുമായ പിശകുകളുടെ എണ്ണത്തിന്, ഉപയോഗിച്ച് വീണ്ടും പ്രവർത്തിപ്പിക്കുക: -v ==6674== പിശക് സംഗ്രഹം: 0 പിശകുകൾ 0 സന്ദർഭങ്ങളിൽ നിന്ന് (അടച്ചത്: 0 മുതൽ 0)
എല്ലാം ശരിയാണ്, പക്ഷേ, നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, കൂടുതൽ മെമ്മറി അനുവദിച്ചു, ഇപ്പോൾ മൂന്ന് അലോക്കുകൾ ഉണ്ട്, രണ്ടല്ല, ദുർബലമായ എംബഡഡ് സിസ്റ്റങ്ങളിൽ, ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നത് അഭികാമ്യമല്ല.
കൂടാതെ, കൺസോളിൽ man asprintf എന്ന് എഴുതിയാൽ, നമ്മൾ കാണും:

ഈ ഫംഗ്‌ഷനുകൾക്ക് അനുസൃതമായി GNU വിപുലീകരണങ്ങളാണ്, C അല്ലെങ്കിൽ POSIX-ൽ അല്ല. അവ *ബിഎസ്ഡിക്ക് കീഴിലും ലഭ്യമാണ്. FreeBSD നടപ്പിലാക്കൽ പിശകിൽ strp നെ NULL ആയി സജ്ജമാക്കുന്നു.

ഈ പ്രവർത്തനം ഗ്നു സ്രോതസ്സുകളിൽ മാത്രമേ ലഭ്യമാകൂ എന്ന് ഇത് വ്യക്തമാക്കുന്നു.

ഉപസംഹാരം

ഉപസംഹാരമായി, സിയിലെ സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് വളരെ സങ്കീർണ്ണമായ ഒരു വിഷയമാണെന്ന് ഞാൻ പറയാൻ ആഗ്രഹിക്കുന്നു, അതിൽ നിരവധി സൂക്ഷ്മതകളുണ്ട്. ഉദാഹരണത്തിന്, ചലനാത്മകമായി മെമ്മറി അനുവദിക്കുമ്പോൾ "സുരക്ഷിത" കോഡ് എഴുതാൻ, malloc() എന്നതിന് പകരം calloc() ഫംഗ്ഷൻ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു - calloc അനുവദിച്ച മെമ്മറി പൂജ്യങ്ങൾ കൊണ്ട് നിറയ്ക്കുന്നു. അല്ലെങ്കിൽ, മെമ്മറി അനുവദിച്ച ശേഷം, മെംസെറ്റ്() ഫംഗ്ഷൻ ഉപയോഗിക്കുക. അല്ലാത്തപക്ഷം, അനുവദിച്ച മെമ്മറി ഏരിയയിൽ ആദ്യം സ്ഥിതിചെയ്യുന്ന മാലിന്യങ്ങൾ ഡീബഗ്ഗിംഗ് സമയത്തും ചിലപ്പോൾ സ്ട്രിംഗുമായി പ്രവർത്തിക്കുമ്പോഴും പ്രശ്നങ്ങൾ ഉണ്ടാക്കാം.

എനിക്ക് അറിയാവുന്ന പകുതിയിലധികം സി പ്രോഗ്രാമർമാരും (അവരിൽ ഭൂരിഭാഗവും തുടക്കക്കാരാണ്) എന്റെ അഭ്യർത്ഥന പ്രകാരം സ്ട്രിംഗുകൾക്കായി മെമ്മറി അനുവദിക്കുന്നതിനുള്ള പ്രശ്നം പരിഹരിച്ചു, അത് ആത്യന്തികമായി സന്ദർഭ പിശകുകളിലേക്ക് നയിക്കുന്ന വിധത്തിലാണ് അത് ചെയ്തത്. ഒരു സന്ദർഭത്തിൽ - ഒരു മെമ്മറി ലീക്ക് വരെ (ശരി, ഒരു വ്യക്തി സൗജന്യമായി ചെയ്യാൻ മറന്നു(str), അത് ആർക്കും ഒരിക്കലും സംഭവിക്കില്ല). വാസ്തവത്തിൽ, നിങ്ങൾ ഇപ്പോൾ വായിച്ച ഈ സൃഷ്ടി സൃഷ്ടിക്കാൻ ഇത് എന്നെ പ്രേരിപ്പിച്ചു.

ഈ ലേഖനം ആർക്കെങ്കിലും ഉപയോഗപ്രദമാകുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. ഞാൻ എന്തിനാണ് ഈ ബഹളമുണ്ടാക്കുന്നത് - ഒരു ഭാഷയും ലളിതമല്ല. എല്ലായിടത്തും അതിന്റേതായ സൂക്ഷ്മതകളുണ്ട്. നിങ്ങൾക്ക് അറിയാവുന്ന ഭാഷയുടെ കൂടുതൽ സൂക്ഷ്മതകൾ, നിങ്ങളുടെ കോഡ് മികച്ചതാണ്.

ഈ ലേഖനം വായിച്ചതിനുശേഷം നിങ്ങളുടെ കോഡ് കുറച്ചുകൂടി മെച്ചപ്പെടുമെന്ന് ഞാൻ വിശ്വസിക്കുന്നു :)
ഭാഗ്യം, ഹബർ!

C++ ലെ സ്ട്രിംഗുകൾ

ഒരു സ്ട്രിംഗ് എന്നത് പ്രതീകങ്ങളുടെ ഒരു ശ്രേണിയാണ് (അറേ). ഒരു പദപ്രയോഗത്തിൽ ഒരൊറ്റ പ്രതീകം സംഭവിക്കുകയാണെങ്കിൽ, അത് ഉൾപ്പെടുത്തിയിരിക്കണം ഒറ്റ ഉദ്ധരണികൾ. എക്‌സ്‌പ്രഷനുകളിൽ ഉപയോഗിക്കുമ്പോൾ, സ്ട്രിംഗ് ഇൻക്‌ലോസ് ചെയ്‌തിരിക്കുന്നു ഇരട്ട ഉദ്ധരണികൾ.വരിയുടെ അവസാനം ശൂന്യ പ്രതീകമാണ് \0 . C++ ൽ, ചിഹ്നങ്ങൾ ഉപയോഗിച്ച് സ്ട്രിംഗുകളെ വിവരിക്കാം (ഇതുപോലുള്ള ഘടകങ്ങളുടെ ഒരു നിര ചാർ), അതിൽ ലൈൻ ടെർമിനേറ്റർ സൂക്ഷിക്കാൻ ഒരു സ്ഥലം നൽകണം.

ഉദാഹരണത്തിന്, 25 പ്രതീക സ്ട്രിംഗ് വിവരണം ഇതുപോലെ കാണപ്പെടും:

നിങ്ങൾക്ക് സ്ട്രിംഗുകളുടെ ഒരു നിര വിവരിക്കാനും കഴിയും:

25 ബൈറ്റുകൾ വീതമുള്ള 3 വരികളുടെ ഒരു ശ്രേണി നിർവചിച്ചിരിക്കുന്നു.

നിങ്ങൾക്ക് ഉപയോഗിക്കാവുന്ന പോയിന്ററുകളുമായി പ്രവർത്തിക്കാൻ ( ചാര്*). ആദ്യത്തെ പ്രതീകത്തിന്റെ വിലാസം പോയിന്ററിന്റെ ആരംഭ മൂല്യമായിരിക്കും.

സ്ട്രിംഗുകൾ പ്രഖ്യാപിക്കുന്നതിനും ഔട്ട്പുട്ട് ചെയ്യുന്നതിനുമുള്ള ഒരു ഉദാഹരണം നോക്കാം.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#"stdafx.h" ഉൾപ്പെടുത്തുക #ഉൾപ്പെടുന്നു നെയിംസ്പേസ് എസ്ടിഡി ഉപയോഗിക്കുന്നു; int main() { setlocale(LC_ALL,"Rus" ); //3 വരികൾ വിവരിക്കുക, s3 ഒരു പോയിന്ററാണ് char s2[ 20 ], * s3, s4[ 30 ] ; കട്ട്<< «s2=» ; cin >> s2; //ഇൻപുട്ട് സ്ട്രിംഗ് s2 കട്ട്<< «s2=» << s2<< endl; //s4 സംഭരിച്ചിരിക്കുന്ന വരിയുടെ വിലാസം s3-ൽ എഴുതുക. ഇപ്പോൾ വേരിയബിളിൽ //(പോയിന്ററുകൾ) s3, s4 എന്നിവ ഒരേ വിലാസത്തിന്റെ മൂല്യം സംഭരിക്കുന്നു s3= s4; കട്ട്<< «s3=» ; cin >> s3; //ഇൻപുട്ട് ലൈൻ s3 //s3, s4 എന്നീ വരികൾ സ്ക്രീനിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യുക, എന്നിരുന്നാലും s3=s4 എന്ന അസൈൻമെന്റിന്റെ ഫലമായി; //ഇപ്പോൾ s3 ഉം s4 ഉം ഒന്നുതന്നെയാണ് കട്ട്<< «s3=» << s3<< endl; കട്ട്<< «s4=» << s4<< endl; സിസ്റ്റം ("താൽക്കാലികമായി നിർത്തുക"); തിരികെ 0; }

പ്രോഗ്രാമിന്റെ ഫലം:

എന്നാൽ ഉപയോക്താവ് ഒരു സ്പേസ് കൊണ്ട് വേർതിരിച്ച വാക്കുകൾ ഒരു വേരിയബിളിലേക്ക് നൽകിയാൽ, പ്രോഗ്രാം വ്യത്യസ്തമായി പ്രവർത്തിക്കുമെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്:

മുഴുവൻ പോയിന്റും പ്രവർത്തനം എന്നതാണ് സിൻഅഭിമുഖീകരിക്കുന്ന ഇടം വരെയുള്ള വരികളിൽ പ്രവേശിക്കുന്നു. കൂടുതൽ വൈവിധ്യമാർന്ന പ്രവർത്തനമാണ് ഗെറ്റ്ലൈൻ.

cin.getline(char *s, int n);

കീബോർഡിൽ നിന്ന് സ്ട്രിംഗുകൾ നൽകുന്നതിന് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു എസ്സ്‌പെയ്‌സുകൾക്കൊപ്പം, വരിയിൽ കൂടുതൽ അടങ്ങിയിരിക്കരുത് എൻകഥാപാത്രങ്ങൾ. അതിനാൽ, ഒരു സ്പേസ് അടങ്ങിയ ലൈനുകൾ ശരിയായി നൽകുന്നതിന്, ഞങ്ങളുടെ പ്രോഗ്രാമിൽ മാറ്റിസ്ഥാപിക്കേണ്ടത് ആവശ്യമാണ് സിൻ >>കൾഓൺ cin.getline(കൾ, 80).

സ്ട്രിംഗ് പ്രവർത്തനങ്ങൾ

അറേ പ്രോസസ്സിംഗ് അൽഗോരിതങ്ങൾ ഉപയോഗിച്ചോ പ്രത്യേക സ്ട്രിംഗ് പ്രോസസ്സിംഗ് ഫംഗ്ഷനുകൾ ഉപയോഗിച്ചോ ഒരു സ്ട്രിംഗ് പ്രതീകങ്ങളുടെ ഒരു നിരയായി പ്രോസസ്സ് ചെയ്യാൻ കഴിയും, അവയിൽ ചിലത് ചുവടെ നൽകിയിരിക്കുന്നു. ഈ സ്ട്രിംഗുകൾക്കൊപ്പം പ്രവർത്തിക്കാൻ നിങ്ങൾ ലൈബ്രറി ഉൾപ്പെടുത്തേണ്ടതുണ്ട് cstring.

ഒരു സംഖ്യയെ ഒരു സ്ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യാൻ, നിങ്ങൾക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കാം സ്പ്രിന്റ്ഫ്ലൈബ്രറിയിൽ നിന്ന് stdio.h.

സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള ചില പ്രവർത്തനങ്ങൾ:

ഫംഗ്ഷൻ പ്രോട്ടോടൈപ്പ്	പ്രവർത്തന വിവരണം
size_t strlen(const char *s)	സ്‌ട്രിംഗിന്റെ ദൈർഘ്യം ബൈറ്റുകളിൽ കണക്കാക്കുന്നു.
char *strcat(char *dest, const char *scr)	സ്ട്രിംഗ് src സ്ട്രിംഗ് ഡെസ്റ്റിന്റെ അവസാനത്തിൽ ചേർക്കുന്നു, തത്ഫലമായുണ്ടാകുന്ന സ്ട്രിംഗ് ഫലമായി തിരികെ നൽകും
char *strcpy(char *dest, const char *scr)	dest ചൂണ്ടിക്കാണിച്ച മെമ്മറി ലൊക്കേഷനിലേക്ക് string scr പകർത്തുന്നു
char strncat(char *dest, const char *dest, size_t maxlen)	string dest ന്റെ അവസാനം വരെ string src യുടെ maxlen പ്രതീകങ്ങൾ കൂട്ടിച്ചേർക്കുന്നു
char *strncpy(char *dest, const char *scr, size_t maxlen)	dest ചൂണ്ടിക്കാണിച്ച മെമ്മറി ലൊക്കേഷനിലേക്ക് src സ്ട്രിംഗ് മാക്സ്ലെൻ പ്രതീകങ്ങൾ പകർത്തുന്നു
int ctrcmp(const char *s1, const char *s2)	വലിയക്ഷരങ്ങളും ചെറിയക്ഷരങ്ങളും തമ്മിലുള്ള വ്യത്യാസം കണക്കിലെടുത്ത് നിഘണ്ടുക്രമത്തിൽ രണ്ട് സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുന്നു, സ്ട്രിംഗുകൾ പൊരുത്തപ്പെടുന്നെങ്കിൽ ഫംഗ്ഷൻ 0 നൽകുന്നു, s2-ന് മുമ്പായി s1 അക്ഷരമാലാക്രമത്തിലാണെങ്കിൽ 1 നൽകുന്നു, അല്ലാത്തപക്ഷം 1.
int strncmp (const char *s1, const char *s2, size_t maxlen)	രണ്ട് സ്ട്രിംഗുകളുടെ മാക്‌സ്‌ലെൻ പ്രതീകങ്ങളെ നിഘണ്ടു ക്രമത്തിൽ താരതമ്യം ചെയ്യുന്നു, സ്ട്രിംഗുകൾ പൊരുത്തപ്പെടുന്നെങ്കിൽ ഫംഗ്‌ഷൻ 0 നൽകുന്നു, s1 അക്ഷരമാലാക്രമത്തിൽ s2-ന് മുമ്പായി വെച്ചാൽ 1, അല്ലാത്തപക്ഷം 1.
ഇരട്ട അറ്റോഫ് (കോൺസ്റ്റ് ചാർ *s)	ഒരു സ്ട്രിംഗ് ഒരു യഥാർത്ഥ സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു; പരിവർത്തനം പരാജയപ്പെടുകയാണെങ്കിൽ, നമ്പർ 0 തിരികെ നൽകും
നീണ്ട അറ്റോൾ (കോൺസ്റ്റ് ചാർ *s)	ഒരു സ്ട്രിംഗ് ഒരു നീണ്ട പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, പരിവർത്തനം പരാജയപ്പെട്ടാൽ 0 നൽകുന്നു
char *strchr(const char *s, int c);	ഒരു പ്രതീകത്തിന്റെ ആദ്യ സംഭവത്തിലേക്ക് ഒരു പോയിന്റർ നൽകുന്നു സിചൂണ്ടിക്കാണിച്ച വരിയിലേക്ക് എസ്. ചിഹ്നമാണെങ്കിൽ സികണ്ടെത്തിയില്ല, NULL നൽകുന്നു
char *strupr(char *s)	s കൊണ്ട് ചൂണ്ടിക്കാണിച്ച സ്ട്രിംഗിലെ പ്രതീകങ്ങളെ വലിയക്ഷര പ്രതീകങ്ങളാക്കി മാറ്റുകയും അത് തിരികെ നൽകുകയും ചെയ്യുന്നു

സ്ട്രിംഗ് ഡാറ്റ തരം

പ്രതീകങ്ങളുടെ ഒരു നിരയായി സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിന് പുറമേ, C++ ൽ ഒരു പ്രത്യേക ഡാറ്റാ തരം ഉണ്ട് സ്ട്രിംഗ്. ഈ തരത്തിലുള്ള വേരിയബിളുകൾ നൽകാൻ നിങ്ങൾക്ക് ഉപയോഗിക്കാം സിൻ, അല്ലെങ്കിൽ പ്രത്യേക പ്രവർത്തനം ഗെറ്റ്ലൈൻ.

ഗെറ്റ്ലൈൻ(സിൻ, എസ്);

ഇവിടെ എസ്- ഇൻപുട്ട് തരം വേരിയബിളിന്റെ പേര് സ്ട്രിംഗ്.

ഈ തരത്തിലുള്ള ഒരു വേരിയബിൾ നിങ്ങൾ നിർവചിക്കുമ്പോൾ, നിങ്ങൾക്ക് ആ വേരിയബിളിന് ഉടൻ ഒരു മൂല്യം നൽകാം.

സ്ട്രിംഗ് var (കൾ);

ഇവിടെ var- വേരിയബിൾ പേര്, എസ്- സ്ട്രിംഗ് സ്ഥിരാങ്കം. ഈ പ്രസ്താവനയുടെ ഫലമായി, ഒരു വേരിയബിൾ സൃഷ്ടിക്കപ്പെടുന്നു varതരം സ്ട്രിംഗ്, കൂടാതെ സ്ട്രിംഗ് സ്ഥിരാങ്കത്തിന്റെ മൂല്യം അതിൽ എഴുതിയിരിക്കുന്നു എസ്. ഉദാഹരണത്തിന്,

സ്ട്രിംഗ് v("ഹലോ");

ഒരു സ്ട്രിംഗ് സൃഷ്ടിച്ചു വി, അതിൽ മൂല്യം എഴുതിയിരിക്കുന്നു ഹലോ.

ആക്സസ്സ് i-thലൈൻ ഘടകം എസ്തരം സ്ട്രിംഗ്ഒരു സാധാരണ രീതിയിൽ നടപ്പിലാക്കി s[i]. തുടങ്ങിയ വരികൾക്ക് മുകളിൽ സ്ട്രിംഗ്ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ നിർവചിച്ചിരിക്കുന്നു:

• അസൈൻമെന്റുകൾ, ഉദാഹരണത്തിന് s1=s2;
• സ്ട്രിംഗുകൾ കൂട്ടിച്ചേർക്കുന്നു (s1+=s2 അല്ലെങ്കിൽ s1=s1+s2) - സ്ട്രിംഗ് s1-ലേക്ക് സ്ട്രിംഗ് s2 ചേർക്കുന്നു, ഫലം സ്ട്രിംഗ് s1-ൽ സംഭരിക്കുന്നു, സ്ട്രിംഗുകൾ സംയോജിപ്പിക്കുന്നതിനുള്ള ഉദാഹരണം:

• ലെക്സിക്കോഗ്രാഫിക് ക്രമത്തെ അടിസ്ഥാനമാക്കിയുള്ള സ്ട്രിംഗ് താരതമ്യങ്ങൾ: s1=s2, s1!=s2, s1 s2, s1<=s2, s1>=s2 - ഫലം ഒരു ലോജിക്കൽ മൂല്യമായിരിക്കും;

പോലുള്ള സ്ട്രിംഗുകൾ പ്രോസസ്സ് ചെയ്യുമ്പോൾ സ്ട്രിംഗ്ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കാം:

• s.substr(pos, ദൈർഘ്യം)- ഒരു സ്‌ട്രിംഗിൽ നിന്ന് ഒരു സബ്‌സ്‌ട്രിംഗ് തിരികെ നൽകുന്നു എസ്, നമ്പറിൽ നിന്ന് ആരംഭിക്കുന്നു പോസ്നീളമുള്ള നീളംകഥാപാത്രങ്ങൾ;
• s.empty()- സ്ട്രിംഗ് ശരിയാണെങ്കിൽ തിരികെ നൽകുന്നു എസ്ശൂന്യം, തെറ്റ് - അല്ലാത്തപക്ഷം;
• s.insert(pos, s1)- ഒരു വരി ചേർക്കുന്നു s1വരിയിലേക്ക് എസ്, സ്ഥാനത്ത് നിന്ന് ആരംഭിക്കുന്നു പോസ്;
• s.remove(pos, നീളം)- ഒരു വരിയിൽ നിന്ന് ഇല്ലാതാക്കുന്നു എസ്സബ്സ്ട്രിംഗ് നീളംനീളമുള്ള പോസ്കഥാപാത്രങ്ങൾ;
• s.find(s1, pos)- ഒരു സ്ട്രിംഗിന്റെ ആദ്യ സംഭവത്തിന്റെ എണ്ണം നൽകുന്നു s1വരിയിലേക്ക് എസ്, തിരയൽ ആരംഭിക്കുന്നത് നമ്പറിൽ നിന്നാണ് പോസ്, പരാമീറ്റർ പോസ്ഇല്ലായിരിക്കാം, ഈ സാഹചര്യത്തിൽ തിരച്ചിൽ വരിയുടെ തുടക്കം മുതൽ ആരംഭിക്കുന്നു;
• s.findfirst(s1, pos)- ഒരു സ്ട്രിംഗിൽ നിന്ന് ഏതെങ്കിലും പ്രതീകത്തിന്റെ ആദ്യ സംഭവത്തിന്റെ എണ്ണം നൽകുന്നു s1വരിയിലേക്ക് എസ്, തിരയൽ ആരംഭിക്കുന്നത് നമ്പറിൽ നിന്നാണ് പോസ്, നഷ്ടപ്പെട്ടിരിക്കാം.

സ്ട്രിംഗുകൾക്കുള്ള റഷ്യൻ ഭാഷ

റഷ്യൻ അക്ഷരങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യുമ്പോൾ, "ഇടത്" പ്രതീകങ്ങൾ കൺസോളിൽ ദൃശ്യമാകുന്നത് നിങ്ങൾ ഇതിനകം ശ്രദ്ധിച്ചിട്ടുണ്ടെന്ന് ഞാൻ കരുതുന്നു. ഈ തെറ്റിദ്ധാരണ ഒഴിവാക്കാൻ, നിങ്ങൾ ഒരു മൂന്നാം കക്ഷി ഫംഗ്ഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട് CharToOemA. ലൈബ്രറി ബന്ധിപ്പിക്കുന്നു windows.h, ഞങ്ങളുടെ ഫംഗ്‌ഷന് സ്‌ട്രിംഗുകളെ മറ്റൊരു എൻകോഡിംഗിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ഇത് ആവശ്യമാണ്. കൂടാതെ, ഞങ്ങൾക്ക് ഒരു അധിക പ്രതീക ശ്രേണി ആവശ്യമാണ്. പ്രോഗ്രാമിന്റെ സോഴ്സ് കോഡ് ഇതുപോലെ കാണപ്പെടും:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#"stdafx.h" ഉൾപ്പെടുത്തുക #ഉൾപ്പെടുന്നു #ഉൾപ്പെടുന്നു നെയിംസ്പേസ് എസ്ടിഡി ഉപയോഗിക്കുന്നു; int main() (setlocale(LC_ALL, "Rus" ); പ്രതീകങ്ങൾ [255 ] = ( "ഞാൻ രൂപാന്തരപ്പെടണം"} ; char * pre= new char [255] ; CharToOemA(കൾ, പ്രീ) ; //മാറ്റുക കട്ട്<< s; മുൻകൂട്ടി ഇല്ലാതാക്കുക; സിസ്റ്റം ("താൽക്കാലികമായി നിർത്തുക>>അസാധു"); തിരികെ 0; }

ഇപ്പോൾ വിവരിച്ച രീതി തികച്ചും അസൗകര്യമാണ്. എന്നാൽ "റഷ്യൻ" പ്രശ്നത്തിന് ലളിതമായ ഒരു പരിഹാരമുണ്ട്. നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, പ്രോഗ്രാം setlocale() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു; പകരം, പ്രധാന ഫംഗ്ഷനിൽ ഇനിപ്പറയുന്ന നിർമ്മാണം ഉൾപ്പെടുത്തുന്നത് കൂടുതൽ സൗകര്യപ്രദമാണ്.

ഈ പാഠത്തിൽ ഞങ്ങൾ സി-സ്റ്റൈൽ സ്ട്രിംഗുകളെ കുറിച്ച് ചർച്ച ചെയ്യും; ഞങ്ങളുടെ വെബ്സൈറ്റിലോ മറ്റേതെങ്കിലും പാഠപുസ്തകത്തിലോ നിങ്ങൾ ഈ സ്ട്രിംഗുകൾ ഇതിനകം കണ്ടിരിക്കാം. വാസ്തവത്തിൽ, സി-സ്ട്രിംഗുകൾ പ്രതീകങ്ങളുടെ നിരകൾ മാത്രമാണ്, എന്നാൽ അവയുടെ സ്വന്തം പ്രത്യേകതകളോടെ, വരിയുടെ അവസാനം എവിടെയാണെന്ന് നമുക്ക് എപ്പോഴും അറിയാം. ഈ ലേഖനത്തിൽ ഞങ്ങൾ സ്ട്രിംഗുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള നിരവധി ഫംഗ്ഷനുകൾ നോക്കും, ഉദാഹരണത്തിന്, നിങ്ങൾ - പകർത്തുക, കൂട്ടിച്ചേർക്കുക, ഒരു സ്ട്രിംഗിന്റെ ദൈർഘ്യം നേടുക.

എന്താണ് സ്ട്രിംഗുകൾ?

അടിസ്ഥാനപരമായി ലളിതമായ അറേകളായ സി-സ്റ്റൈൽ സ്ട്രിംഗുകൾക്കൊപ്പം, ഈ "ലിറ്ററൽ" പോലുള്ള സ്ട്രിംഗ് ലിറ്ററലുകളും ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക. വാസ്തവത്തിൽ, സ്ട്രിംഗുകളും ലിറ്ററലുകളും കമ്പ്യൂട്ടറിന്റെ മെമ്മറിയിൽ അടുത്തടുത്തായി സ്ഥിതിചെയ്യുന്ന പ്രതീകങ്ങളുടെ ഒരു കൂട്ടമാണ്. എന്നാൽ അറേകളും ലിറ്ററലുകളും തമ്മിൽ ഇപ്പോഴും വ്യത്യാസമുണ്ട്: ലിറ്ററലുകൾ മാറ്റാൻ കഴിയില്ല, സ്ട്രിംഗുകൾക്ക് കഴിയും.

ഒരു സി-സ്റ്റൈൽ സ്ട്രിംഗ് എടുക്കുന്ന ഏതൊരു ഫംഗ്ഷനും അക്ഷരത്തെ ഒരു പാരാമീറ്ററായി എടുക്കാം. സിയിൽ ചില എന്റിറ്റികൾ ഉണ്ട്, അവ യഥാർത്ഥത്തിൽ അല്ലാത്തപ്പോൾ സ്ട്രിംഗുകൾ പോലെ കാണപ്പെടുന്നു. ഞാൻ ഇപ്പോൾ പ്രതീകങ്ങളെക്കുറിച്ചാണ് സംസാരിക്കുന്നത്, അവ ഒറ്റ ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, ഇതാ ഒരു ഉദാഹരണം - "a", നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഇതൊരു സ്ട്രിംഗ് അല്ല. ഒരു പ്രത്യേക സ്ഥലത്ത് ഒരു പ്രതീകം ഒരു സ്‌ട്രിംഗിലേക്ക് അസൈൻ ചെയ്യാൻ കഴിയും, എന്നാൽ പ്രതീകങ്ങൾ ഒരു സ്ട്രിംഗ് ആയി പ്രോസസ്സ് ചെയ്യാൻ കഴിയില്ല. നിങ്ങൾ ഓർക്കുന്നുവെങ്കിൽ, അറേകൾ പോയിന്ററുകൾ പോലെയാണ് പ്രവർത്തിക്കുന്നത്, അതിനാൽ നിങ്ങൾ ഒരു സ്ട്രിംഗിലേക്ക് ഒരൊറ്റ പ്രതീകം നൽകിയാൽ, അത് ഒരു പിശകായി കണക്കാക്കും.

മുകളിൽ പറഞ്ഞവയിൽ നിന്ന്, സ്ട്രിംഗുകൾ പ്രതീകങ്ങളുടെ നിരകളാണെന്നും സ്ട്രിംഗ് ലിറ്ററലുകൾ ഇരട്ട ഉദ്ധരണികളാൽ ചുറ്റപ്പെട്ട വാക്കുകളാണെന്നും നിങ്ങൾ മനസ്സിലാക്കിയിരിക്കണം. അക്ഷരാർത്ഥത്തിൽ മറ്റൊരു ഉദാഹരണം ഇതാ:

"ഇതൊരു സ്റ്റാറ്റിക് സ്ട്രിംഗ് ആണ്"

അൽപ്പം ഉയരത്തിൽ സൂചിപ്പിച്ച സ്ട്രിംഗുകളുടെ പ്രത്യേകത നിങ്ങൾ മറന്നോ? അതിനാൽ, C-സ്ട്രിംഗുകൾ എല്ലായ്പ്പോഴും ഒരു ശൂന്യ പ്രതീകത്തിൽ അവസാനിക്കണം, അക്ഷരാർത്ഥത്തിൽ "\0". അതിനാൽ, 49 അക്ഷരങ്ങൾ അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് പ്രഖ്യാപിക്കാൻ, നിങ്ങൾ ശൂന്യ പ്രതീകത്തിനായി ഒരു അധിക സെൽ റിസർവ് ചെയ്യേണ്ടതുണ്ട്:

Char myString;

ഉദാഹരണത്തിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, അറേയുടെ ദൈർഘ്യം 50 പ്രതീകങ്ങളാണ്, അതിൽ 49 എണ്ണം ഒരു വരിയും ഒരെണ്ണം ആയിരിക്കും, അവസാനത്തേത് ഒരു ശൂന്യ പ്രതീകമായിരിക്കും. ഓരോ വാക്യത്തിന്റെയും അവസാനത്തിൽ ഒരു പിരീഡ് ഉള്ളതുപോലെ, സി-ലൈനുകളുടെ അവസാനത്തിൽ എല്ലായ്പ്പോഴും ഒരു ശൂന്യ പ്രതീകം ഉണ്ടായിരിക്കണം എന്നത് ഓർത്തിരിക്കേണ്ടത് പ്രധാനമാണ്. സ്ട്രിംഗ് ഔട്ട്പുട്ട് ചെയ്യുമ്പോൾ നൾ പ്രതീകം ദൃശ്യമാകില്ലെങ്കിലും, അത് മെമ്മറിയിൽ ഇടം പിടിക്കുന്നു. സാങ്കേതികമായി, അമ്പത് മൂലകങ്ങളുടെ ഒരു നിരയിൽ, നിങ്ങൾക്ക് 49 അക്ഷരങ്ങൾ മാത്രമേ സംഭരിക്കാൻ കഴിയൂ, കാരണം സ്ട്രിംഗ് അവസാനിപ്പിക്കാൻ അവസാന പ്രതീകം ആവശ്യമാണ്. കൂടാതെ, പോയിന്ററുകൾ ഒരു സ്ട്രിംഗായി ഉപയോഗിക്കാനും കഴിയും. എന്നതിനെക്കുറിച്ചുള്ള ലേഖനം നിങ്ങൾ വായിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഇതുപോലൊന്ന് ചെയ്യാൻ കഴിയും:

ചാർ *myString; // ചാർ ടൈപ്പ് പോയിന്റർ myString = malloc(sizeof(*myString) * 64); // മെമ്മറി അലോക്കേഷൻ

ഈ ഉദാഹരണത്തിൽ, myString അറേയ്‌ക്കായി ഞങ്ങൾ 64 മെമ്മറി ലൊക്കേഷനുകൾ അനുവദിച്ചു. മെമ്മറി സ്വതന്ത്രമാക്കാൻ, free() ഫംഗ്ഷൻ ഉപയോഗിക്കുക.

ഫ്രീ(myString);

സ്ട്രിംഗുകൾ ഉപയോഗിക്കുന്നു

ടെക്സ്റ്റ് വിവരങ്ങളിൽ നിങ്ങൾക്ക് വിവിധ പ്രവർത്തനങ്ങൾ നടത്തേണ്ടിവരുമ്പോൾ സ്ട്രിംഗുകൾ ഉപയോഗപ്രദമാണ്. ഉദാഹരണത്തിന്, ഒരു പ്രോഗ്രാമിലേക്ക് ഉപയോക്താവ് ഒരു പേര് നൽകണമെങ്കിൽ, നിങ്ങൾ ഒരു സ്ട്രിംഗ് ഉപയോഗിക്കും. ഒരു സ്‌ട്രിംഗ് ഇൻപുട്ട് ചെയ്യുന്നതിന് scanf() ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നത് പ്രവർത്തിക്കുന്നു, പക്ഷേ ഒരു ബഫർ ഓവർഫ്ലോക്ക് കാരണമായേക്കാം. എല്ലാത്തിനുമുപരി, ഇൻപുട്ട് സ്ട്രിംഗ് ബഫർ സ്ട്രിംഗിന്റെ വലുപ്പത്തേക്കാൾ വലുതായിരിക്കാം. ഈ പ്രശ്നം പരിഹരിക്കാൻ നിരവധി മാർഗങ്ങളുണ്ട്, എന്നാൽ ഏറ്റവും ലളിതമായ മാർഗ്ഗം ഉപയോഗിക്കുക എന്നതാണ്, അത് ഹെഡർ ഫയലിൽ പ്രഖ്യാപിച്ചിരിക്കുന്നു .

ഉപയോക്താവിൽ നിന്നുള്ള ഇൻപുട്ട് വായിക്കുമ്പോൾ, അവസാനത്തേത് ഒഴികെയുള്ള എല്ലാ പ്രതീകങ്ങളും അത് വായിക്കും. അതിനുശേഷം, റീഡ് ലൈനിന്റെ അവസാനം ഒരു സീറോ ടെർമിനേറ്റർ സ്ഥാപിക്കും. ഉപയോക്താവ് എന്റർ അമർത്തുന്നത് വരെ fgets() ഫംഗ്ഷൻ പ്രതീകങ്ങൾ വായിക്കും. fgets() ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം നോക്കാം:

#ഉൾപ്പെടുന്നു int main() (char myString; // long string printf("ഒരു നീണ്ട സ്ട്രിംഗ് നൽകുക: "); fgets(myString, 100, stdin); // ഇൻപുട്ട് സ്ട്രീം printf-ൽ നിന്നുള്ള സ്ട്രിംഗ് വായിക്കുക("നിങ്ങൾ ഇനിപ്പറയുന്ന സ്ട്രിംഗ് നൽകി: %s", myString); getchar(); )

fgets() എന്നതിലേക്കുള്ള ആദ്യ പരാമീറ്റർ ഒരു സ്ട്രിംഗ് ആണ്, രണ്ടാമത്തെ പരാമീറ്റർ സ്ട്രിംഗിന്റെ വലുപ്പമാണ്, മൂന്നാമത്തെ പരാമീറ്റർ ഇൻപുട്ട് ഡാറ്റ സ്ട്രീമിലേക്കുള്ള ഒരു പോയിന്ററാണ്.

പ്രോഗ്രാമിന്റെ ഫലം:

<ВВОД>...

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, പ്രോഗ്രാം ഔട്ട്പുട്ടിൽ നിന്ന്, ഒരു പുതിയ ലൈൻ പ്രതീകം - "\n" - ഇൻപുട്ട് ലൈനിൽ പ്രവേശിച്ചു. fgets() സ്ട്രിംഗ് myString-ലേക്ക് എന്റർ ബട്ടൺ അമർത്തി അതിന്റെ ജോലി പൂർത്തിയാക്കിയതിനാലാണ് ഇത് സംഭവിച്ചത്. ഇതിനർത്ഥം നിങ്ങൾ പുതിയ ലൈൻ പ്രതീകം സ്വമേധയാ നീക്കം ചെയ്യേണ്ടതായി വരാം എന്നാണ്. ഇതിനുള്ള ഒരു മാർഗ്ഗം പ്രതീകം-കഥാപാത്രങ്ങളുടെ എണ്ണലാണ്. നമുക്ക് പ്രോഗ്രാം പരിഷ്ക്കരിച്ച് പുതിയ ലൈൻ പ്രതീകം നീക്കം ചെയ്യാം:

#ഉൾപ്പെടുന്നു int main() (char myString; // long string printf("ഒരു നീണ്ട സ്ട്രിംഗ് നൽകുക: "); fgets(myString, 100, stdin); // int i എന്ന ഇൻപുട്ട് സ്ട്രീമിൽ നിന്ന് ഒരു സ്ട്രിംഗ് വായിക്കുക; (i = 0; ഐ< 100; i++) { if (myString[i] == "\n") { myString[i] = "\0"; break; } } printf("Вы ввели следующую строку: %s", myString); getchar(); }

ഇൻപുട്ട് സ്‌ട്രിംഗിൽ 100 ​​പ്രതീകങ്ങളിൽ കുറവുണ്ടെങ്കിൽ, സ്‌ട്രിംഗിൽ ഒരു പുതിയ ലൈൻ പ്രതീകവും ഉൾപ്പെടുത്തും. അതിനാൽ, ലളിതമായ ബ്രൂട്ട് ഫോഴ്‌സ് ഉപയോഗിച്ച് നമുക്ക് ഈ പ്രതീകം നീക്കംചെയ്യാം. പ്രോഗ്രാമിലേക്ക് ഞങ്ങൾ ഒരു ലൂപ്പ് ചേർത്തു, അതിൽ സ്ട്രിംഗിന്റെ പ്രതീകങ്ങളിലൂടെ ഞങ്ങൾ ലൂപ്പ് ചെയ്യുന്നു, വരികൾ 12-19. ഒരു ന്യൂലൈൻ പ്രതീകം കണ്ടുമുട്ടുമ്പോൾ, ഞങ്ങൾ അതിനെ ഒരു ശൂന്യ പ്രതീകം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു, വരി 16. പ്രോഗ്രാമിന്റെ ഫലം:

ഒരു നീണ്ട വരി നൽകുക: വിധി അതിന്റെ അടയാളം വിടുന്നു നിങ്ങൾ ഇനിപ്പറയുന്ന വരി നൽകി: വിധി അതിന്റെ അടയാളം വിടുന്നു ഈ വിൻഡോ അടയ്‌ക്കാൻ, ക്ലിക്കുചെയ്യുക<ВВОД>...

ഇപ്പോഴത്തേക്ക് ഇത്രമാത്രം. അടുത്ത ലേഖനത്തിൽ സ്ട്രിംഗുകളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള പ്രത്യേക പ്രവർത്തനങ്ങളെക്കുറിച്ച് ഞാൻ നിങ്ങളോട് പറയും.

P.S.: നമ്മൾ എല്ലാവരും വ്യത്യസ്ത വീഡിയോ റെക്കോർഡിംഗുകൾ കാണാൻ ഇഷ്ടപ്പെടുന്നു, എന്നാൽ ചിലപ്പോൾ ചില വീഡിയോ ഫയൽ ഫോർമാറ്റുകൾ പ്ലേ ചെയ്യുന്നത് എല്ലായ്പ്പോഴും സാധ്യമല്ല. അതിനാൽ, പ്രോഗ്രാം ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ പ്രശ്നം പരിഹരിക്കാൻ കഴിയും - xilisoft converter ultimate. നിങ്ങൾക്ക് വീഡിയോകൾ ഒരു ഫോർമാറ്റിൽ നിന്ന് മറ്റൊന്നിലേക്ക് എളുപ്പത്തിൽ പരിവർത്തനം ചെയ്യാൻ കഴിയും. കൂടാതെ, ഈ പ്രോഗ്രാമിന് ഓഡിയോ ഫയലുകളും ആനിമേറ്റഡ് ചിത്രങ്ങളും പരിവർത്തനം ചെയ്യാൻ കഴിയും.

ഈ സൈറ്റിലെ AdBlock താൽക്കാലികമായി നിർത്തുക.

അതിനാൽ, സി ഭാഷയിൽ സ്ട്രിംഗുകൾ. മറ്റ് പല പ്രോഗ്രാമിംഗ് ഭാഷകളിലും ചെയ്യുന്നത് പോലെ അവയ്‌ക്കായി പ്രത്യേക ഡാറ്റ തരമില്ല. സിയിൽ, ഒരു സ്ട്രിംഗ് എന്നത് പ്രതീകങ്ങളുടെ ഒരു നിരയാണ്. ഒരു വരിയുടെ അവസാനം അടയാളപ്പെടുത്തുന്നതിന്, ഈ പാഠത്തിന്റെ അവസാന ഭാഗത്ത് ഞങ്ങൾ ചർച്ച ചെയ്ത "\0" പ്രതീകം ഉപയോഗിക്കുന്നു. ഇത് ഒരു തരത്തിലും സ്ക്രീനിൽ പ്രദർശിപ്പിക്കാത്തതിനാൽ നിങ്ങൾക്ക് അത് നോക്കാൻ കഴിയില്ല.

ഒരു സ്ട്രിംഗ് സൃഷ്ടിക്കുകയും ആരംഭിക്കുകയും ചെയ്യുന്നു

ഒരു സ്ട്രിംഗ് പ്രതീകങ്ങളുടെ ഒരു നിരയായതിനാൽ, ഒരു സ്ട്രിംഗ് പ്രഖ്യാപിക്കുന്നതും സമാരംഭിക്കുന്നതും ഏകമാന ശ്രേണികളുള്ള സമാന പ്രവർത്തനങ്ങൾക്ക് സമാനമാണ്.

സ്ട്രിംഗുകൾ സമാരംഭിക്കുന്നതിനുള്ള വ്യത്യസ്ത വഴികൾ ഇനിപ്പറയുന്ന കോഡ് വ്യക്തമാക്കുന്നു.

പട്ടിക 1.

ചാർ str; char str1 = ("Y","o","n","g","C","o","d","e","r","\0"); char str2 = "ഹലോ!"; char str3 = "ഹലോ!";

ചിത്രം.1 സ്ട്രിംഗുകളുടെ പ്രഖ്യാപനവും സമാരംഭവും

ആദ്യ വരിയിൽ ഞങ്ങൾ പത്ത് പ്രതീകങ്ങളുടെ ഒരു ശ്രേണി പ്രഖ്യാപിക്കുന്നു. ഇത് ശരിക്കും ഒരു ചരട് പോലുമല്ല, കാരണം... അതിൽ null പ്രതീകം \0 ഇല്ല, ഇപ്പോൾ ഇത് ഒരു കൂട്ടം പ്രതീകങ്ങൾ മാത്രമാണ്.

രണ്ടാമത്തെ വരി. നേരിട്ട് ആരംഭിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതമായ മാർഗം. ഞങ്ങൾ ഓരോ ചിഹ്നവും പ്രത്യേകം പ്രഖ്യാപിക്കുന്നു. ഇവിടെ പ്രധാന കാര്യം ശൂന്യമായ പ്രതീകം \0 ചേർക്കാൻ മറക്കരുത് എന്നതാണ്.

മൂന്നാമത്തെ വരി രണ്ടാമത്തെ വരിയുമായി സാമ്യമുള്ളതാണ്. ചിത്രത്തിൽ ശ്രദ്ധിക്കുക. കാരണം അറേയിലെ ഘടകങ്ങളേക്കാൾ വലതുവശത്തുള്ള വരിയിൽ കുറച്ച് പ്രതീകങ്ങൾ മാത്രമേ ഉള്ളൂ, ശേഷിക്കുന്ന ഘടകങ്ങൾ \0 കൊണ്ട് നിറയും.

നാലാമത്തെ വരി. നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഇവിടെ വലുപ്പമൊന്നും വ്യക്തമാക്കിയിട്ടില്ല. പ്രോഗ്രാം അത് യാന്ത്രികമായി കണക്കാക്കുകയും ആവശ്യമായ ദൈർഘ്യമുള്ള പ്രതീകങ്ങളുടെ ഒരു നിര സൃഷ്ടിക്കുകയും ചെയ്യും. ഈ സാഹചര്യത്തിൽ, ശൂന്യ പ്രതീകം \0 അവസാനം ചേർക്കും.

ഒരു സ്ട്രിംഗ് എങ്ങനെ ഔട്ട്പുട്ട് ചെയ്യാം

സ്‌ക്രീനിൽ സൃഷ്ടിച്ച വരികൾ പ്രദർശിപ്പിക്കുന്ന ഒരു പൂർണ്ണ പ്രോഗ്രാമിലേക്ക് മുകളിലുള്ള കോഡ് വികസിപ്പിക്കാം.

പട്ടിക 2.

#ഉൾപ്പെടുന്നു int main(ശൂന്യം) ( char str; char str1 = ("Y","o","n","g","C","o","d","e","r"," \0"); char str2 = "ഹലോ!"; char str3 = "ഹലോ!"; for(int i = 0; i< 10; i = i + 1) printf("%c\t",str[i]); printf("\n"); puts(str1); printf("%s\n",str2); puts(str3); return 0; }

Fig.2 സ്ക്രീനിൽ ഒരു സ്ട്രിംഗ് പ്രദർശിപ്പിക്കുന്നതിനുള്ള വിവിധ വഴികൾ

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, സ്ക്രീനിൽ ഒരു സ്ട്രിംഗ് പ്രദർശിപ്പിക്കുന്നതിന് നിരവധി അടിസ്ഥാന മാർഗങ്ങളുണ്ട്.

• %s സ്പെസിഫയർ ഉപയോഗിച്ച് printf ഫംഗ്ഷൻ ഉപയോഗിക്കുക
• പുട്ട് ഫംഗ്ഷൻ ഉപയോഗിക്കുക
• fputs ഫംഗ്‌ഷൻ ഉപയോഗിക്കുക, ഔട്ട്‌പുട്ടിനുള്ള സ്റ്റാൻഡേർഡ് സ്ട്രീം രണ്ടാമത്തെ പാരാമീറ്ററായി stdout ആയി വ്യക്തമാക്കുന്നു.

പുട്ട്, എഫ്പുട്ട് ഫംഗ്‌ഷനുകൾ മാത്രമാണ് ന്യൂനൻസ്. പുട്ട് ഫംഗ്‌ഷൻ ഔട്ട്‌പുട്ടിനെ അടുത്ത വരിയിലേക്ക് പൊതിയുന്നു, എന്നാൽ fputs ഫംഗ്‌ഷൻ അങ്ങനെ ചെയ്യുന്നില്ല.

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, നിഗമനം വളരെ ലളിതമാണ്.

സ്ട്രിംഗുകൾ പ്രവേശിക്കുന്നു

സ്ട്രിംഗ് ഇൻപുട്ട് ഔട്ട്പുട്ടിനെക്കാൾ അൽപ്പം സങ്കീർണ്ണമാണ്. ഏറ്റവും ലളിതമായ മാർഗ്ഗം ഇനിപ്പറയുന്നതായിരിക്കും:

പട്ടിക 3.

#ഉൾപ്പെടുന്നു int main(void) (char str; gets(str); puts(str); തിരികെ 0; )

ഗെറ്റ്സ് ഫംഗ്ഷൻ പ്രോഗ്രാമിനെ താൽക്കാലികമായി നിർത്തുന്നു, കീബോർഡിൽ നിന്ന് നൽകിയ പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗ് വായിക്കുകയും ഒരു പ്രതീക ശ്രേണിയിൽ സ്ഥാപിക്കുകയും ചെയ്യുന്നു, അതിന്റെ പേര് ഫംഗ്ഷനിലേക്ക് ഒരു പാരാമീറ്ററായി കൈമാറുന്നു.
എന്റർ കീയുമായി ബന്ധപ്പെട്ട പ്രതീകം ഉപയോഗിച്ച് ഗെറ്റ്സ് ഫംഗ്ഷൻ അവസാനിക്കുകയും സ്ട്രിംഗിൽ ഒരു ശൂന്യ പ്രതീകമായി എഴുതുകയും ചെയ്യുന്നു.
അപകടം ശ്രദ്ധിച്ചോ? ഇല്ലെങ്കിൽ, കംപൈലർ അതിനെക്കുറിച്ച് ദയയോടെ നിങ്ങൾക്ക് മുന്നറിയിപ്പ് നൽകും. ഉപയോക്താവ് എന്റർ അമർത്തുമ്പോൾ മാത്രമേ ഗെറ്റ്സ് ഫംഗ്ഷൻ പുറത്തുകടക്കുകയുള്ളൂ എന്നതാണ് പ്രശ്നം. ഞങ്ങളുടെ കാര്യത്തിൽ - 20-ൽ കൂടുതൽ പ്രതീകങ്ങൾ നൽകിയാൽ, നമുക്ക് അറേയ്ക്ക് അപ്പുറത്തേക്ക് പോകാം എന്ന വസ്തുത ഇത് നിറഞ്ഞതാണ്.
വഴിയിൽ, ബഫർ ഓവർഫ്ലോ പിശകുകൾ മുമ്പ് ഏറ്റവും സാധാരണമായ അപകടസാധ്യതയായി കണക്കാക്കപ്പെട്ടിരുന്നു. അവ ഇന്നും കാണപ്പെടുന്നു, പക്ഷേ പ്രോഗ്രാമുകൾ ഹാക്ക് ചെയ്യാൻ അവ ഉപയോഗിക്കുന്നത് വളരെ ബുദ്ധിമുട്ടാണ്.

അപ്പോൾ നമുക്ക് എന്താണ് ഉള്ളത്? ഞങ്ങൾക്ക് ഒരു ടാസ്‌ക് ഉണ്ട്: പരിമിതമായ വലുപ്പമുള്ള ഒരു ശ്രേണിയിലേക്ക് ഒരു സ്ട്രിംഗ് എഴുതുക. അതായത്, ഉപയോക്താവ് നൽകിയ പ്രതീകങ്ങളുടെ എണ്ണം ഞങ്ങൾ എങ്ങനെയെങ്കിലും നിയന്ത്രിക്കണം. ഇവിടെ fgets ഫംഗ്ഷൻ ഞങ്ങളുടെ സഹായത്തിന് വരുന്നു:

പട്ടിക 4.

#ഉൾപ്പെടുന്നു int main(void) (char str; fgets(str, 10, stdin); puts(str); റിട്ടേൺ 0; )

fgets ഫംഗ്‌ഷൻ ഇൻപുട്ടായി മൂന്ന് ആർഗ്യുമെന്റുകൾ എടുക്കുന്നു: സ്‌ട്രിംഗ് എഴുതാനുള്ള വേരിയബിൾ, എഴുതേണ്ട സ്‌ട്രിംഗിന്റെ വലുപ്പം, സ്‌ട്രിംഗിലേക്ക് ഡാറ്റ എഴുതാനുള്ള സ്‌ട്രീമിന്റെ പേര്, ഈ സാഹചര്യത്തിൽ stdin. പാഠം 3-ൽ നിന്ന് നിങ്ങൾക്ക് ഇതിനകം അറിയാവുന്നതുപോലെ, കീബോർഡുമായി സാധാരണയായി ബന്ധപ്പെട്ടിരിക്കുന്ന സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് സ്ട്രീം ആണ് stdin. ഡാറ്റ stdin സ്ട്രീമിൽ നിന്ന് വരണമെന്നത് ഒട്ടും ആവശ്യമില്ല; ഭാവിയിൽ ഫയലുകളിൽ നിന്നുള്ള ഡാറ്റ വായിക്കാനും ഞങ്ങൾ ഈ ഫംഗ്ഷൻ ഉപയോഗിക്കും.

ഈ പ്രോഗ്രാമിന്റെ നിർവ്വഹണ വേളയിൽ നമ്മൾ 10 പ്രതീകങ്ങളേക്കാൾ ദൈർഘ്യമുള്ള ഒരു സ്ട്രിംഗ് നൽകുകയാണെങ്കിൽ, ആദ്യം മുതൽ 9 പ്രതീകങ്ങൾ മാത്രം, ഒരു ലൈൻ ബ്രേക്ക് ഇപ്പോഴും അറേയിൽ എഴുതപ്പെടും, fgets ആവശ്യമായ ദൈർഘ്യത്തിലേക്ക് സ്ട്രിംഗ് "മുറിക്കും".

fgets ഫംഗ്‌ഷൻ 10 പ്രതീകങ്ങൾ വായിക്കുന്നില്ലെന്നത് ശ്രദ്ധിക്കുക, 9! ഞങ്ങൾ ഓർക്കുന്നതുപോലെ, സ്ട്രിംഗുകളിൽ അവസാനത്തെ പ്രതീകം ശൂന്യ പ്രതീകത്തിനായി നീക്കിവച്ചിരിക്കുന്നു.

നമുക്ക് അത് പരിശോധിക്കാം. അവസാന ലിസ്റ്റിംഗിൽ നിന്ന് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാം. 1234567890 എന്ന വരി നൽകുക. 123456789 എന്ന ലൈൻ സ്ക്രീനിൽ ദൃശ്യമാകും.

ചിത്രം 3 fgets ഫംഗ്‌ഷന്റെ ഉദാഹരണം

എന്ന ചോദ്യം ഉയരുന്നു. പത്താമത്തെ കഥാപാത്രം എവിടെ പോയി? ഞാൻ ഉത്തരം പറയും. ഇത് എവിടെയും പോയിട്ടില്ല, അത് ഇൻപുട്ട് സ്ട്രീമിൽ തന്നെ തുടരുന്നു. ഇനിപ്പറയുന്ന പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക.

പട്ടിക 5.

#ഉൾപ്പെടുന്നു int main(void) (char str; fgets(str, 10, stdin); puts(str); int h = 99; printf("do %d\n", h); scanf("%d",&h) ; printf("%d\n ന് ശേഷം", h); തിരികെ 0; )

അവളുടെ ജോലിയുടെ ഫലം ഇതാ.

ചിത്രം.4 ശൂന്യമല്ലാത്ത stdin ബഫർ

എന്താണ് സംഭവിച്ചതെന്ന് ഞാൻ വിശദീകരിക്കാം. ഞങ്ങൾ fgets ഫംഗ്‌ഷനെ വിളിച്ചു. അവൾ ഇൻപുട്ട് സ്ട്രീം തുറന്ന് ഞങ്ങൾ ഡാറ്റ നൽകുന്നതിനായി കാത്തിരുന്നു. ഞങ്ങൾ കീബോർഡിൽ നിന്ന് 1234567890\n നൽകി (\n എന്റർ കീ അമർത്തുക എന്നാണ് ഞാൻ അർത്ഥമാക്കുന്നത്). ഇത് stdin ഇൻപുട്ട് സ്ട്രീമിലേക്ക് പോയി. fgets ഫംഗ്‌ഷൻ, പ്രതീക്ഷിച്ചതുപോലെ, ഇൻപുട്ട് സ്ട്രീമിൽ നിന്ന് ആദ്യത്തെ 9 പ്രതീകങ്ങൾ 123456789 എടുത്തു, അവയിൽ null പ്രതീകം \0 ചേർക്കുകയും string-ൽ എഴുതുകയും ചെയ്തു. ഇൻപുട്ട് സ്ട്രീമിൽ ഇനിയും 0\n അവശേഷിക്കുന്നു.

അടുത്തതായി നമ്മൾ വേരിയബിൾ h പ്രഖ്യാപിക്കുന്നു. ഞങ്ങൾ അതിന്റെ മൂല്യം സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുന്നു. അപ്പോൾ നമ്മൾ സ്കാൻഫ് ഫംഗ്ഷനെ വിളിക്കുന്നു. ഇവിടെ നമുക്ക് എന്തെങ്കിലും നൽകാമെന്ന് പ്രതീക്ഷിക്കുന്നു, പക്ഷേ... ഇൻപുട്ട് സ്ട്രീമിൽ 0\n തൂങ്ങിക്കിടക്കുന്നു, തുടർന്ന് സ്കാൻഫ് ഫംഗ്ഷൻ ഇത് ഞങ്ങളുടെ ഇൻപുട്ടായി മനസ്സിലാക്കുകയും h എന്ന വേരിയബിളിലേക്ക് 0 എഴുതുകയും ചെയ്യുന്നു. അടുത്തതായി ഞങ്ങൾ അത് സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും.

ഇത് തീർച്ചയായും നമ്മൾ പ്രതീക്ഷിക്കുന്ന സ്വഭാവമല്ല. ഈ പ്രശ്നം കൈകാര്യം ചെയ്യുന്നതിന്, ഉപയോക്താവിന്റെ ഇൻപുട്ട് വായിച്ചതിനുശേഷം ഇൻപുട്ട് ബഫർ മായ്‌ക്കേണ്ടതുണ്ട്. ഇതിനായി ഒരു പ്രത്യേക ഫംഗ്ഷൻ ഫ്ലഷ് ഉപയോഗിക്കുന്നു. ഇതിന് ഒരു പാരാമീറ്റർ മാത്രമേയുള്ളൂ - മായ്‌ക്കേണ്ട സ്ട്രീം.

നമുക്ക് അവസാനത്തെ ഉദാഹരണം ശരിയാക്കാം, അതുവഴി അത് പ്രവചിക്കാവുന്ന രീതിയിൽ പ്രവർത്തിക്കുന്നു.

പട്ടിക 6.

#ഉൾപ്പെടുന്നു int main(void) (char str; fgets(str, 10, stdin); fflush(stdin); // ഇൻപുട്ട് സ്ട്രീം പുട്ടുകൾ മായ്‌ക്കുക(str); int h = 99; printf("do %d\n", h ) ; സ്കാൻഫ്("%d",&h); printf("%d\n", h); മടങ്ങുക 0; )

ഇപ്പോൾ പ്രോഗ്രാം അത് പോലെ പ്രവർത്തിക്കും.

ചിത്രം.4 ഫ്‌ലഷ് ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് സ്റ്റഡിൻ ബഫർ ഫ്ലഷ് ചെയ്യുന്നു

ചുരുക്കത്തിൽ, രണ്ട് വസ്തുതകൾ ശ്രദ്ധിക്കാം. ആദ്യം. നിലവിൽ, ഗെറ്റ്സ് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നത് സുരക്ഷിതമല്ല, അതിനാൽ എല്ലായിടത്തും fgets ഫംഗ്ഷൻ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു.

രണ്ടാമത്. നിങ്ങൾ fgets ഫംഗ്‌ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ ഇൻപുട്ട് ബഫർ മായ്‌ക്കാൻ മറക്കരുത്.

സ്ട്രിംഗുകൾ നൽകുന്നതിനെക്കുറിച്ചുള്ള സംഭാഷണം ഇത് അവസാനിപ്പിക്കുന്നു. മുന്നോട്ടുപോകുക.