ഇംഗ്ലീഷ്ഫ്രഞ്ച്സ്പാനിഷ്

സെർവറുകൾ പ്രവർത്തിപ്പിക്കുക | Ubuntu > | Fedora > |


OnWorks ഫെവിക്കോൺ

icmake - ക്ലൗഡിൽ ഓൺലൈനിൽ

ഉബുണ്ടു ഓൺലൈൻ, ഫെഡോറ ഓൺലൈൻ, വിൻഡോസ് ഓൺലൈൻ എമുലേറ്റർ അല്ലെങ്കിൽ MAC OS ഓൺലൈൻ എമുലേറ്റർ എന്നിവയിലൂടെ OnWorks സൗജന്യ ഹോസ്റ്റിംഗ് ദാതാവിൽ icmake പ്രവർത്തിപ്പിക്കുക

Ubuntu Online, Fedora Online, Windows online emulator അല്ലെങ്കിൽ MAC OS ഓൺലൈൻ എമുലേറ്റർ എന്നിങ്ങനെയുള്ള ഞങ്ങളുടെ ഒന്നിലധികം സൗജന്യ ഓൺലൈൻ വർക്ക്സ്റ്റേഷനുകളിലൊന്ന് ഉപയോഗിച്ച് OnWorks സൗജന്യ ഹോസ്റ്റിംഗ് ദാതാവിൽ പ്രവർത്തിപ്പിക്കാവുന്ന കമാൻഡ് icmake ആണിത്.

പട്ടിക:

NAME


icmake - ഒരു പ്രോഗ്രാം മെയിന്റനൻസ് (ഉണ്ടാക്കുക) എ ഉപയോഗിക്കുന്ന യൂട്ടിലിറ്റി C-വ്യാകരണം പോലെ

സിനോപ്സിസ്


icmake [ഓപ്ഷനുകൾ] ഉറവിടം[.im] [dest[.bim]] [-- [args]]

icmun ബിംഫിൽ

വിവരണം


ഐക്മേക്ക്(1) എന്നതിന് പകരമായി ഉപയോഗിക്കാം ഉണ്ടാക്കുക(1). അതിന്റെ സ്റ്റാൻഡേർഡ് ഓപ്പറേഷൻ മോഡിൽ, അത്
ഇനിപ്പറയുന്ന പ്രോഗ്രാമുകളെ വിളിക്കുന്നു:

o icm-pp icmake ഫയൽ പ്രീപ്രോസസ് ചെയ്യാൻ

o icm-comp ബൈറ്റ്-കോഡ് കംപൈൽ ചെയ്യാൻ icmake s

o icm-exec ബൈറ്റ്-കോഡ് ഫയൽ എക്സിക്യൂട്ട് ചെയ്യാൻ

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

പരിപാടി icmun(1) സമാഹരിച്ച ബൈറ്റ്-കോഡ് (.ബിം) ഫയൽ ഡിസ്അസംബ്ലിംഗ് ചെയ്യാൻ ഉപയോഗിക്കാം. ഇക്മൺ
ചിത്രീകരണം, വിദ്യാഭ്യാസം, ഡീബഗ്ഗിംഗ് എന്നിവയ്ക്കായി പ്രാഥമികമായി ഉപയോഗിക്കുന്നു.

ഹെഡർ ഫയലുകൾ പരിഷ്‌ക്കരിച്ചുകഴിഞ്ഞാൽ പരമ്പരാഗത മേക്ക്-യൂട്ടിലിറ്റികൾ ഉറവിടങ്ങൾ വീണ്ടും കംപൈൽ ചെയ്യുന്നു. ൽ
സന്ദർഭം സി ++ ഒരു പുതിയ അംഗത്തെ ചേർക്കുന്നത് പോലെ, പ്രോഗ്രാം ഡെവലപ്‌മെന്റ് ഇത് പലപ്പോഴും ഒരു മോശം ആശയമാണ്
ക്ലാസ്സിന്റെ ഉറവിടങ്ങൾ വീണ്ടും കംപൈൽ ചെയ്യാൻ class ആവശ്യപ്പെടുന്നില്ല. ക്ലാസ് കൈകാര്യം ചെയ്യാൻ
ഡിപൻഡൻസികൾ icmbuld(1) പരിശോധിക്കാം ക്ലാസുകൾ ഡിപൻഡൻസികൾ നിർവചിക്കാൻ ഉപയോഗിക്കാവുന്ന ഫയലുകൾ
ക്ലാസുകൾക്കിടയിൽ. സ്ഥിരസ്ഥിതിയായി, വർഗ്ഗ-ആശ്രിതത്വം വ്യാഖ്യാനിക്കപ്പെടുന്നില്ല. റഫർ ചെയ്യുക icmconf(7)
കൂടുതൽ വിവരങ്ങൾക്ക് മാൻ പേജ്.

ഓപ്ഷനുകൾ


ഐക്മേക്ക് ഇനിപ്പറയുന്ന ഫയലുകളും ഓപ്ഷനുകളും ഉപയോഗിക്കുന്നു:

o ഉറവിടം: icmake സ്ക്രിപ്റ്റ് സോഴ്സ് ഫയൽ (ഡിഫോൾട്ട് എക്സ്റ്റൻഷൻ: .im).

o ലക്ഷ്യസ്ഥാനം: ബൈനറി icmake സ്ക്രിപ്റ്റ് ഫയൽ (സ്ഥിരസ്ഥിതി: `ഉറവിടം'.ബിം, `.ബിം ഫയൽ' എന്ന് വിളിക്കുന്നു
താഴെ).

o --: icmake ആർഗ്യുമെന്റുകൾ വേർതിരിക്കുന്ന വേർതിരിക്കൽ icmake പാസാക്കിയ വാദങ്ങളിൽ നിന്നുള്ള വാദങ്ങൾ
.bim filenl() ലേക്ക് വാദിക്കുന്നു: ഇനിപ്പറയുന്ന വാദങ്ങൾ -- .bim ഫയലിലേക്ക് കൈമാറുന്നു
എന്നതിൽ നിന്ന് ലഭ്യമാണ് പട്ടിക argv പരാമീറ്റർ നിർവചിച്ചിരിക്കുന്നത് icmake
സ്ക്രിപ്റ്റിന്റെ പ്രധാന ഫംഗ്‌ഷന്റെ രണ്ടാമത്തെ പാരാമീറ്റർ (താഴെ വിഭാഗത്തിൽ കാണുക USER നിർവചിച്ചു
പ്രവർത്തനങ്ങൾ). ചില ഓപ്ഷനുകൾക്കായി (ചുവടെ കാണുക). -- സെപ്പറേറ്റർ ആവശ്യമില്ല.

ഐക്മേക്ക് വിവിധ ഓപ്ഷനുകൾ പിന്തുണയ്ക്കുന്നു, അടുത്തതായി വിവരിക്കുന്നു. ദി -h ഓപ്ഷൻ മറ്റുള്ളവയെ മറികടക്കുന്നു
ഓപ്ഷനുകൾ, ദി -a ഓപ്ഷൻ ഒഴികെ മറ്റെല്ലാ ഓപ്ഷനുകളും അസാധുവാക്കുന്നു -h. ശേഷിക്കുന്ന പ്രവർത്തനങ്ങളിൽ
ഓപ്ഷനുകൾ (-ബി, -സി, -ഇ, -ഞാൻ, -p ഒപ്പം -t) ഒന്ന് മാത്രം വ്യക്തമാക്കാം:

o -a
എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ കാണിക്കുക icmake, അസാധുവാക്കി -h;

o -b
നിർത്തലാക്കി: പകരം -e ഓപ്ഷൻ ഉപയോഗിക്കുക;

o -c
The icmake സോഴ്സ് ഫയൽ കംപൈൽ ചെയ്തു, ഒരു .bim ഫയൽ സൃഷ്ടിക്കുന്നു;

o -e
എക്സിക്യൂട്ട് ചെയ്യുക icmake .bim ഫയൽ, ആയി നൽകിയിരിക്കുന്നു icmakeന്റെ ആദ്യ ഫയൽ വാദം. ഏതെങ്കിലും അധിക
ആർഗ്യുമെന്റുകൾ .bim ഫയലിലേക്ക് കൈമാറുന്നു, ഒപ്പം -- വ്യക്തമാക്കാൻ പാടില്ല;

o -F
ഫയലിന്റെ പേരുകളും ഫ്ലാഗുകളും കൂടാതെ ചെയ്യേണ്ട എല്ലാ പ്രവർത്തനങ്ങളുടെയും ഒരു അവലോകനം
icmake സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് സ്ട്രീമിൽ കാണിക്കുന്നു;

o -h
ഉപയോഗ വിവരങ്ങളും അവസാനവും നൽകുക icmake;

o -i
എന്നതാണ് ആദ്യത്തെ വാദം icmake സോഴ്സ് ഫയൽ, ഡിഫോൾട്ട് ബൈനറി ഫയൽ ആണ്
ആവശ്യമെങ്കിൽ നിർമ്മിച്ചു. ഏതെങ്കിലും അധിക ആർഗ്യുമെന്റുകൾ .bim ഫയലിലേക്ക് കൈമാറും
അതുപോലെ, ഒപ്പം -- വ്യക്തമാക്കാൻ പാടില്ല;

o -p
The icmake സോഴ്സ് ഫയൽ പ്രീപ്രോസസ്സ് ചെയ്തതേയുള്ളൂ, പ്രീപ്രോസസ് ചെയ്ത ഫയൽ എഴുതിയിരിക്കുന്നു
ലേക്ക് icmakeന്റെ രണ്ടാമത്തെ ഫയൽ ആർഗ്യുമെന്റ് (സ്ഥിരസ്ഥിതിയായി `ഉറവിടം'.pim);

o -q
അവഗണിച്ചു, ഭാവിയിൽ നീക്കം ചെയ്യപ്പെടും icmake പതിപ്പ്;

o -t
വാദം താഴെ -t എന്നത് ഒരു താൽക്കാലിക .bim ഫയലിന്റെ പേരാണ്, അത് നീക്കം ചെയ്തു
ശേഷം icmakeന്റെ വിളി. എപ്പോൾ . താൽക്കാലിക .bim ഫയലിന്റെ പേരായി വ്യക്തമാക്കിയിരിക്കുന്നു
തുടർന്ന് സ്ഥിരസ്ഥിതി താൽക്കാലിക ഡയറക്ടറി, തുടർന്ന് icmakeന്റെ പ്രോസസ്സ്-ഐഡി, തുടർന്ന്
.ബിം ഉപയോഗിക്കുന്നു.

താത്കാലിക .bim ന്റെ പേര് പിന്തുടരുക എന്നതിന്റെ പേര് ഫയൽ ചെയ്യുക icmake ഉറവിട സ്ക്രിപ്റ്റ്
വ്യക്തമാക്കണം. ഏതെങ്കിലും അധിക ആർഗ്യുമെന്റുകൾ .bim ഫയലിലേക്ക് കൈമാറും, ഒപ്പം
-- വ്യക്തമാക്കാൻ പാടില്ല; ഉറവിട സ്ക്രിപ്റ്റ് ഫയലിന്റെ എക്സിക്യൂട്ടബിൾ ഫ്ലാഗ് സജ്ജീകരിച്ച ശേഷം
(chmod +x സ്ക്രിപ്റ്റ്), കൂടാതെ ഇതുപോലെയുള്ള ഒരു പ്രാരംഭ വരി നൽകുന്നു:

#!/usr/bin/icmake -t.

The icmake സ്ക്രിപ്റ്റ് നേരിട്ട് വിളിക്കാം:

സ്ക്രിപ്റ്റ് arg1 arg2

ഏത് സാഹചര്യത്തിലാണ് icmake സ്ക്രിപ്റ്റ് `സ്ക്രിപ്റ്റ്' അത് സ്വീകരിക്കുമ്പോൾ നടപ്പിലാക്കുന്നു
വാദങ്ങൾ സ്ക്രിപ്റ്റ് arg1 arg2.

o -T
ഈ ഓപ്‌ഷൻ സംഭരിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ഡയറക്‌ടറിയുടെ പേരിനൊപ്പം നൽകണം
താൽക്കാലിക ഫയലുകൾ. ഉദാ, ഒരു കംപൈൽ ചെയ്യുമ്പോൾ icmake സ്ക്രിപ്റ്റ്, ഔട്ട്പുട്ട് icmakeഎന്നയാളുടെ
പുറത്തുകടക്കുമ്പോൾ നീക്കം ചെയ്യുന്ന ഒരു താൽക്കാലിക ഫയലാണ് preprocessor. സ്ഥിരസ്ഥിതിയായി / tmp ഉപയോഗിക്കുന്നു,
അല്ലാതെ / tmp എഴുതാവുന്ന ഡയറക്‌ടറി അല്ല, ഈ സാഹചര്യത്തിൽ നിലവിലെ ഉപയോക്താവിന്റെത് $ HOME
ഡയറക്ടറി ഉപയോഗിക്കുന്നു. അവ്യക്തമായ താൽക്കാലിക ഫയൽനാമങ്ങൾ എല്ലായ്പ്പോഴും ആരംഭിക്കുന്നത് പ്രോസസ്സ് ഐഡിയിൽ നിന്നാണ്
നിലവിൽ icmake പ്രക്രിയ.

o -v
ഡിസ്പ്ലേ icmakeന്റെ പതിപ്പ് നമ്പറും അവസാനവും icmake, അസാധുവാക്കി -h

ഇക്മൺ:

ബിംഫിൽ: ബൈനറി icmake സ്ക്രിപ്റ്റ് ഫയൽ.

പ്രിപ്രോസസർ ഡയറക്റ്റീവ്സ്


ഇനിപ്പറയുന്ന പ്രീപ്രൊസസ്സർ നിർദ്ദേശങ്ങൾ ലഭ്യമാണ്:

അഭിപ്രായം:
സാധാരണ C അഭിപ്രായം (എല്ലാം ഇടയിൽ /* ഒപ്പം */) അതുപോലെ കമന്റ്-ടു-എൻഡ്-ഓഫ്-ലൈൻ (എല്ലാം
ലൈൻ ഉള്ളടക്കങ്ങൾ താഴെ //) അവഗണിക്കപ്പെടുന്നു.

ഷെൽ സ്റ്റാർട്ടപ്പ്: ആദ്യ വരി icmake-സ്ക്രിപ്റ്റ് തുടങ്ങാം #!പാതഎവിടെ
പാത യുടെ സമ്പൂർണ്ണ സ്ഥാനം നിർവചിക്കുന്നു icmake പ്രോഗ്രാം. സ്ക്രിപ്റ്റ് ഉണ്ടാക്കിക്കൊണ്ട്
എക്സിക്യൂട്ടബിൾ, ഇത് വ്യക്തമായി വിളിക്കാതെ തന്നെ വിളിക്കാം icmake.

ഉദാ, ഒരു (എക്‌സിക്യൂട്ടബിൾ) icmakefile 'icm' (എക്‌സ്‌റ്റൻഷൻ ഇല്ലാതെ) ആദ്യ വരി ആണെങ്കിൽ
അടങ്ങിയിരിക്കുന്നു

#!/usr/bin/icmake -i

അപ്പോള് ഐസിഎം ഒരു കമാൻഡായി നൽകാം, അങ്ങനെ നടപ്പിലാക്കുന്നു

/usr/bin/icmake -i icm ...

പകരമായി,

#!/usr/bin/icmake -t /tmp/icm

ഉപയോഗിച്ചേക്കാം, അതിന്റെ ഫലമായി

#!/usr/bin/icmake -t /tmp/icm icm ...

ഈ സാഹചര്യത്തിൽ, പുറത്തുകടക്കുമ്പോൾ ബൈനറി ഫയൽ നീക്കം ചെയ്യപ്പെടും.

o # ഉൾപ്പെടുത്തുക "ഫയലിന്റെ പേര്"
ഫയൽ ഫയലിന്റെ പേര് നിർദ്ദേശത്തിന്റെ സ്ഥാനത്ത് ഉൾപ്പെടുത്തിയിട്ടുണ്ട്

o # ഉൾപ്പെടുത്തുക
ഫയൽ ഫയലിന്റെ പേര് എന്ന സ്ഥലത്ത് ഉൾപ്പെടുത്തിയിട്ടുണ്ട് # ഉൾപ്പെടുത്തുക നിർദ്ദേശം; ഫയലിന്റെ പേര്
നിർദിഷ്ട കോളൻ-വേർതിരിക്കപ്പെട്ട ഡയറക്‌ടറികളിൽ തിരയുന്നു IM പരിസ്ഥിതി
വേരിയബിൾ. ആദ്യ സംഭവം ഫയലിന്റെ പേര് വ്യക്തമാക്കിയ ഡയറക്ടറികളിൽ IM
പരിസ്ഥിതി വേരിയബിൾ ഉപയോഗിക്കുന്നു.

o # നിർവചിക്കുക ഐഡന്റിഫയർ [നിർവചനം]
ടെക്സ്റ്റ് ഐഡന്റിഫയർ വഴി മാറ്റിസ്ഥാപിക്കും നിര്വചനം. നിർവചനത്തിൽ അടങ്ങിയിരിക്കാം
ഇതിനകം നിർവചിച്ച ഐഡന്റിഫയറുകളിലേക്കുള്ള റഫറൻസുകൾ ${identifier} ഫോർമാറ്റ്. എങ്കിൽ
${identifier} നിർവചിച്ചിട്ടില്ല (ഇതുവരെ), വാചകം ${identifier} അക്ഷരാർത്ഥത്തിൽ സൂക്ഷിച്ചിരിക്കുന്നു.
അനന്തമായ ആവർത്തനം തടയാൻ പരമാവധി 100 ${identifier} മാറ്റിസ്ഥാപിക്കൽ അനുവദനീയമാണ്.

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

ഇനിപ്പറയുന്ന നിർവചനം #നിർവചിക്കുന്നു ഐഡന്റിഫയർ ഓപ്ഷണൽ ആണ്. ഒഴിവാക്കിയാൽ, ദി
മാക്രോ നിർവചിച്ചിരിക്കുന്നു, അതിനാൽ ഇത് ഉപയോഗിക്കാനാകും #if(n)def നിർദ്ദേശങ്ങൾ (ചുവടെ കാണുക), പക്ഷേ അവ
എന്നതിലെ ഏതെങ്കിലും വാചകം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നില്ല icmake കോഡ് പ്രസ്താവനകൾ.

o #ifdef ഐഡന്റിഫയർ
എങ്കില് ഐഡന്റിഫയർ കോഡിന്റെ അടുത്ത ബ്ലോക്ക് മാക്രോ നിർവചിച്ചു (പൊരുത്തപ്പെടുന്നതുവരെ # കൂടാതെ
or #അവസാനം നിർദ്ദേശം വായിച്ചു) ബൈറ്റ്-കംപൈൽ ചെയ്തതാണ്. അല്ലെങ്കിൽ, കോഡിന്റെ ബ്ലോക്ക് ആണ്
അവഗണിച്ചു.

o #ifndef ഐഡന്റിഫയർ
എങ്കില് ഐഡന്റിഫയർ മാക്രോ ആയിരുന്നു അല്ല കോഡിന്റെ അടുത്ത ബ്ലോക്ക് നിർവചിച്ചു (പൊരുത്തപ്പെടുന്നതുവരെ
# കൂടാതെ or #അവസാനം നിർദ്ദേശം കണ്ടെത്തി) ബൈറ്റ്-കംപൈൽ ചെയ്തതാണ്. അല്ലെങ്കിൽ, എന്ന ബ്ലോക്ക്
കോഡ് അവഗണിക്കപ്പെട്ടു.

o # കൂടാതെ
എ അവസാനിപ്പിക്കുന്നു #ifdef ഒപ്പം #ifndef നിർദ്ദേശം, സംബന്ധിച്ച സ്വീകാര്യത തീരുമാനം മാറ്റുന്നു
ഇനിപ്പറയുന്ന കോഡ്. ഒന്ന് മാത്രം # കൂടാതെ നിർദ്ദേശവുമായി ബന്ധപ്പെടുത്താവുന്നതാണ് #if(n)def
നിർദ്ദേശങ്ങൾ.

o #അവസാനം
പൊരുത്തപ്പെടുത്തൽ ആരംഭിക്കുന്ന പ്രീപ്രൊസസ്സർ ബ്ലോക്ക് അവസാനിപ്പിക്കുന്നു #ifdef, #ifndef or # കൂടാതെ
നിർദ്ദേശം. ദി #അവസാനം ഡയറക്ടറിയും അതിന്റെ പൊരുത്തവും #if(n)def നിർദ്ദേശം ആയിരിക്കണം
അതേ ഫയലിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്.

o # undef ഐഡന്റിഫയർ
നീക്കംചെയ്യുക ഐഡന്റിഫയർ നിർവചിക്കപ്പെട്ട ചിഹ്നങ്ങളുടെ കൂട്ടത്തിൽ നിന്ന്. ഇത് ബാധിക്കില്ല
മുമ്പ് നിർവചിക്കപ്പെട്ട ഏതെങ്കിലും ചിഹ്നങ്ങളുടെ സ്പെസിഫിക്കേഷൻ ഐഡന്റിഫയറിന്റെ നിര്വചനം
ഉപയോഗിച്ചിട്ടുണ്ട്. എങ്കിൽ ഐഡന്റിഫയർ മുന്നറിയിപ്പ് നൽകിയിട്ടില്ലെന്ന് നിർവചിച്ചിട്ടില്ല.

ഡാറ്റ ടൈപ്പുകൾ


ഐക്മേക്ക് ഈ ഡാറ്റ തരങ്ങളെ പിന്തുണയ്ക്കുന്നു:

o ASCII പ്രതീകം സ്ഥിരാങ്കങ്ങൾ
ASCII പ്രതീക സ്ഥിരാങ്കങ്ങൾ ഒറ്റ അല്ലെങ്കിൽ ഇരട്ട കൊണ്ട് ചുറ്റപ്പെട്ട ഒരു പ്രതീകം ഉൾക്കൊള്ളുന്നു
ഉദ്ധരണികൾ. ഒറ്റ കഥാപാത്രങ്ങൾ (ഉദാ. 'എ') കഥാപാത്രത്തെ തന്നെ പ്രതിനിധീകരിക്കുന്നു. സ്റ്റാൻഡേർഡ്
രക്ഷപ്പെടൽ ക്രമങ്ങൾ (ഉദാ. '\n') പിന്തുണയ്ക്കുകയും അവയുടെ സ്റ്റാൻഡേർഡ് പരിവർത്തനത്തെ പ്രതിനിധീകരിക്കുകയും ചെയ്യുന്നു
മൂല്യം (ഉദാ. '\n' ascii മൂല്യം 10 ​​(ദശാംശം)) പ്രതിനിധീകരിക്കുന്നു. നിലവാരമില്ലാത്ത രക്ഷപ്പെടൽ
ക്രമങ്ങൾ (ഉദാ. '\x') എസ്കേപ്പ് പ്രതീകത്തെ പിന്തുടരുന്ന ascii പ്രതീകത്തെ പ്രതിനിധീകരിക്കുന്നു
(അങ്ങനെ '\x' തുല്യമാണ് 'x'). മൂന്ന് ഒക്ടൽ അക്കങ്ങൾ അടങ്ങുന്ന എസ്കേപ്പ് സീക്വൻസുകൾ പ്രതിനിധീകരിക്കുന്നു
ഒക്ടൽ മൂല്യം മൊഡ്യൂളോ 256 ന് അനുയോജ്യമായ ascii പ്രതീകം (ഉദാ, '\123').
രണ്ട് ഹെക്സാഡെസിമൽ അക്കങ്ങളും ഒരു x അടങ്ങുന്ന എസ്കേപ്പ് സീക്വൻസുകളെ പ്രതിനിധീകരിക്കുന്നു
ഹെക്സാഡെസിമൽ മൂല്യവുമായി പൊരുത്തപ്പെടുന്ന ascii പ്രതീകം (ഉദാ. '\xa4').

o int
അവിഭാജ്യ മൂല്യങ്ങൾ, മുതൽ -0x8000 മുഖാന്തിരം 0x7ff. int സ്ഥിരാങ്കങ്ങൾ ആയിരിക്കാം
ദശാംശ സംഖ്യകളായി വ്യക്തമാക്കിയിരിക്കുന്നു (1 മുതൽ 9 വരെയുള്ള അക്കങ്ങളിൽ തുടങ്ങി), അഷ്ടസംഖ്യകൾ
(0 മുതൽ ആരംഭിക്കുന്നു, തുടർന്ന് ഒന്നോ അതിലധികമോ ഒക്ടൽ അക്കങ്ങൾ) ഹെക്സാഡെസിമൽ സംഖ്യകൾ
(0x-ൽ തുടങ്ങി, ഒന്നോ അതിലധികമോ ഹെക്സാഡെസിമൽ അക്കങ്ങൾ) അല്ലെങ്കിൽ ഇങ്ങനെ ASCII
പ്രതീക സ്ഥിരാങ്കങ്ങൾ.

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

ഇരട്ട ഉദ്ധരണികളാൽ ചുറ്റപ്പെട്ട ASCII പ്രതീക സ്ഥിരാങ്കങ്ങളും ഉപയോഗിക്കാം
ഓപ്പറണ്ടുകളിൽ ഒന്ന് an ആണെങ്കിൽ ഗണിത പദപ്രയോഗങ്ങൾ int. ഒറ്റ കഥാപാത്രം
സ്ട്രിംഗ് സ്ഥിരമായ ആവശമാകുന്നു സ്ഥിരമായിരിക്കുക, ആകാൻ കഴിയില്ല സ്ട്രിംഗ് വേരിയബിൾ.

അതുപോലെ, ഒറ്റ ഉദ്ധരണികളാൽ ചുറ്റപ്പെട്ട ASCII പ്രതീക സ്ഥിരാങ്കങ്ങൾ ഉപയോഗിച്ചേക്കാം
ഒരു സ്ട്രിംഗ് ഓപ്പറണ്ട് പ്രതീക്ഷിക്കുന്ന സാഹചര്യങ്ങൾ.

o പട്ടിക
വ്യക്തിഗതമായി ആക്സസ് ചെയ്യാവുന്ന ഒരു ശ്രേണി അടങ്ങുന്ന ഒരു ഡാറ്റ ഘടന സ്ട്രിംഗ് മൂല്യങ്ങൾ. എപ്പോൾ
ഒരു പട്ടികയിൽ ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു, അതിന്റെ ആദ്യ ഘടകം സൂചിക 0 ആണ് സൂചിപ്പിക്കുന്നത്.

o ശൂന്യം
ഫംഗ്‌ഷൻ എ റിട്ടേൺ ചെയ്യുന്നില്ലെന്ന് സൂചിപ്പിക്കാൻ ഫംഗ്‌ഷൻ നിർവചനങ്ങൾക്കൊപ്പം ഉപയോഗിക്കുന്നു
മൂല്യം.

വേരിയബിളുകൾ ആഗോള തലത്തിലും ഉള്ളിലെ ഏത് പ്രാദേശിക തലത്തിലും നിർവചിക്കാം
പ്രവർത്തനങ്ങൾ. ഫംഗ്ഷനുകൾക്കുള്ളിൽ നിർവചിക്കുമ്പോൾ, സ്റ്റാൻഡേർഡ് C സ്കോപ്പിംഗും ദൃശ്യപരതയും നിയമങ്ങൾ
പ്രയോഗിക്കുക. ഉദാ, ലോക്കൽ വേരിയബിളുകൾ അവയുടെ സ്വന്തം അല്ലെങ്കിൽ കൂടുതൽ ആഴത്തിലുള്ള നെസ്റ്റഡ് മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ
ബ്ലോക്കുകൾ, അവയുടെ ദൃശ്യപരത കൂടുതൽ ആഴത്തിൽ നെസ്റ്റഡ് ബ്ലോക്കുകളിൽ മറയ്ക്കുന്നു
കൂടുതൽ ആഴത്തിൽ നെസ്റ്റഡ് ബ്ലോക്കുകൾക്കുള്ളിൽ വേരിയബിൾ എന്ന് പേരിട്ടു. വേരിയബിളുകൾ ശക്തമായി ടൈപ്പ് ചെയ്തിട്ടുണ്ട്, കൂടാതെ
തരം പാടില്ല ശൂന്യം.

വേരിയബിളുകൾ നിർവചിക്കുമ്പോൾ അവ ആരംഭിക്കാം. ഇനിഷ്യലൈസേഷനുകൾ പദപ്രയോഗങ്ങളാണ്, അത്
മുൻകൂട്ടി അല്ലെങ്കിൽ ഉപയോക്തൃ-നിർവചിച്ച ഫംഗ്ഷനുകൾ, സ്ഥിരമായ മൂല്യങ്ങൾ, വേരിയബിളുകളുടെ മൂല്യങ്ങൾ എന്നിവ ഉപയോഗിക്കാം
നിർവചനത്തിന്റെ പോയിന്റിൽ ദൃശ്യമാണ്.

മുൻകൂട്ടി നിശ്ചയിച്ചത് സ്ഥിരം


ഇനിപ്പറയുന്ന സ്ഥിരാങ്കങ്ങൾ മുൻകൂട്ടി നിർവചിച്ചിരിക്കുന്നു icmake. എല്ലാം സ്ഥിരമാണ് int മൂല്യങ്ങൾ:

─────────────────────────────────
പ്രതീക മൂല്യം ഉദ്ദേശിച്ചുള്ളതാണ്
─────────────────────────────────
O_ALL 8 മേക്ക്‌ലിസ്റ്റ്
O_DIR 2 മേക്ക്‌ലിസ്റ്റ്
O_FILE 1 മേക്ക്‌ലിസ്റ്റ്
O_SUBDIR 4 മേക്ക്‌ലിസ്റ്റ്
─────────────────────────────────
ഓഫ് 0 എക്കോ
1 എക്കോയിൽ
─────────────────────────────────
P_CHECK 0 സിസ്റ്റം കോളുകൾ
P_NOCHECK 1 സിസ്റ്റം കോളുകൾ
─────────────────────────────────
S_IEXEC 32 സ്റ്റാറ്റ്
S_IFCHR 1 സ്ഥിതിവിവരക്കണക്ക്
S_IFDIR 2 സ്ഥിതിവിവരക്കണക്ക്
S_IFREG 4 സ്ഥിതിവിവരക്കണക്ക്
S_IREAD 8 സ്റ്റാറ്റ്
S_IWRITE 16 സ്റ്റാറ്റ്
─────────────────────────────────

ഇനിപ്പറയുന്ന സ്ഥിരാങ്കങ്ങൾ വാസ്തുവിദ്യയെ ആശ്രയിച്ചിരിക്കുന്നു:

────────────────────────────────────────────────── ────────────
പ്ലാറ്റ്‌ഫോമിൽ നിർവചിക്കുമ്പോൾ ചിഹ്നം 1, അല്ലാത്തപക്ഷം 0
────────────────────────────────────────────────── ────────────
unix Unix, സാധാരണയായി GNU-ന്റെ gcc കംപൈലറിനൊപ്പം
UNIX പകരമായി ലഭ്യമായേക്കാം
linux x86 പ്രവർത്തിക്കുന്ന Linux (സാധാരണയായി gcc ഉപയോഗിച്ച്)
ലിനക്സ് പകരം ലഭ്യമായേക്കാം
M_SYSV, M_UNIX x86 SCO/Unix പ്രവർത്തിക്കുന്നു
_POSIX _SOURCE Posix കംപൈലർ ഉള്ള Unix
__hpux HP-UX, നേറ്റീവ് HP കംപൈലറിനൊപ്പം
────────────────────────────────────────────────── ────────────

ഓപ്പറേറ്റർമാർ


int-ടൈപ്പ് ചെയ്തത് പ്രവർത്തനരീതി(കൾ):

എല്ലാം C ഓപ്പറേറ്റർമാർ ലഭ്യമാണ് (പോയിന്റർ ഓപ്പറേറ്റർമാർ ഒഴികെ icmake പിന്തുണയ്ക്കുന്നില്ല
സൂചകങ്ങൾ). അവർ അവരുടെ പോലെ പ്രവർത്തിക്കുന്നു C- പ്രോഗ്രാമിംഗ് ഭാഷാ എതിരാളികൾ.

സ്ട്രിംഗ്-ടൈപ്പ് ചെയ്ത പ്രവർത്തനരീതി(കൾ):

വേണ്ടി സ്ട്രിംഗ് ടൈപ്പ് വേരിയബിളുകൾ കൂടാതെ/അല്ലെങ്കിൽ സ്ഥിരാങ്കങ്ങൾ താഴെ പറയുന്ന ഓപ്പറേറ്റർമാർ ലഭ്യമാണ് (a ഒപ്പം b
പ്രതിനിധാനം ചെയ്യുക സ്ട്രിംഗ് വേരിയബിളുകൾ അല്ലെങ്കിൽ സ്ഥിരാങ്കങ്ങൾ):

o a + b: പുതിയത് തിരികെ നൽകുന്നു സ്ട്രിംഗ് എന്ന സംയോജനം അടങ്ങിയിരിക്കുന്ന മൂല്യം സ്ട്രിംഗ് മൂല്യങ്ങൾ a
ഒപ്പം b. അതല്ല സ്ട്രിംഗ് സ്ഥിരാങ്കങ്ങൾ നേരിട്ട് സംയോജിപ്പിച്ചേക്കാം (ഉപയോഗിക്കാതെ +
ഓപ്പറേറ്റർ), ഉദാ, ഇനിപ്പറയുന്ന രണ്ട് വരികൾ സ്ട്രിംഗിനെ നിർവചിക്കുന്നു "ഹലോ ലോകം":

"ഹലോ വേൾഡ്"
"ഹലോ" + "ലോകം"

o a += b: a ഒരു ആയിരിക്കണം സ്ട്രിംഗ് വേരിയബിൾ, അതിലേക്ക് സ്ട്രിംഗ് വേരിയബിൾ അല്ലെങ്കിൽ മൂല്യം b is
അനുബന്ധമായി.

ഒ സ്ട്രിംഗ് താരതമ്യങ്ങൾ: ഓപ്പറേറ്റർമാർ == != <= >= < > != ഒപ്പം == എന്നതിലേക്ക് പ്രയോഗിച്ചേക്കാം സ്ട്രിംഗ്
മൂല്യങ്ങൾ അല്ലെങ്കിൽ വേരിയബിളുകൾ, താരതമ്യം വിജയിക്കുകയാണെങ്കിൽ 1 നൽകുന്നു, അല്ലാത്തപക്ഷം 0.
താരതമ്യം കേസ് സെൻസിറ്റീവാണ്, കൂടാതെ നിർവചിച്ചിരിക്കുന്ന ക്രമം അല്ലെങ്കിൽ പ്രതീകങ്ങൾ പിന്തുടരുന്നു
ലെ ASCII പ്രതീക സെറ്റ്.

o !a: ബൂളിയൻ ! (അല്ല) ഓപ്പറേറ്റർ 1 നൽകുന്നു എങ്കിൽ സ്ട്രിംഗ് a ശൂന്യമാണ്, അല്ലാത്തപക്ഷം 0 ആണ്
മടങ്ങി.

o a ചെറുപ്പക്കാരൻ b, a പുതിയത് b: ഫയലാണെങ്കിൽ 1 നൽകുന്നു a ഫയലിനേക്കാൾ സമീപകാലമാണ് b. ഉദാ,
"source.cc" പുതിയത് "source.o". ഫയലുകൾ a ഒപ്പം b നിലവിലില്ല: രണ്ടും ഇല്ലെങ്കിൽ
നിലവിലുണ്ട് 0 തിരികെ നൽകുന്നു; എങ്കിൽ b നിലവിലില്ല, 1 തിരികെ ലഭിച്ചു; എങ്കിൽ a നിലവിലില്ല 0 ആണ്
മടങ്ങി; അവ തുല്യമായി പഴയതാണെങ്കിൽ 0 തിരികെ നൽകും. (ദി നിലവിലുണ്ട് () മുൻകൂട്ടി നിശ്ചയിച്ച പ്രവർത്തനം
(താഴെ, വിഭാഗം കാണുക മുൻകൂട്ടി നിശ്ചയിച്ചത് പ്രവർത്തനങ്ങൾ) എന്ന് വ്യക്തമായി പരിശോധിക്കാൻ ഉപയോഗിക്കാം a
ഫയൽ നിലവിലുണ്ട്).

o a പഴയത് b: ഫയലാണെങ്കിൽ 1 ആയി മാറുന്നു a ഫയലിനേക്കാൾ പഴയതാണ് b. ഉദാ, "libprog.a" പഴയത്
"source.o". ഫയലുകൾ a ഒപ്പം b നിലനിൽക്കണമെന്നില്ല: രണ്ടും ഇല്ലെങ്കിൽ 0 ആണ്
മടങ്ങി; എങ്കിൽ a നിലവിലില്ല, 1 തിരികെ ലഭിച്ചു; എങ്കിൽ b നിലവിലില്ല 0 തിരികെ നൽകുന്നു; എങ്കിൽ
അവ തുല്യമായി പഴയതാണ് 0 തിരികെ നൽകുന്നു.

o []: സൂചിക ഓപ്പറേറ്റർ ഒരു സ്ട്രിംഗ് വേരിയബിളിൽ നിന്നോ സ്ഥിരമായതിൽ നിന്നോ ഒരു പ്രതീകം വീണ്ടെടുക്കുന്നു: അത്
ഒരു സ്ട്രിംഗ് ഒരു ആയി നൽകുന്നു മൂല്യം. അതിനാൽ, ഇനിപ്പറയുന്ന പ്രസ്താവന ശരി സമാഹരിക്കുന്നു:

// str1 ഉം str2 ഉം സ്ട്രിംഗുകളാണെന്ന് കരുതുക
str1 = str2[3];

എന്നാൽ ഇനിപ്പറയുന്ന പ്രസ്താവന സമാഹരിക്കുന്നില്ല:

str2[3] = "a";

ഒരു അസാധുവായ സൂചിക മൂല്യം നൽകിയിട്ടുണ്ടെങ്കിൽ ഒരു ശൂന്യമായ സ്ട്രിംഗ് തിരികെ നൽകും.

o `ബാക്ക്ടിക്ക്` ഓപ്പറേറ്റർ (`സ്ട്രിംഗ് cmd`)
രണ്ട് ബാക്ക്ടിക്കുകൾക്കിടയിൽ സ്ഥാപിച്ചിരിക്കുന്ന ഒരു സ്ട്രിംഗ് എക്സിക്യൂട്ട് ചെയ്യുന്നു പോപ്പൻ(3) പ്രവർത്തനം. ദി
സ്ട്രിംഗ് ആർഗ്യുമെന്റിൽ സംഭരിച്ചിരിക്കുന്ന കമാൻഡ് വഴി ജനറേറ്റ് ചെയ്യുന്ന സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് ആണ്
ഒരു പട്ടികയായി മടങ്ങി. കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയില്ലെന്ന് ഒരു ശൂന്യമായ ലിസ്റ്റ് സൂചിപ്പിക്കുന്നു.
എക്സിക്യൂട്ട് ചെയ്യാവുന്ന ഒരു കമാൻഡ്, എന്നാൽ ഒരു ഔട്ട്പുട്ടും നൽകാത്ത ഒരു ലിസ്റ്റ് നൽകുന്നു
ഒരു ശൂന്യമായ ഘടകം അടങ്ങിയിരിക്കുന്നു. കമാൻഡിന്റെ സാധാരണ പിശക് സ്ട്രീം ഔട്ട്പുട്ട് അല്ല
ബാക്ക്ടിക്ക് ഓപ്പറേറ്റർ ശേഖരിച്ചത്. എന്നിരുന്നാലും, സാധാരണ ഷെൽ റീഡയറക്ഷൻ ആകാം
സാധാരണ പിശക് സ്ട്രീമിന്റെ ഔട്ട്പുട്ട് ശേഖരിക്കാൻ ഉപയോഗിക്കുന്നു. ഉദാഹരണം:

printf (`"ls"`); // ഘടകങ്ങൾ പ്രിന്റ് ചെയ്യുന്നു
// നിലവിലെ ഡയറക്ടറി

മുൻകൂട്ടി നിശ്ചയിച്ച പ്രവർത്തനം eval(സ്ട്രിംഗ് cmd) കൃത്യമായി ബാക്ക്ടിക്ക് പോലെയാണ് പെരുമാറുന്നത്
ഓപ്പറേറ്റർ: അവ പര്യായപദങ്ങളാണ്.

ലിസ്റ്റ്-ടൈപ്പ് ചെയ്തത് പ്രവർത്തനരീതി(കൾ):

വേണ്ടി പട്ടിക തരം വേരിയബിളുകൾ കൂടാതെ/അല്ലെങ്കിൽ മൂല്യങ്ങൾ ഇനിപ്പറയുന്ന ഓപ്പറേറ്റർമാർക്ക് ലഭ്യമാണ്:

o a + b: പുതിയത് തിരികെ നൽകുന്നു പട്ടിക എന്ന സംയോജനം അടങ്ങിയിരിക്കുന്ന മൂല്യം പട്ടിക മൂല്യങ്ങൾ a ഒപ്പം
b. ഇതാണ് അല്ല ഒരു സെറ്റ് ഓപ്പറേഷൻ: ഒരു ഘടകം രണ്ടിലും ദൃശ്യമാകുകയാണെങ്കിൽ a ഒപ്പം അകത്തേക്കും b, അവര് ചെയ്യും
തത്ഫലമായുണ്ടാകുന്ന ലിസ്റ്റിൽ രണ്ടുതവണ ദൃശ്യമാകും (സെറ്റ്-അഡിഷൻ നൽകുന്നത് ബിൽറ്റ്-ഇൻ ആണ്
ഫംഗ്ഷൻ കേൾക്കൽ).

o a - b: പുതിയത് തിരികെ നൽകുന്നു പട്ടിക മൂലകങ്ങൾ അടങ്ങുന്ന മൂല്യം a ഇല്ലാത്തവ
in b. ഈ is ഒരു സെറ്റ്-ഡിഫറൻസ് ഓപ്പറേഷൻ: തിരികെ നൽകിയ പട്ടികയിൽ എല്ലാ ഘടകങ്ങളും അടങ്ങിയിരിക്കുന്നു
in a എന്നതിന്റെ ഘടകങ്ങളല്ല b.

o a += b: ഘടകങ്ങൾ b ലെ ഘടകങ്ങളിലേക്ക് ചേർക്കുന്നു a, അത് ഒരു ആയിരിക്കണം പട്ടിക
വേരിയബിൾ. ഇതാണ് അല്ല ഒരു സെറ്റ് പ്രവർത്തനം.

o a -= b: ഘടകങ്ങൾ b ലെ ഘടകങ്ങളിൽ നിന്ന് നീക്കം ചെയ്യപ്പെടുന്നു a, അത് ഒരു ആയിരിക്കണം പട്ടിക
വേരിയബിൾ. ഈ is ഒരു സെറ്റ് പ്രവർത്തനം: എല്ലാ ഘടകങ്ങളും a എന്നിവയിൽ കാണപ്പെടുന്നു b ആകുന്നു
നിന്ന് നീക്കം ചെയ്തു a.

സമത്വ താരതമ്യങ്ങൾ പട്ടികപ്പെടുത്തുക: ഓപ്പറേറ്റർമാർ != ഒപ്പം == എന്നതിലേക്ക് പ്രയോഗിച്ചേക്കാം പട്ടിക മൂല്യങ്ങൾ അല്ലെങ്കിൽ
വേരിയബിളുകൾ. ഓപ്പറേറ്റർ == രണ്ട് ലിസ്റ്റുകളിലും എലമെന്റ്-ബൈ-എലമെന്റ് സമാനമാണെങ്കിൽ 1 നൽകുന്നു
ഘടകങ്ങൾ, അല്ലാത്തപക്ഷം 0 തിരികെ നൽകും. ഓപ്പറേറ്റർ != ഫലം വിപരീതമാക്കുന്നു ==.

o !a: ബൂളിയൻ ! എങ്കിൽ ഓപ്പറേറ്റർ 1 നൽകുന്നു പട്ടിക a ശൂന്യമാണ്, അല്ലാത്തപക്ഷം 0 ആണ്
മടങ്ങി.

o []: ഇൻഡെക്സ് ഓപ്പറേറ്റർ ഒരു ലിസ്റ്റ് വേരിയബിളിൽ നിന്ന് ഒരു ലിസ്റ്റ് ഘടകം വീണ്ടെടുക്കുന്നു: അത് a നൽകുന്നു
ഒരു പോലെ സ്ട്രിംഗ് മൂല്യം. അതിനാൽ, ഇനിപ്പറയുന്ന പ്രസ്താവന ശരി സമാഹരിക്കുന്നു:

// lst ഒരു ലിസ്റ്റാണെന്നും str ഒരു സ്ട്രിംഗ് ആണെന്നും കരുതുക
str = lst[3];

എന്നാൽ ഇനിപ്പറയുന്ന പ്രസ്താവന സമാഹരിക്കുന്നില്ല:

lst[3] = str;

ഒരു അസാധുവായ സൂചിക മൂല്യം നൽകിയിട്ടുണ്ടെങ്കിൽ ഒരു ശൂന്യമായ സ്ട്രിംഗ് തിരികെ നൽകും.

കാസ്റ്റിംഗ്:

സ്റ്റാൻഡേർഡ് ഉപയോഗിച്ച് ടൈപ്പ് കാസ്റ്റുകൾ നടത്താം C കാസ്റ്റ് ചെയ്യാനുള്ള കാസ്റ്റ് ഓപ്പറേറ്റർ:

o സ്ട്രിംഗുകൾ മുതൽ ints വരെ തിരിച്ചും ((int)"123", (സ്ട്രിംഗ്)55)

o ലിസ്റ്റുകളിലേക്കുള്ള സ്ട്രിംഗുകൾ (പട്ടിക ലിസ്റ്റ് = (ലിസ്റ്റ്) "ഹലോ")

പറ നിയന്ത്രണം


ഐക്മേക്ക് ഇനിപ്പറയുന്ന ഉപസെറ്റ് വാഗ്ദാനം ചെയ്യുന്നു Cയുടെ പ്രസ്താവനകൾ. അവയിൽ ഉള്ളതുപോലെ ഉപയോഗിക്കാം C
പ്രോഗ്രാമിങ് ഭാഷ.

o പദപ്രയോഗം ;
പ്ലെയിൻ എക്സ്പ്രഷൻ സ്റ്റേറ്റ്മെന്റ്;

ഒ സംയുക്ത പ്രസ്താവന
ഏത് തരത്തിലുള്ള വേരിയബിളുകളും ഏതെങ്കിലും സംയുക്തത്തിനുള്ളിൽ എവിടെയും നിർവചിക്കുകയും ആരംഭിക്കുകയും ചെയ്യാം
പ്രസ്താവന. ദി കാണാവുന്ന ഒരു വേരിയബിളിന്റെ നിർവചന പോയിന്റിൽ ആരംഭിക്കുന്നു.

o if (അവസ്ഥ) പ്രസ്താവന
വ്യവസ്ഥയ്ക്കുള്ളിൽ ഒരു വേരിയബിൾ നിർവചിക്കുകയും സമാരംഭിക്കുകയും ചെയ്യാം. ഉദാ,

എങ്കിൽ (സ്ട്രിംഗ് str = getText())
പ്രക്രിയ(str);

ഈ ഉദാഹരണത്തിൽ, പ്രക്രിയ എങ്കിൽ വിളിക്കില്ല getText () ഒരു ശൂന്യമായ സ്ട്രിംഗ് തിരികെ നൽകുന്നു. ദി
വേരിയബിൾ str മുമ്പോ ശേഷമോ നിലവിലില്ല if പ്രസ്താവന.

o if (അവസ്ഥ) പ്രസ്താവന മറ്റാരെങ്കിലും പ്രസ്താവന
മുമ്പത്തെ പ്രസ്താവന പോലെ, വ്യവസ്ഥയ്ക്കുള്ളിൽ ഒരു വേരിയബിൾ നിർവചിക്കാം
ആരംഭിച്ചത്.

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

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

അതേസമയം (int x = 10)
printf(x--, "\n");

o മടങ്ങിവരുക, ഒപ്പം മടക്കം ആവിഷ്കാരം;
പ്ലെയിൻ മടക്കം എന്നതിൽ പ്രസ്താവനകൾ ഉപയോഗിക്കാം ശൂന്യം പ്രവർത്തനങ്ങൾ, ഒപ്പം മടക്കം പദപ്രയോഗം
പ്രസ്താവനകൾ മറ്റ് തരത്തിലുള്ള ഫംഗ്ഷനുകളിൽ ഉപയോഗിക്കുന്നു. ചടങ്ങ് പ്രധാന റിട്ടേൺ തരം ഉണ്ട്
ശൂന്യം അങ്ങനെ അകത്ത് പ്രധാന പ്ലെയിൻ മാത്രം മടക്കം പ്രസ്താവനകൾ ഉപയോഗിക്കാം. സ്ഥിരസ്ഥിതിയായി ഒരു icmake
സ്ക്രിപ്റ്റിന്റെ എക്സിറ്റ് മൂല്യം 0 ആണ്. ബിൽറ്റ്-ഇൻ ഫംഗ്ഷൻ ഉപയോഗിക്കുക പുറത്ത് (ചുവടെ കാണുക) വ്യക്തമാക്കാൻ
മറ്റേതെങ്കിലും എക്സിറ്റ് മൂല്യം.

Be ഉപദേശിച്ചു: മൂല്യങ്ങൾ തിരികെ നൽകാത്ത അസാധുവായ ഫംഗ്‌ഷനുകളുടെ സ്വഭാവം നിർവചിക്കപ്പെട്ടിട്ടില്ല.

o ഇടവേള
ഇലകൾ വേണ്ടി ഒപ്പം സമയത്ത് പ്രസ്താവനകൾ, പ്രസ്താവനയുടെ അവസ്ഥയെ മറികടക്കുന്നു.

o തുടരുക
a യുടെ അടുത്ത ആവർത്തനത്തോടെ തുടരുന്നു വേണ്ടി or സമയത്ത് പ്രസ്താവന.

o പുറത്തുകടക്കുക (എക്സ്പ്രഷൻ)
ഒരു എക്സിക്യൂഷൻ അവസാനിപ്പിക്കുന്നു icmake- സ്ക്രിപ്റ്റ്. ദി പദപ്രയോഗം ഒരു വരെ വിലയിരുത്തണം int
മൂല്യം, അത് സ്ക്രിപ്റ്റിന്റെ എക്സിറ്റ് മൂല്യമായി മാറുന്നു.

മുൻകൂട്ടി നിശ്ചയിച്ചത് പ്രവർത്തനങ്ങൾ


ഐക്മേക്ക് താഴെപ്പറയുന്ന മുൻനിശ്ചയിച്ച ഫംഗ്‌ഷനുകൾ വാഗ്ദാനം ചെയ്യുന്നു, അത് എവിടെയും ഉപയോഗിക്കാനാകും icmake
സ്ക്രിപ്റ്റുകൾ. ഇനിപ്പറയുന്ന അവലോകനം ഫംഗ്‌ഷൻ നാമമനുസരിച്ച് അക്ഷരമാലാക്രമത്തിൽ ക്രമീകരിച്ചിരിക്കുന്നു.

o ശൂന്യം ആർഗ്ഹെഡ്(സ്ട്രിംഗ് h)
എന്ന സഹായി പ്രവർത്തനം എക്സിക്() (ചുവടെയും കാണുക എക്സിക്()): `ആർഗ്യുമെന്റ് ഹെഡ്' നിർവചിക്കുന്നു,
കൂടെ ഉപയോഗിക്കേണ്ടതാണ് എക്സിക്(). ഡിഫോൾട്ടായി, `ആർഗ്യുമെന്റ് ഹെഡ്' ഒരു ശൂന്യമായ സ്ട്രിംഗാണ്.

o ശൂന്യം argtail (സ്ട്രിംഗ് t)
എന്ന സഹായി പ്രവർത്തനം എക്സിക്() (ചുവടെയും കാണുക എക്സിക്()): `ആർഗ്യുമെന്റ് ടെയിൽ' നിർവചിക്കുന്നു,
കൂടെ ഉപയോഗിക്കേണ്ടതാണ് എക്സിക്(). ഡിഫോൾട്ടായി, `ആർഗ്യുമെന്റ് ടെയിൽ' ഒരു ശൂന്യമായ സ്ട്രിംഗാണ്.

o int ascii(സ്ട്രിംഗ് s)
എന്നതിന്റെ ആദ്യ പ്രതീകം നൽകുന്നു s ഒരു സംഖ്യയായി; ഉദാ, ascii("A") തിരികെ 65;

o സ്ട്രിംഗ് ascii(int i)
റിട്ടേൺസ് i ഒരു സ്ട്രിംഗായി, ഉദാ, ASCII(65) സ്ട്രിംഗ് തിരികെ നൽകുന്നു "എ";

o സ്ട്രിംഗ് change_base(string ഫയൽ, സ്ട്രിംഗ് പുതിയ അടിത്തറ)
എന്നതിന്റെ അടിസ്ഥാന നാമം മാറ്റുന്നു ഫയല്, മാറ്റിയ പേര് തിരികെ നൽകുന്നു. ഉദാ,
change_base("/path/demo.im", "പുറത്ത്") വരുമാനം "/path/out.im";

o സ്ട്രിംഗ് change_ext(സ്ട്രിംഗ് ഫയൽ, സ്ട്രിംഗ് പുതിയത്)
ന്റെ വിപുലീകരണം മാറ്റുന്നു ഫയല്, മാറ്റിയ പേര് തിരികെ നൽകുന്നു. ഉദാ,
rss_changeExt("source.cc", "o") വരുമാനം "source.o";

o സ്ട്രിംഗ് change_path(സ്ട്രിംഗ് ഫയൽ, സ്ട്രിംഗ് പുതിയ പാത)
എന്നതിന്റെ പാത്ത് സ്പെസിഫിക്കേഷൻ മാറ്റുന്നു ഫയല്, മാറ്റിയ പേര് തിരികെ നൽകുന്നു. ഉദാ,
change_path("tmp/ബൈനറി", "/ usr / bin") വരുമാനം "/usr/bin/binary". ശ്രദ്ധിക്കുക
/ആവശ്യമെങ്കിൽ - വേർതിരിക്കൽ ചേർത്തിരിക്കുന്നു.

o സ്ട്രിംഗ് chdir(സ്ട്രിംഗ് newdir)
സ്‌ക്രിപ്റ്റിന്റെ പ്രവർത്തന ഡയറക്‌ടറി മാറ്റുന്നു, മുമ്പത്തെ ഡയറക്‌ടറി ഒരു സമ്പൂർണ്ണമായി നൽകുന്നു
പാത.

ഉപയോഗം chdir("") നിലവിലുള്ള വർക്കിംഗ് ഡയറക്ടറി ലഭിക്കുന്നതിന്, chdir("") ഉപയോഗിച്ചേക്കാം
സ്റ്റാർട്ടപ്പ് വർക്കിംഗ് ഡയറക്ടറി നേടുക (റിലീസുകളിൽ ഈ പ്രവർത്തനം തകർന്നിരിക്കുന്നു
7.00-ന് മുമ്പ്, എന്നാൽ ഇപ്പോൾ പ്രവർത്തനക്ഷമമാണ്). പ്രവർത്തനം അവസാനിപ്പിക്കുന്നു
icmake-സ്ക്രിപ്റ്റ് വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ newdir നിലവിലില്ല.

o സ്ട്രിംഗ് chdir(int പരിശോധിക്കുന്നു, സ്ട്രിംഗ് newdir)
മുമ്പത്തെ ഫംഗ്‌ഷന്റെ അതേ പ്രവർത്തനക്ഷമത, എന്നാൽ വ്യക്തമാക്കുന്നതിലൂടെ പരിശോധിക്കുന്നു as
P_NOCHECK. ഫംഗ്ഷൻ സ്ക്രിപ്റ്റ് അവസാനിപ്പിക്കില്ല. മറിച്ച്, അത് തിരികെ നൽകും
സ്ക്രിപ്റ്റിന്റെ നിലവിലെ പ്രവർത്തന ഡയറക്ടറി.

o cmdhead(സ്ട്രിംഗ് h)
എന്ന സഹായി പ്രവർത്തനം എക്സിക്() (ചുവടെയും കാണുക എക്സിക്()): ഒരു `കമാൻഡ് ഹെഡ്' നിർവചിക്കുന്നു, to
ഉപയോഗിച്ച് ഉപയോഗിക്കാം എക്സിക്(). സ്ഥിരസ്ഥിതിയായി, `കമാൻഡ് ഹെഡ്' ഒരു ശൂന്യമായ സ്ട്രിംഗാണ്.

o cmdtail(സ്ട്രിംഗ് t)
എന്ന സഹായി പ്രവർത്തനം എക്സിക്() (ചുവടെയും കാണുക എക്സിക്()): ഒരു `കമാൻഡ് ടെയിൽ' നിർവചിക്കുന്നു, to
ഉപയോഗിച്ച് ഉപയോഗിക്കാം എക്സിക്(). സ്ഥിരസ്ഥിതിയായി, `കമാൻഡ് ടെയിൽ' ഒരു ശൂന്യമായ സ്ട്രിംഗാണ്.

o echo(int തിരഞ്ഞെടുക്കുക)
വിളിക്കപ്പെടുന്ന പ്രോഗ്രാമുകളുടെ പ്രതിധ്വനി നിയന്ത്രിക്കുന്നു (അവരുടെ വാദങ്ങളും), വ്യക്തമാക്കുക ഓഫാണ് പ്രതിധ്വനിക്കുകയാണെങ്കിൽ
ആവശ്യപ്പെട്ടിട്ടില്ല. സ്ഥിരസ്ഥിതിയായി പ്രതിധ്വനി (ഓൺ) ഉപയോഗിക്കുന്നു.

o സ്ട്രിംഗ് ഘടകം(int സൂചിക, പട്ടിക (അഥവാ സ്ട്രിംഗ്) var)
ഇൻഡക്‌സ് ഓപ്പറേറ്റർക്ക് സമാനമായ പ്രവൃത്തികൾ: സൂചികയെ റഫർ ചെയ്യുക ([]) ഓപ്പറേറ്റർ
വിഭാഗം ഓപ്പറേറ്റർമാർ.

o പട്ടിക eval(സ്ട്രിംഗ് str)
ഈ ഫംഗ്‌ഷൻ ബാക്ക്‌ടിക്ക് ഓപ്പറേറ്ററിന് സമാനമായി പ്രവർത്തിക്കുന്നു. നൽകിയ ഉദാഹരണം
അതിനാൽ ബാക്ക്ടിക്ക് ഓപ്പറേറ്റർ ഇതുപോലെ എഴുതാമായിരുന്നു:

printf(eval("ls")); // കറന്റിലുള്ള ഘടകങ്ങൾ പ്രിന്റ് ചെയ്യുന്നു
// ഡയറക്ടറി

o exec(സ്ട്രിംഗ് cmd, ...)
ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഓരോ ആർഗ്യുമെന്റും പ്രിഫിക്‌സ് ചെയ്യും arghead()എന്നയാളുടെ
വാദവും പോസ്റ്റ് ഫിക്സഡ് argtail()യുടെ വാദം. ശൂന്യതകളൊന്നും ചേർത്തിട്ടില്ലെന്നത് ശ്രദ്ധിക്കുക
തമ്മിലുള്ള arghead()ന്റെ ഉള്ളടക്കം, ശരിയായ വാദം, കൂടാതെ argtail()യുടെ വാദം. എല്ലാം
അങ്ങനെ പരിഷ്കരിച്ച ആർഗ്യുമെന്റുകൾ സംയോജിപ്പിച്ചിരിക്കുന്നു, ഇത്തവണ ഒറ്റ ശൂന്യതകളാൽ വേർതിരിച്ചിരിക്കുന്നു, ഒപ്പം
അപ്പോള് cmdhead()കമാൻഡിനും ആദ്യത്തെ ആർഗ്യുമെന്റിനുമിടയിൽ ന്റെ ഉള്ളടക്കങ്ങൾ ചേർത്തിരിക്കുന്നു
(ഇരുവശവും ഒറ്റ ശൂന്യതയാൽ വേർതിരിച്ചിരിക്കുന്നു) കൂടാതെ cmdtail()യുടെ ഉള്ളടക്കങ്ങൾ ചേർത്തിരിക്കുന്നു
വാദഗതികളിലേക്ക് (വീണ്ടും, ഒരൊറ്റ ശൂന്യത കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു). PATH കണ്ടെത്താൻ തിരച്ചിൽ നടത്തുന്നു
cmd. 0 തിരികെ ലഭിച്ചു.

o എക്സിക്(int ചെക്ക് സിഎംഡി, സ്ട്രിംഗ് cmd, ...)
മുമ്പത്തെ ഫംഗ്‌ഷന്റെ അതേ പ്രവർത്തനക്ഷമത, എന്നാൽ വ്യക്തമാക്കുന്നതിലൂടെ പരിശോധിക്കുന്നു as
NOT_CHECKED ഫംഗ്ഷൻ സ്ക്രിപ്റ്റ് അവസാനിപ്പിക്കില്ല. മറിച്ച്, അത് തിരികെ നൽകും
കമാൻഡിന്റെ എക്സിറ്റ് സ്റ്റാറ്റസ് എന്ന് വിളിക്കുന്നു, അല്ലെങ്കിൽ 0x7f00 കമാൻഡ് കണ്ടെത്തിയില്ലെങ്കിൽ.

o എക്സിക്യൂട്ട് (സ്ട്രിംഗ് cmd, സ്ട്രിംഗ് cmdhd, സ്ട്രിംഗ് ശരി, ..., സ്ട്രിംഗ് argtl, സ്ട്രിംഗ് cmdtl)
അതുപോലെ തന്നെ എക്സിക്(), എന്നാൽ കമാൻഡ് ഹെഡ്/ടെയിൽ, ആർഗ്യുമെന്റ് ഹെഡ്/ടെയിൽ എന്നിവ വ്യക്തമാക്കണം.

യഥാർത്ഥത്തിൽ നടപ്പിലാക്കിയ കമാൻഡ് ആരംഭിക്കുന്നത് cmd, അതിനുശേഷം cmdhd. അടുത്തത് ഒരു പരമ്പരയാണ്
വാദങ്ങൾ പിന്തുടരുന്നു, ഓരോന്നിനും ചുറ്റപ്പെട്ടിരിക്കുന്നു arghd ഒപ്പം argtl. കമാൻഡ് അവസാനിക്കുന്നു
cmdtl. 0 തിരികെ ലഭിച്ചു

o എക്സിക്യൂട്ട് (int പരിശോധിക്കുന്നു, സ്ട്രിംഗ് cmd, സ്ട്രിംഗ് cmdhd, സ്ട്രിംഗ് ശരി, ..., സ്ട്രിംഗ് argtl,
സ്ട്രിംഗ് cmdtl)
മുമ്പത്തെ ഫംഗ്‌ഷന്റെ അതേ പ്രവർത്തനക്ഷമത, എന്നാൽ വ്യക്തമാക്കുന്നതിലൂടെ പരിശോധിക്കുന്നു as
NOT_CHECKED ഫംഗ്ഷൻ സ്ക്രിപ്റ്റ് അവസാനിപ്പിക്കില്ല. മറിച്ച്, അത് തിരികെ നൽകും
കമാൻഡിന്റെ എക്സിറ്റ് സ്റ്റാറ്റസ് എന്ന് വിളിക്കുന്നു, അല്ലെങ്കിൽ 0x7f00 കമാൻഡ് കണ്ടെത്തിയില്ലെങ്കിൽ.

o int നിലവിലുണ്ട് (സ്ട്രിംഗ് ഫയൽ)
എങ്കിൽ പൂജ്യമല്ലാത്ത മൂല്യം നൽകുന്നു ഫയല് നിലവിലുണ്ട്, അല്ലെങ്കിൽ 0 തിരികെ നൽകും.

o പട്ടിക fgets(സ്ട്രിംഗ് ഫയൽ, പട്ടിക ഓഫ്സെറ്റ്)
ശ്രദ്ധിക്കുക: in icmake പതിപ്പ് 8.00.00 എന്നതിൽ നിന്ന് ഈ ഫംഗ്‌ഷന്റെ പ്രോട്ടോടൈപ്പ് മാറ്റി
പട്ടിക fgets(സ്ട്രിംഗ് ഫയൽ, int ഓഫ്സെറ്റ്) ലേക്ക് പട്ടിക fgets(സ്ട്രിംഗ് ഫയൽ, പട്ടിക ഓഫ്സെറ്റ്).

അടങ്ങുന്ന ഓഫ്‌സെറ്റിൽ അടുത്ത വരി കണ്ടെത്തി ഓഫ്സെറ്റ് എന്നതിൽ നിന്ന് വായിക്കുന്നു ഫയല്. ഒരു പാസ്സ്
ശൂന്യമായ ലിസ്റ്റ് fgets വായിക്കാൻ ഫയല് അതിന്റെ തുടക്കം മുതൽ.

റീഡ് ലൈനിലെ ഉള്ളടക്കങ്ങൾ അതിന്റെ ആദ്യ ഘടകമായി ഉൾക്കൊള്ളുന്ന ഒരു ലിസ്റ്റ് ഇത് നൽകുന്നു
(കൂടാതെ \n ലൈൻ ടെർമിനേറ്റർ), അതിന്റെ രണ്ടാമത്തെ ഘടകമായി ലൈനിന്റെ ടെർമിനേറ്റർ `\n'
(കണ്ടുപിടിച്ചാൽ), അതിന്റെ മൂന്നാമത്തെ ഘടകമായി സ്ട്രിംഗ് OK ഒരു ലൈൻ വിജയകരമായിരുന്നുവെങ്കിൽ
വായിക്കുക, പരാജയം ഫയലിൽ നിന്നുള്ള വായന പരാജയപ്പെട്ടാൽ. EOF-ൽ വായിക്കുമ്പോൾ ഒരു ശൂന്യമായ ലിസ്റ്റ് ആണ്
മടങ്ങി. തിരികെ നൽകിയ പട്ടികയിൽ അധിക ഘടകങ്ങൾ അടങ്ങിയിരിക്കാം, അവ ആന്തരികമാണ്
ഉപയോഗിച്ചത് fgets അടുത്ത വരി വായിക്കുമ്പോൾ.

ഒന്നിലധികം വരികൾ വായിക്കാൻ, ഒരു ശൂന്യമായ ലിസ്റ്റ് ഇതായി പാസ്സാക്കി തുടങ്ങുക ലഭിക്കുന്നു രണ്ടാമത്തെ വാദം.
തുടർന്നുള്ള വരികൾ വായിക്കാൻ, മുമ്പ് നൽകിയ ലിസ്റ്റ് കൈമാറുക fgets ന്റെ സെക്കന്റ്
വാദം.

ഒരു പൂർണ്ണമായ ഫയൽ എങ്ങനെ വായിക്കാമെന്ന് കാണിക്കുന്ന ഒരു ഉദാഹരണം ഇതാ:

ലിസ്റ്റ് റിട്ട്;
അതേസമയം (1)
{
ret = fgets("ഫയലിന്റെ പേര്", ret);
എങ്കിൽ (! റിട്ട്)
പൊട്ടി;
പ്രക്രിയ(ret[0], ret[1]);
}

o int fprintf(സ്ട്രിംഗ് ഫയലിന്റെ പേര്, ...)
ഫയലിലേക്ക് എല്ലാ (കോമ വേർതിരിക്കപ്പെട്ട) ആർഗ്യുമെന്റുകളും കൂട്ടിച്ചേർക്കുന്നു ഫയലിന്റെ പേര്. ഇവയുടെ എണ്ണം നൽകുന്നു
അച്ചടിച്ച വാദങ്ങൾ.

o int fprintf(സ്ട്രിംഗ് ഫയലിന്റെ പേര്, സ്ട്രിംഗ് ഫോർമാറ്റ്, ...)
ഫയലിലേക്ക് എല്ലാ (കോമ വേർതിരിക്കപ്പെട്ട) ആർഗ്യുമെന്റുകളും കൂട്ടിച്ചേർക്കുന്നു ഫയലിന്റെ പേര്. ഇവയുടെ എണ്ണം നൽകുന്നു
അച്ചടിച്ച വാദങ്ങൾ.

If ഫോർമാറ്റ് പ്ലേസ്‌ഹോൾഡറുകൾ അടങ്ങിയിരിക്കുന്നു % 1 .. %n ഔട്ട്‌പുട്ട് ഫോർമാറ്റ് ചെയ്‌തിരിക്കുന്നു (ഇതും കാണുക
strformat). ഈ സാഹചര്യത്തിൽ ആർഗ്യുമെന്റ് കൗണ്ടിംഗ് (കൂടാതെ) എന്നതിനപ്പുറം ആരംഭിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക
ഫോർമാറ്റ് സ്ട്രിംഗ്: ഇനിപ്പറയുന്ന ആദ്യത്തെ ആർഗ്യുമെന്റ് ഫോർമാറ്റ് എന്ന് പരാമർശിക്കുന്നു %1.

o സ്ട്രിംഗ് get_base(string ഫയൽ)
എന്നതിന്റെ അടിസ്ഥാന നാമം നൽകുന്നു ഫയല്. പാത്ത് പ്രിഫിക്‌സ് ഇല്ലാത്ത ഫയലാണ് അടിസ്ഥാന നാമം
അതിന്റെ വിപുലീകരണം കൂടാതെ. വിപുലീകരണം അവസാന ഘട്ടത്തിൽ ആരംഭിക്കുന്ന എല്ലാ വിവരങ്ങളും ആണ്
ഫയലിന്റെ പേരിൽ ഡോട്ട്. അന്തിമ ഡോട്ട് കണ്ടെത്തിയില്ലെങ്കിൽ, ഫയലിന്റെ പേര് അടിസ്ഥാന നാമമാണ്.
ഉദാ, അടിസ്ഥാന നാമം എബി തുല്യമാണ് a, അടിസ്ഥാന നാമം abc തുല്യമാണ് എബി, അടിത്തറ
പേര് a/b/c തുല്യമാണ് c.

o സ്ട്രിംഗ് നേടുക()
അടുത്ത അമർത്തിയ കീ ഒരു സ്ട്രിംഗ് ആയി നൽകുന്നു (`Enter' അമർത്തുന്നത് ആവശ്യമില്ല).

o സ്ട്രിംഗ് get_dext(സ്ട്രിംഗ് ഫയൽ)
എന്നതിന്റെ വിപുലീകരണം നൽകുന്നു ഫയല്, വേർതിരിക്കുന്ന ഡോട്ട് ഉൾപ്പെടെ. വിപുലീകരണം എല്ലാം
ഫയൽനാമത്തിന്റെ അവസാന ഡോട്ടിൽ തുടങ്ങുന്ന വിവരങ്ങൾ.

അന്തിമ ഡോട്ട് കണ്ടെത്തിയില്ലെങ്കിൽ, ഒരു ശൂന്യമായ സ്ട്രിംഗ് തിരികെ നൽകും.

o പട്ടിക getenv(സ്ട്രിംഗ് envvar)
പരിസ്ഥിതി വേരിയബിളിന്റെ മൂല്യം നൽകുന്നു envvar രണ്ട് ഘടകങ്ങൾ അടങ്ങിയ ഒരു പട്ടികയിൽ:

പരിസ്ഥിതി വേരിയബിൾ നിർവചിക്കപ്പെട്ടിട്ടുണ്ടോ എന്ന് ആദ്യ ഘടകം സൂചിപ്പിക്കുന്നു (മൂല്യം
"ക്സനുമ്ക്സ") അല്ലെങ്കിൽ അല്ല (മൂല്യം "ക്സനുമ്ക്സ");
രണ്ടാമത്തെ ഘടകം പരിസ്ഥിതി വേരിയബിളിന്റെ മൂല്യത്തെ സൂചിപ്പിക്കുന്നു.

പരിസ്ഥിതി വേരിയബിളുകൾ രൂപത്തിലുള്ളതാണ് വേരിയബിൾ = മൂല്യം, കൂടാതെ പട്ടികയുടെ നിർവചിച്ചാൽ
രണ്ടാമത്തെ ഘടകം അടങ്ങിയിരിക്കുന്നു മൂല്യം. മൂല്യം ശൂന്യമാണെങ്കിൽ, വേരിയബിൾ നിർവചിക്കപ്പെടുന്നു, പക്ഷേ
അതുമായി ബന്ധപ്പെട്ട ഒരു വാചകവുമില്ല.

o സ്ട്രിംഗ് get_ext(സ്ട്രിംഗ് ഫയൽ)
എന്നതിന്റെ വിപുലീകരണം നൽകുന്നു ഫയല്, വേർതിരിക്കുന്ന ഡോട്ട് ഒഴികെ. വിപുലീകരണം എല്ലാം
ഫയൽ നാമത്തിലെ അവസാന ഡോട്ടിൽ ആരംഭിക്കുന്ന വിവരങ്ങൾ.

അന്തിമ ഡോട്ട് കണ്ടെത്തിയില്ലെങ്കിൽ, ഒരു ശൂന്യമായ സ്ട്രിംഗ് തിരികെ നൽകും.

o int getpid()
icmake ബൈറ്റ് കോഡ് ഇന്റർപ്രെറ്ററിന്റെ പ്രോസസ്സ്-ഐഡി നൽകുന്നു icm-exec.

o സ്ട്രിംഗ് ലഭിക്കുന്നു ()
കീബോർഡിൽ നിന്ന് വായിച്ച അടുത്ത വരി a ആയി നൽകുന്നു സ്ട്രിംഗ്. എന്നതിൽ ലൈൻ പ്രവേശിച്ചു
റിട്ടേണിൽ സംഭരിച്ചിട്ടില്ലാത്ത ഒരു `Enter' കീ ഉപയോഗിച്ച് കീബോർഡ് അവസാനിപ്പിക്കണം
സ്ട്രിംഗ്.

o സ്ട്രിംഗ് get_path(സ്ട്രിംഗ് ഫയൽ)
എന്നതിന്റെ പാത്ത്-പ്രിഫിക്‌സ് നൽകുന്നു ഫയല്. പാത്ത് പ്രിഫിക്‌സ് എന്നത് വരെയുള്ള എല്ലാ വിവരങ്ങളും (ഒപ്പം
ഉൾപ്പെടെ) അവസാന ഡയറക്ടറി സെപ്പറേറ്റർ (അതായത്, പ്രവർത്തനത്തെ ആശ്രയിച്ചിരിക്കുന്നു
സിസ്റ്റം, ഒരു ഫോർവേഡ്- അല്ലെങ്കിൽ ബാക്ക്സ്ലാഷ്).

ഒരു പാതയും കണ്ടെത്തിയില്ലെങ്കിൽ, ഒരു ശൂന്യമായ സ്ട്രിംഗ് തിരികെ നൽകും.

o int ലിസ്റ്റ്ഫൈൻഡ്(ലിസ്റ്റ് lst, സ്ട്രിംഗ് str)
ആദ്യ സൂചിക തിരികെ നൽകുന്നു ലിസ്റ്റ് എവിടെ ചരട് str കണ്ടെത്തി, അല്ലെങ്കിൽ -1 എങ്കിൽ ലിസ്റ്റ് ഇല്ല
അടങ്ങിയിട്ടുണ്ട് str.

o int ലിസ്റ്റ്ലെൻ(ലിസ്റ്റ് l)
മൂലകങ്ങളുടെ എണ്ണം നൽകുന്നു പട്ടിക.

o പട്ടിക ലിസ്‌റ്റൂണിയൻ(ലിസ്റ്റ് lhs, പട്ടിക rhs)
മൂലകങ്ങളുടെ യൂണിയൻ അടങ്ങുന്ന ഒരു ലിസ്റ്റ് നൽകുന്നു lhs ഒപ്പം rhs.

o പട്ടിക ലിസ്‌റ്റൂണിയൻ(ലിസ്റ്റ് lst, സ്ട്രിംഗ് str)
മൂലകങ്ങളുടെ യൂണിയൻ അടങ്ങുന്ന ഒരു ലിസ്റ്റ് നൽകുന്നു ലിസ്റ്റ് ഒപ്പം str.

o പട്ടിക മേക്ക്‌ലിസ്റ്റ്(സ്ട്രിംഗ് മാസ്ക്)
പൊരുത്തപ്പെടുന്ന എല്ലാ ഫയലുകളുടെയും ഒരു ലിസ്റ്റ് നൽകുന്നു പൊയ്മുഖം. ഉദാ, മേക്ക്‌ലിസ്റ്റ്("*.c") ഒരു ലിസ്റ്റ് തിരികെ നൽകുന്നു
അവസാനിക്കുന്ന എല്ലാ ഫയലുകളും അടങ്ങിയിരിക്കുന്നു .c.

o പട്ടിക മേക്ക്‌ലിസ്റ്റ്(തരം, സ്ട്രിംഗ് മാസ്ക്)
മുമ്പത്തെ ഫംഗ്‌ഷൻ പോലെ തന്നെ, പക്ഷേ ഡയറക്‌ടറി ഘടകങ്ങളുടെ തരം ആയിരിക്കാം
അതിന്റെ ആദ്യ വാദമായി വ്യക്തമാക്കിയിരിക്കുന്നു:

ചിഹ്ന അർത്ഥം
IS_ALL എല്ലാ ഡയറക്‌ടറി എൻട്രികളും നേടുന്നു
IS_DIR ഉൾപ്പെടെ എല്ലാ ഡയറക്ടറികളും നേടുന്നു. ഒപ്പം ..
IS_FILE ഫയലുകളുടെ ഒരു ലിസ്റ്റ് നേടുന്നു
IS_SUBDIR എല്ലാ ഉപഡയറക്‌ടറികളും നേടുന്നു

പാറ്റേൺ എന്നത് ശ്രദ്ധിക്കുക * Unix-type ഓപ്പറേറ്റിംഗ് കീഴിലുള്ള മറഞ്ഞിരിക്കുന്ന എൻട്രികളുമായി പൊരുത്തപ്പെടുന്നില്ല
സംവിധാനങ്ങൾ. ഉപയോഗിക്കുക .* അതിനു വേണ്ടി.

o പട്ടിക മേക്ക്‌ലിസ്റ്റ്(സ്ട്രിംഗ് മാസ്ക്, പുതിയത്, സ്ട്രിംഗ് താരതമ്യം ചെയ്യുക)
നൽകിയിരിക്കുന്നതിലും പുതിയവയുമായി പൊരുത്തപ്പെടുന്ന എല്ലാ ഫയലുകളുടെയും ലിസ്റ്റ് നൽകുന്നു
താരതമ്യം ചെയ്യുക. ഓപ്പറേറ്റർ ചെറുപ്പക്കാരൻ പകരം ഉപയോഗിക്കാം പുതിയത്. അതല്ല പുതിയത് ഒപ്പം
ചെറുപ്പക്കാരൻ ഓപ്പറേറ്റർമാരാണ്, സ്ട്രിംഗുകളല്ല.

o പട്ടിക makelist([int = IS_FILE,] സ്ട്രിംഗ് മാസ്ക്, പുതിയത്, സ്ട്രിംഗ് താരതമ്യം ചെയ്യുക)
മുമ്പത്തെ പ്രവർത്തനത്തിന് സമാനമാണ്, പക്ഷേ ടൈപ്പ് ചെയ്യുക എന്നതുപോലെ വ്യക്തമാക്കിയേക്കാം പട്ടിക മേക്ക്‌ലിസ്റ്റ്(തരം,
സ്ട്രിംഗ് മാസ്ക്).

o മേക്ക്‌ലിസ്റ്റ്(സ്ട്രിംഗ് മാസ്ക്, പഴയ, സ്ട്രിംഗ് താരതമ്യം ചെയ്യുക)
മുകളിൽ കാണുന്ന; comparefile-നേക്കാൾ പഴയ ഫയലുകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു.

o മേക്ക്‌ലിസ്റ്റ്(തരം, സ്ട്രിംഗ് മാസ്ക്, പഴയ, സ്ട്രിംഗ് താരതമ്യം ചെയ്യുക)
മുമ്പത്തെ പ്രവർത്തനത്തിന് സമാനമാണ്, പക്ഷേ ടൈപ്പ് ചെയ്യുക എന്നതുപോലെ വ്യക്തമാക്കിയേക്കാം പട്ടിക മേക്ക്‌ലിസ്റ്റ്(തരം,
സ്ട്രിംഗ് മാസ്ക്).

o int printf(...)
സ്ക്രീനിലേക്ക് (അതായത്, സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് സ്ട്രീം) എല്ലാ (കോമയാൽ വേർതിരിച്ച) ആർഗ്യുമെന്റുകളും കാണിക്കുന്നു.
അച്ചടിച്ച ആർഗ്യുമെന്റുകളുടെ എണ്ണം നൽകുന്നു.

o int printf(സ്ട്രിംഗ് ഫോർമാറ്റ്, ...)
സ്ക്രീനിലേക്ക് (അതായത്, സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് സ്ട്രീം) എല്ലാ (കോമയാൽ വേർതിരിച്ച) ആർഗ്യുമെന്റുകളും കാണിക്കുന്നു.
അച്ചടിച്ച ആർഗ്യുമെന്റുകളുടെ എണ്ണം നൽകുന്നു (the ഫോർമാറ്റ് സ്ട്രിംഗ് ഒരു ആർഗ്യുമെന്റായി കണക്കാക്കുന്നു).

If ഫോർമാറ്റ് പ്ലേസ്‌ഹോൾഡറുകൾ അടങ്ങിയിരിക്കുന്നു % 1 .. %n ഔട്ട്‌പുട്ട് ഫോർമാറ്റ് ചെയ്‌തിരിക്കുന്നു (ഇതും കാണുക
strformat).

o int putenv(സ്ട്രിംഗ് envvar)
ചേർക്കുന്നു envvar കറന്റിലേക്ക് (icmake) പരിസ്ഥിതി ഫോർമാറ്റ് ഉപയോഗിക്കുക: "VAR=value".
0 നൽകുന്നു.

o സ്ട്രിംഗ് വലുപ്പം മാറ്റുക(സ്ട്രിംഗ് str, int പുതിയ നീളം) സ്ട്രിംഗിന്റെ ഒരു പകർപ്പ് നൽകുന്നു str, വലുപ്പം മാറ്റി
പുതിയ നീളം കഥാപാത്രങ്ങൾ. എങ്കിൽ പുതിയ നീളം നെഗറ്റീവ് ആണെങ്കിൽ ഒരു ശൂന്യമായ സ്ട്രിംഗ് തിരികെ ലഭിക്കും,
if പുതിയ നീളം കവിഞ്ഞു str's ദൈർഘ്യം തുടർന്ന് പുതുതായി ചേർത്ത പ്രതീകങ്ങൾ ആരംഭിക്കുന്നു
ശൂന്യമായ ഇടങ്ങളിലേക്ക്.

o int വലിപ്പം (പട്ടിക l)
ഒഴിവാക്കി: ഉപയോഗിക്കുക ശ്രദ്ധിച്ചു.

o int sizeoflist(ലിസ്റ്റ് l)
ഒഴിവാക്കി: ഉപയോഗിക്കുക ശ്രദ്ധിച്ചു.

o പട്ടിക സ്റ്റാറ്റ്(സ്ട്രിംഗ് പ്രവേശനം)
റിട്ടേൺസ് അറിഞ്ഞുകൂടാത്തപിശകുനിലസ്റ്റാറ്റ്(2) ഡയറക്ടറി എൻട്രിയുടെ വിവരങ്ങൾ എൻട്രി ഒരു പട്ടികയായി. തിരികെ നൽകിയ പട്ടിക
രണ്ട് ഘടകങ്ങളുണ്ട്: ഘടകം 0 ആണ് ആട്രിബ്യൂട്ട് മൂല്യം, മൂലകം 1 ന്റെ വലിപ്പം ഉൾക്കൊള്ളുന്നു
ഫയല്.

ആട്രിബ്യൂട്ടുകൾ ബിറ്റ്-ഫ്ലാഗുകളായി തിരികെ നൽകുന്നു, ഇനിപ്പറയുന്ന മുൻനിർവചിക്കപ്പെട്ടതിൽ നിന്ന് രചിച്ചതാണ്
സ്ഥിരാങ്കങ്ങൾ:

S_IFCHR S_IFDIR S_IFREG
S_IREAD S_IWRITE S_IEXEC

കാണുക അറിഞ്ഞുകൂടാത്തപിശകുനിലസ്റ്റാറ്റ്(2) ഈ സ്ഥിരാങ്കങ്ങളുടെ അർത്ഥങ്ങൾക്കായുള്ള മാനുവൽ പേജ്.

o പട്ടിക സ്റ്റാറ്റ് (പരിശോധിക്കുന്നു, സ്ട്രിംഗ് പ്രവേശനം)
മുമ്പത്തെ പ്രവർത്തനത്തിന് സമാനമാണ്, എന്നാൽ വ്യക്തമാക്കുന്നതിലൂടെ പരിശോധിക്കുന്നു as P_NOCHECK പ്രവർത്തനം
സ്ക്രിപ്റ്റ് അവസാനിപ്പിക്കില്ല. മറിച്ച്, തിരിച്ചുവരുന്നു അറിഞ്ഞുകൂടാത്തപിശകുനിലസ്റ്റാറ്റ്(2) റിട്ടേൺ മൂല്യം.

o int strchr(സ്ട്രിംഗ് str, സ്ട്രിംഗ് അക്ഷരങ്ങൾ)
ആദ്യ സൂചിക തിരികെ നൽകുന്നു str അതിൽ ഏതെങ്കിലും കഥാപാത്രങ്ങൾ ടാങ്കുകൾ കണ്ടെത്തി, അല്ലെങ്കിൽ -1
if str എന്നതിലെ കഥാപാത്രങ്ങളൊന്നും അടങ്ങിയിട്ടില്ല ടാങ്കുകൾ.

o int strlen(സ്ട്രിംഗ് str)
പ്രതീകങ്ങളുടെ എണ്ണം നൽകുന്നു str (അവസാന 0 കണക്കാക്കുന്നില്ല).

o int strfind(സ്ട്രിംഗ് വൈക്കോൽ കൂന, സ്ട്രിംഗ് സൂചി)
ഇൻഡെക്സ് റിട്ടേൺസ് വൈക്കോൽ കൂന എവിടെ സൂചി കണ്ടെത്തി, അല്ലെങ്കിൽ -1 എങ്കിൽ സൂചി അടങ്ങിയിട്ടില്ല
in വൈക്കോൽ കൂന.
ഫംഗ്ഷൻ ആയിരുന്നു വിളിച്ചു strstr() in പതിപ്പുകൾ മുമ്പ് 7.00.

o int strformat(സ്ട്രിംഗ് ഫോർമാറ്റ്,...)
ആർഗ്യുമെന്റുകൾ പരിഹരിക്കുന്നതിനായി % 1 .. % 2 എന്ന പ്ലേസ്‌ഹോൾഡറുകൾ ഉപയോഗിച്ച് ഫോർമാറ്റ് ചെയ്‌ത സ്ട്രിംഗ് നൽകുന്നു
ഇനിപ്പറയുന്ന ഫോർമാറ്റ്.
ഉദാഹരണം:

void main ()
{
int i = 10;
int j = 20;
സ്ട്രിംഗ് s1;
സ്ട്രിംഗ് s2;
// പരമ്പരാഗത സമീപനം:
s1 = (സ്ട്രിംഗ്)i + "" + (സ്ട്രിംഗ്)j + "" + (സ്ട്രിംഗ്)i;
// strformat ഉപയോഗിക്കുന്നു:
s2 = strformat("%1 %2 %1", i, j);
printf("s1 = %1, s2 = %2\n", s1, s2);
}

o സ്ട്രിംഗ് strlwr(സ്ട്രിംഗ് s)
എന്നതിന്റെ ചെറിയക്ഷരം ഡ്യൂപ്ലിക്കേറ്റ് നൽകുന്നു s.

o പട്ടിക strtok(സ്ട്രിംഗ് str, സ്ട്രിംഗ് സെപ്പറേറ്ററുകൾ)
യുടെ എല്ലാ സബ്‌സ്‌ട്രിംഗുകളും അടങ്ങുന്ന ഒരു ലിസ്റ്റ് നൽകുന്നു str ഒന്നോ അതിലധികമോ കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു
(തുടർച്ചയായ) പ്രതീകങ്ങൾ സെപ്പറേറ്ററുകൾ. ഉദാ, strtok("ഹലോ icmake's+world", " +")
മൂന്ന് സ്ട്രിംഗുകൾ അടങ്ങിയ ലിസ്റ്റ് നൽകുന്നു "ഹലോ", "icmake ന്റെ", ഒപ്പം "ലോകം".

o സ്ട്രിംഗ് strupr(സ്ട്രിംഗ് s)
എന്നതിന്റെ വലിയക്ഷരം ഡ്യൂപ്ലിക്കേറ്റ് നൽകുന്നു s.

o സ്ട്രിംഗ് substr(സ്ട്രിംഗ് ടെക്സ്റ്റ്, int ഓഫ്സെറ്റ്, int എണ്ണുക)
ഒരു ഉപസ്‌ട്രിംഗ് നൽകുന്നു ടെക്സ്റ്റ്ആരംഭിക്കുന്നു ഓഫ്സെറ്റ്, അടങ്ങുന്ന എണ്ണുക കഥാപാത്രങ്ങൾ. എങ്കിൽ
ഓഫ്സെറ്റ് സ്ട്രിംഗിന്റെ വലുപ്പം കവിയുന്നു (അല്ലെങ്കിൽ തുല്യം). എണ്ണുക <= 0, പിന്നെ ഒരു ശൂന്യമായ ചരട്
തിരികെ നൽകപ്പെടുന്നു. എങ്കിൽ ഓഫ്സെറ്റ് 0-ൽ കുറവാണെങ്കിൽ 0 ഉപയോഗിക്കുന്നു.

o int സിസ്റ്റം(സ്ട്രിംഗ് കമാൻഡ്)
നിർവ്വഹിക്കുന്നു കമാൻഡ്. റിട്ടേൺ മൂല്യം എക്സിക്യൂട്ട് ചെയ്ത കമാൻഡിന്റെ എക്സിറ്റ് മൂല്യത്തെ സൂചിപ്പിക്കുന്നു. ദി
സ്ട്രിംഗ് കമാൻഡ് റീഡയറക്ഷൻ കൂടാതെ/അല്ലെങ്കിൽ പൈപ്പിംഗ് പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കാം.

o int സിസ്റ്റം(int പരിശോധിക്കുന്നു, സ്ട്രിംഗ് കമാൻഡ്)
മുമ്പത്തെ ഫംഗ്‌ഷന്റെ അതേ പ്രവർത്തനക്ഷമത, എന്നാൽ വ്യക്തമാക്കുന്നതിലൂടെ പരിശോധിക്കുന്നു as
NOT_CHECKED ഫംഗ്ഷൻ സ്ക്രിപ്റ്റ് അവസാനിപ്പിക്കില്ല. മറിച്ച്, അത് തിരികെ നൽകും
കമാൻഡിന്റെ എക്സിറ്റ് സ്റ്റാറ്റസ് എന്ന് വിളിക്കുന്നു, അല്ലെങ്കിൽ 0x7f00 കമാൻഡ് കണ്ടെത്തിയില്ലെങ്കിൽ.

o സ്ട്രിംഗ് ട്രിം(സ്ട്രിംഗ് s)
ഇതിന്റെ ഒരു പകർപ്പ് നൽകുന്നു s വൈറ്റ് സ്പേസുകളെ നയിക്കാതെയും പിന്നിലാക്കാതെയും.

o സ്ട്രിംഗ് ട്രിംലെഫ്റ്റ്(സ്ട്രിംഗ് str)
ഇതിന്റെ ഒരു പകർപ്പ് നൽകുന്നു s വെളുത്ത ഇടങ്ങൾ നയിക്കാതെ.

o സ്ട്രിംഗ് ട്രിം(സ്ട്രിംഗ് s)
ഇതിന്റെ ഒരു പകർപ്പ് നൽകുന്നു s വെളുത്ത ഇടങ്ങൾ പിന്തുടരാതെ.

USER നിർവചിച്ചു പ്രവർത്തനങ്ങൾ


ശൂന്യം പ്രധാന

ഐക്മേക്ക് സ്ക്രിപ്റ്റുകൾ ഒരു ഉപയോക്തൃ-നിർവചിച്ച ഫംഗ്ഷൻ നൽകണം പ്രധാന. പ്രവർത്തനം പ്രധാന ഉണ്ട്
മൂന്ന് ഓപ്ഷണൽ പാരാമീറ്ററുകൾ, അവസാനത്തേതിൽ നിന്ന് ഒഴിവാക്കിയേക്കാം (envp) ആദ്യത്തേത്
(ആർജിസി), പോലെ C. അതിന്റെ പൂർണ്ണമായ പ്രോട്ടോടൈപ്പ് ഇതാണ് (ശ്രദ്ധിക്കുക: ശൂന്യം മടക്കം തരം):

പ്രധാന അസാധുത (int argc, ലിസ്റ്റ് argv, ലിസ്റ്റ് envp)

In പ്രധാന (),

o ആർജിസി മൂലകങ്ങളുടെ എണ്ണത്തെ പ്രതിനിധീകരിക്കുന്നു argv;

o argv ആർഗ്യുമെന്റുകൾ അടങ്ങിയിരിക്കുന്നു, മൂലകം 0 .bim-ന്റെ പേരിന് തുല്യമാണ്
ഫയൽ;

o envp 'പരിസ്ഥിതി' വേരിയബിളുകൾ അടങ്ങിയിരിക്കുന്നു. ചടങ്ങ് ശ്രദ്ധിച്ചു ഉപയോഗിക്കാം
അതിന്റെ മൂലകങ്ങളുടെ എണ്ണം നിർണ്ണയിക്കുക. ഘടകങ്ങൾ envp ഫോം ഉണ്ട്
വേരിയബിൾ = മൂല്യം. പകരമായി, പ്രവർത്തനം getenv a വീണ്ടെടുക്കാൻ ഉപയോഗിക്കാം
നിർദ്ദിഷ്ട പരിസ്ഥിതി വേരിയബിൾ ഉടനടി. ഉദാഹരണം:

പ്രധാനം അസാധുവാണ് (int argc, list argv)
{
സമാഹരിക്കാനുള്ള പട്ടിക;
int idx;

എങ്കിൽ (argc == 1)
ഉപയോഗം (ഘടകം(0, argv));

എങ്കിൽ (കോമ്പൈൽ = മാറ്റി ("*.cc"))
{
വേണ്ടി (idx = ദൈർഘ്യം (tocompile); idx--; )
കംപൈൽ(ഘടകം(idx, toCompile));

എങ്കിൽ (getenv("dryrun")[0] == "0")
ലിങ്കിംഗ് (ഘടകം(2, argv));
}
}

എല്ലാ ആഗോള വേരിയബിളുകളും അവയുടെ നിർവചനങ്ങളുടെ ക്രമത്തിൽ ആരംഭിച്ചിരിക്കുന്നു പ്രധാന വിളിക്കുന്നത്
icmakeഅധിക ജോലികൾ ചെയ്യുന്നതിനുള്ള റൺ-ടൈം സപ്പോർട്ട് സിസ്റ്റം.

കൂടാതെ നിർവചിച്ചിരിക്കുന്നത് ഉപയോക്താവ് ഫംഗ്ഷനുകളും

അധിക പ്രവർത്തനങ്ങൾ നിർവചിക്കാം. ഒരിക്കൽ നിർവചിച്ചാൽ, ഈ ഫംഗ്ഷനുകളെ വിളിക്കാം. മുന്നോട്ട്
വേരിയബിളുകളുടെയോ ഫംഗ്‌ഷനുകളുടെയോ റഫറൻസ് പിന്തുണയ്‌ക്കുന്നില്ല, പക്ഷേ ആവർത്തിച്ച് വിളിക്കുന്നു
പ്രവർത്തനങ്ങൾ ആണ്. ഫംഗ്‌ഷൻ ഡിക്ലറേഷനുകൾ പിന്തുണയ്‌ക്കാത്തതിനാൽ പരോക്ഷമായ ആവർത്തനത്തെ പിന്തുണയ്‌ക്കുന്നില്ല
ഒന്നുകിൽ പിന്തുണച്ചു.

ഉപയോക്തൃ-നിർവചിച്ച പ്രവർത്തനങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഘടകങ്ങൾ ഉണ്ടായിരിക്കണം:

o ഫംഗ്‌ഷന്റെ റിട്ടേൺ തരം, അതിൽ ഒന്നായിരിക്കണം ശൂന്യമായ, int, സ്ട്രിംഗ് or പട്ടിക. അവിടെ
സ്ഥിരസ്ഥിതി തരമല്ല.

o ഫംഗ്‌ഷന്റെ പേര്, ഉദാ, സമാഹരിക്കുക.

o ഒരു പാരാമീറ്റർ ലിസ്റ്റ്, പൂജ്യമോ അതിലധികമോ കോമയാൽ വേർതിരിച്ച പരാമീറ്ററുകൾ നിർവചിക്കുന്നു. പാരാമീറ്ററുകൾ
സ്വയം ഒരു തരം നാമം ഉൾക്കൊള്ളുന്നു (int, സ്ട്രിംഗ്, അഥവാ പട്ടിക) തുടർന്ന്
പാരാമീറ്ററിന്റെ ഐഡന്റിഫയർ. ഉദാ, (സ്ട്രിംഗ് ഔട്ട്ഫിൽ, സ്ട്രിംഗ് ഉറവിടം).

ഒ എ ശരീരം ഒരു ജോടി ചുരുണ്ട ബ്രേസുകളാൽ ചുറ്റപ്പെട്ടിരിക്കുന്നു ({ ഒപ്പം }).

ഫംഗ്‌ഷൻ ബോഡികളിൽ വേരിയബിൾ നിർവചനങ്ങൾ അടങ്ങിയിരിക്കാം (ഓപ്ഷണലായി ഇനീഷ്യലൈസ് ചെയ്‌തത്). വേരിയബിൾ
നിർവചനങ്ങൾ ഒരു തരം നാമത്തിൽ ആരംഭിക്കുന്നു, തുടർന്ന് ഒന്നോ അതിലധികമോ കോമ വേർതിരിച്ചിരിക്കുന്നു (ഓപ്ഷണലായി
ആരംഭിച്ചത്) വേരിയബിൾ ഐഡന്റിഫയറുകൾ. ഒരു വേരിയബിൾ വ്യക്തമായി ആരംഭിച്ചില്ലെങ്കിൽ അത്
സ്ഥിരസ്ഥിതിയായി സമാരംഭിച്ചു. സ്ഥിരസ്ഥിതിയായി ഒരു int വേരിയബിൾ 0, a ആയി ആരംഭിക്കുന്നു സ്ട്രിംഗ് is
ഒരു ശൂന്യമായ സ്ട്രിംഗിലേക്ക് ആരംഭിച്ചു ("") a പട്ടിക പൂജ്യം മൂലകങ്ങളുടെ ഒരു പട്ടികയിലേക്ക് ആരംഭിക്കുന്നു.

വേരിയബിൾ നിർവചനങ്ങൾക്ക് പുറമേ, ബോഡികളിൽ പൂജ്യമോ അതിലധികമോ പ്രസ്താവനകൾ അടങ്ങിയിരിക്കാം (cf.
വിഭാഗം പറ നിയന്ത്രണം). വേരിയബിളുകൾ നിർവചിക്കാമെന്നത് ശ്രദ്ധിക്കുക (ഓപ്ഷണലായി ആരംഭിക്കുകയും)
ഫംഗ്‌ഷനുകൾക്കുള്ളിൽ എവിടെയും, കൂടാതെ അകത്തും എങ്കിൽ, വേണ്ടി ഒപ്പം സമയത്ത് പ്രസ്താവനകൾ.

യുടെ പെരുമാറ്റം icmakeമൂല്യങ്ങൾ നൽകാത്ത അസാധുവായ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്ന സ്ക്രിപ്റ്റുകൾ അല്ല
നിർവചിച്ചിരിക്കുന്നത്.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് icmake ഓൺലൈനിൽ ഉപയോഗിക്കുക


Ad


Ad