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

പട്ടിക:

NAME

makepp_tutorial_compilation -- Unix കമ്പൈലേഷൻ കമാൻഡുകൾ

വിവരണം

കംപൈലേഷൻ കമാൻഡുകൾ എന്തുചെയ്യുന്നു എന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് നല്ല ഗ്രാഹ്യമുണ്ടെങ്കിൽ ഈ മാനുവൽ പേജ് ഒഴിവാക്കുക.

അവരുടെ പ്രോഗ്രാമിംഗ് ക്ലാസുകളിൽ വിഷമിപ്പിക്കുന്ന കുറച്ച് ആളുകളെ പഠിപ്പിക്കുന്നത് എങ്ങനെയെന്ന് ഞാൻ കാണുന്നു
പ്രോഗ്രാമുകൾ എഴുതിക്കഴിഞ്ഞാൽ കംപൈൽ ചെയ്യാൻ പോകുക. തുടക്കക്കാർ ഒന്നുകിൽ ആശ്രയിക്കുന്നു
മനഃപാഠമാക്കിയ കമാൻഡ്, അല്ലെങ്കിൽ നിർമ്മിക്കുന്ന ബിൽറ്റ്ഇൻ നിയമങ്ങളിൽ. ഞാൻ അത്ഭുതപ്പെട്ടുപോയി
ഒപ്റ്റിമൈസേഷൻ ഇല്ലാതെ കംപൈൽ ചെയ്യാൻ പഠിച്ച അങ്ങേയറ്റം കമ്പ്യൂട്ടർ പരിജ്ഞാനമുള്ള ആളുകൾ
അത് എത്ര പ്രധാനമാണെന്ന് അവർ ഒരിക്കലും പറഞ്ഞിട്ടില്ല. സമാഹാരം എങ്ങനെ എന്നതിനെക്കുറിച്ചുള്ള പ്രാഥമിക അറിവ്
കമാൻഡുകളുടെ പ്രവർത്തനം നിങ്ങളുടെ പ്രോഗ്രാമുകളെ ഇരട്ടി വേഗത്തിലോ അതിലധികമോ പ്രവർത്തിപ്പിക്കാൻ ഇടയാക്കിയേക്കാം, അതിനാൽ ഇത് കുറഞ്ഞത് വിലമതിക്കുന്നു
അഞ്ച് നിമിഷം. C കംപൈൽ ചെയ്യുന്നതിന് നിങ്ങൾ അറിയേണ്ട എല്ലാ കാര്യങ്ങളും ഈ പേജ് വിവരിക്കുന്നു
അല്ലെങ്കിൽ യുണിക്സിന്റെ ഏത് വേരിയന്റിലും C++ പ്രോഗ്രാമുകൾ.

പേര് ഒഴികെ C++ കംപൈലേഷൻ സമാനമായതിനാൽ ഉദാഹരണങ്ങൾ കൂടുതലും C യ്ക്കായിരിക്കും
കംപൈലർ വ്യത്യസ്തമാണ്. നിങ്ങൾ ഒരു ഫയലിൽ സോഴ്സ് കോഡ് കംപൈൽ ചെയ്യുകയാണെന്ന് കരുതുക
"xyz.c" കൂടാതെ "xyz" എന്നൊരു പ്രോഗ്രാം നിർമ്മിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു. എന്താണ് സംഭവിക്കേണ്ടത്?

ഇതുപോലുള്ള ഒരു കമാൻഡ് ഉപയോഗിച്ച് ഒരു ഘട്ടത്തിൽ നിങ്ങളുടെ പ്രോഗ്രാം നിർമ്മിക്കാൻ കഴിയുമെന്ന് നിങ്ങൾക്ക് അറിയാമായിരിക്കും:

cc -g xyz.c -o xyz

ഇത് പ്രവർത്തിക്കും, എന്നാൽ നിങ്ങൾ ആണെങ്കിൽ നിങ്ങൾ മനസ്സിലാക്കേണ്ട രണ്ട്-ഘട്ട പ്രക്രിയ ഇത് മറയ്ക്കുന്നു
മേക്ക് ഫയലുകൾ എഴുതുന്നു. (യഥാർത്ഥത്തിൽ, രണ്ടിൽ കൂടുതൽ ഘട്ടങ്ങളുണ്ട്, പക്ഷേ നിങ്ങൾ ചെയ്യേണ്ടത് മാത്രം
അവയിൽ രണ്ടെണ്ണം മനസ്സിലാക്കുക.) ഒന്നിലധികം മൊഡ്യൂളുകളുള്ള ഒരു പ്രോഗ്രാമിന്, രണ്ട് ഘട്ടങ്ങൾ സാധാരണമാണ്
വ്യക്തമായി വേർതിരിച്ചിരിക്കുന്നു.

സമാഹരണ
നിങ്ങളുടെ C അല്ലെങ്കിൽ C++ സോഴ്‌സ് കോഡിന്റെ ഒരു ബൈനറി ഫയലിലേക്ക് വിവർത്തനം ചെയ്യുന്നതാണ് ആദ്യപടി
ഒരു ഒബ്ജക്റ്റ് ഫയൽ. ഒബ്‌ജക്‌റ്റ് ഫയലുകൾക്ക് സാധാരണയായി ".o" ന്റെ ഒരു വിപുലീകരണമുണ്ട്. (അടുത്തിടെ ചിലതിന്
പ്രൊജക്‌റ്റുകൾ, ".lo" എന്നത് അല്പം വ്യത്യസ്തമായ ഒബ്‌ജക്റ്റ് ഫയലിനും ഉപയോഗിക്കുന്നു.)

Unix-ൽ ഒരു ഒബ്ജക്റ്റ് ഫയൽ നിർമ്മിക്കാനുള്ള കമാൻഡ് ഇതുപോലെ കാണപ്പെടുന്നു:

cc -g -c xyz.c -o xyz.o

"cc" എന്നത് C കംപൈലർ ആണ്. ചിലപ്പോൾ ഇതര സി കമ്പൈലറുകൾ ഉപയോഗിക്കുന്നു; വളരെ സാധാരണമായ ഒന്നാണ്
"gcc" എന്ന് വിളിക്കുന്നു. ഒരു സാധാരണ C++ കംപൈലർ ഗ്നു കമ്പൈലറാണ്, ഇതിനെ സാധാരണയായി "g++" എന്ന് വിളിക്കുന്നു. ഫലത്തിൽ
Unix-ലെ എല്ലാ C, C++ കംപൈലറുകൾക്കും ബാക്കിയുള്ള കമാൻഡുകൾക്ക് ഒരേ വാക്യഘടനയാണ് (കുറഞ്ഞത്
അടിസ്ഥാന പ്രവർത്തനങ്ങൾക്ക്), അതിനാൽ ഒരേയൊരു വ്യത്യാസം ആദ്യ വാക്ക് ആയിരിക്കും.

"-g" ഓപ്ഷൻ എന്താണ് ചെയ്യുന്നതെന്ന് ഞങ്ങൾ പിന്നീട് വിശദീകരിക്കും.

ഔട്ട്പുട്ടായി ഒരു ".o" ഫയൽ നിർമ്മിക്കാൻ "-c" ഓപ്ഷൻ C കംപൈലറോട് പറയുന്നു. (ഇല്ലെങ്കിൽ
"-c" വ്യക്തമാക്കുക, തുടർന്ന് അത് രണ്ടാമത്തെ സമാഹാര ഘട്ടം സ്വയമേവ നിർവഹിക്കുന്നു.)

"-o xyz.o" ഓപ്ഷൻ ഒബ്ജക്റ്റ് ഫയലിന്റെ പേര് എന്താണെന്ന് കംപൈലറോട് പറയുന്നു. നിങ്ങൾക്ക് കഴിയും
ഒബ്ജക്റ്റ് ഫയലിന്റെ പേരും ഉറവിടത്തിന്റെ പേരും തുല്യമായിരിക്കുന്നിടത്തോളം ഇത് ഒഴിവാക്കുക
".o" എക്സ്റ്റൻഷൻ ഒഴികെയുള്ള ഫയൽ.

മിക്കവാറും, ഓപ്ഷനുകളുടെ ക്രമവും ഫയലിന്റെ പേരുകളും പ്രശ്നമല്ല. ഒന്ന്
ഔട്ട്പുട്ട് ഫയൽ ഉടനടി "-o" പിന്തുടരേണ്ടതുണ്ട് എന്നതാണ് പ്രധാന ഒഴിവാക്കൽ.

ലിങ്കിംഗ്
ഒരു പ്രോഗ്രാം നിർമ്മിക്കുന്നതിന്റെ രണ്ടാം ഘട്ടത്തെ വിളിക്കുന്നു ലിങ്കുചെയ്യുന്നു. ഒരു ഒബ്ജക്റ്റ് ഫയൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയില്ല
നേരിട്ട്; അതൊരു ഇന്റർമീഡിയറ്റ് രൂപമാണ് ലിങ്ക്ഡ് ഇതിനുവേണ്ടി മറ്റ് ഘടകങ്ങളിലേക്ക്
ഒരു പ്രോഗ്രാം നിർമ്മിക്കുക. മറ്റ് ഘടകങ്ങളിൽ ഉൾപ്പെടാം:

· ലൈബ്രറികൾ. എ ലൈബ്രറി, ഏകദേശം പറഞ്ഞാൽ, ഒബ്ജക്റ്റ് മൊഡ്യൂളുകളുടെ ഒരു ശേഖരമാണ്
ആവശ്യാനുസരണം ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഉദാഹരണത്തിന്, നിങ്ങളുടെ പ്രോഗ്രാം "printf" ഫംഗ്‌ഷനെ വിളിക്കുകയാണെങ്കിൽ, പിന്നെ
"printf" ഫംഗ്‌ഷന്റെ നിർവ്വചനം സിസ്റ്റം C ലൈബ്രറിയിൽ നിന്ന് ഉൾപ്പെടുത്തിയിരിക്കണം.
ചില ലൈബ്രറികൾ നിങ്ങളുടെ പ്രോഗ്രാമിലേക്ക് സ്വയമേവ ലിങ്ക് ചെയ്‌തിരിക്കുന്നു (ഉദാ. അടങ്ങിയിരിക്കുന്ന ഒന്ന്
"printf") അതിനാൽ നിങ്ങൾ ഒരിക്കലും അവരെക്കുറിച്ച് വിഷമിക്കേണ്ടതില്ല.

· നിങ്ങളുടെ പ്രോഗ്രാമിലെ മറ്റ് ഉറവിട ഫയലുകളിൽ നിന്ന് ഉരുത്തിരിഞ്ഞ ഒബ്ജക്റ്റ് ഫയലുകൾ. നിങ്ങൾ എഴുതുകയാണെങ്കിൽ നിങ്ങളുടെ
പ്രോഗ്രാമിന് യഥാർത്ഥത്തിൽ നിരവധി സോഴ്സ് ഫയലുകൾ ഉണ്ട്, സാധാരണയായി നിങ്ങൾ ഓരോന്നും കംപൈൽ ചെയ്യും
സോഴ്സ് ഫയൽ ഒരു പ്രത്യേക ഒബ്ജക്റ്റ് ഫയലിലേക്ക് മാറ്റുക, തുടർന്ന് അവയെല്ലാം ഒരുമിച്ച് ലിങ്ക് ചെയ്യുക.

ദി ലിങ്കർ ഒബ്ജക്റ്റ് ഫയലുകളുടെ ഒരു ശേഖരം എടുക്കുന്നതിനുള്ള ഉത്തരവാദിത്തമുള്ള പ്രോഗ്രാമാണ്
ഒരു എക്സിക്യൂട്ടബിൾ ഫയൽ നിർമ്മിക്കുന്നതിനായി ലൈബ്രറികളും അവയെ ഒന്നിച്ച് ബന്ധിപ്പിക്കുന്നു. എക്സിക്യൂട്ടബിൾ ഫയൽ ആണ്
നിങ്ങൾ യഥാർത്ഥത്തിൽ പ്രവർത്തിപ്പിക്കുന്ന പ്രോഗ്രാം.

പ്രോഗ്രാം ലിങ്ക് ചെയ്യുന്നതിനുള്ള കമാൻഡ് ഇതുപോലെ കാണപ്പെടുന്നു:

cc -g xyz.o -o xyz

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

നിങ്ങൾ "-o xyz" എന്ന് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഔട്ട്‌പുട്ട് ഫയലിനെ "a.out" എന്ന് വിളിക്കും, അത് തോന്നുന്നു
എന്നെ സംബന്ധിച്ചിടത്തോളം തികച്ചും ഉപയോഗശൂന്യവും ആശയക്കുഴപ്പമുണ്ടാക്കുന്നതുമായ ഒരു കൺവെൻഷനാണ്. അതിനാൽ എല്ലായ്പ്പോഴും "-o" എന്ന് വ്യക്തമാക്കുക
ലിങ്കിംഗ് ഘട്ടം.

നിങ്ങളുടെ പ്രോഗ്രാമിന് ഒന്നിൽ കൂടുതൽ ഒബ്ജക്റ്റ് ഫയലുകൾ ഉണ്ടെങ്കിൽ, നിങ്ങൾ എല്ലാ ഒബ്ജക്റ്റ് ഫയലുകളും വ്യക്തമാക്കണം
ലിങ്ക് കമാൻഡ്.

എന്തുകൊണ്ട് നിങ്ങളെ ആവശ്യം ലേക്ക് പ്രത്യേക The ഘട്ടങ്ങൾ
എന്തുകൊണ്ട് ഇതുപോലുള്ള ലളിതമായ, ഒറ്റ-ഘട്ട കമാൻഡ് ഉപയോഗിക്കരുത്:

cc -g xyz.c -o xyz

കൂടുതൽ സങ്കീർണ്ണമായ രണ്ട്-ഘട്ട സമാഹാരത്തിന് പകരം

cc -g -c xyz.c -o xyz.o
cc -g xyz.o -o xyz

ആന്തരികമായി ആദ്യത്തേത് രണ്ടാമത്തേതാക്കി മാറ്റുകയാണെങ്കിൽ? എങ്കിൽ മാത്രം വ്യത്യാസം പ്രധാനമാണ്
നിങ്ങളുടെ പ്രോഗ്രാമിൽ ഒന്നിലധികം മൊഡ്യൂളുകൾ ഉണ്ട്. ഞങ്ങൾക്ക് ഒരു അധിക മൊഡ്യൂൾ ഉണ്ടെന്ന് കരുതുക,
"abc.c". ഇപ്പോൾ ഞങ്ങളുടെ സമാഹാരം ഇതുപോലെ കാണപ്പെടുന്നു:

# ഒരു-ഘട്ട കമാൻഡ്.
cc -g xyz.c abc.c -o xyz

or

# രണ്ട്-ഘട്ട കമാൻഡ്.
cc -g -c xyz.c -o xyz.o
cc -g -c abc.c -o abc.o
cc -g xyz.o abc.o -o xyz

ആദ്യ രീതി, തീർച്ചയായും, രണ്ടാമത്തെ രീതിയിലേക്ക് ആന്തരികമായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു. ഇതിനർത്ഥം
ഓരോ തവണ കമാൻഡ് പ്രവർത്തിപ്പിക്കുമ്പോഴും "xyz.c", "abc.c" എന്നിവ വീണ്ടും കംപൈൽ ചെയ്യപ്പെടുന്നു. എന്നാൽ നിങ്ങളാണെങ്കിൽ
"xyz.c" മാത്രം മാറ്റി, "abc.c" വീണ്ടും കംപൈൽ ചെയ്യേണ്ട ആവശ്യമില്ല, അതിനാൽ രണ്ടിന്റെ രണ്ടാമത്തെ വരി-
സ്റ്റേജ് കമാൻഡുകൾ ചെയ്യേണ്ടതില്ല. ഇത് സമാഹാരത്തിൽ വലിയ മാറ്റമുണ്ടാക്കും
സമയം, പ്രത്യേകിച്ചും നിങ്ങൾക്ക് ധാരാളം മൊഡ്യൂളുകൾ ഉണ്ടെങ്കിൽ. ഇക്കാരണത്താൽ, ഫലത്തിൽ എല്ലാ മേക്ക് ഫയലുകളും സൂക്ഷിക്കുന്നു
രണ്ട് സമാഹാര ഘട്ടങ്ങൾ വേർതിരിക്കുന്നു.

ഇത് ഏറെക്കുറെ അടിസ്ഥാനകാര്യങ്ങളാണ്, എന്നാൽ നിങ്ങൾ ശരിക്കും ചെയ്യേണ്ട കുറച്ച് ചെറിയ വിശദാംശങ്ങൾ കൂടിയുണ്ട്
കുറിച്ച് അറിയാം.

ഡീബഗ്ഗിംഗ് വേഴ്സസ് ഒപ്റ്റിമൈസേഷൻ
സാധാരണയായി പ്രോഗ്രാമർമാർ ഒരു പ്രോഗ്രാം കംപൈൽ ചെയ്യുന്നത് ഒന്നുകിൽ ഡീബഗ്ഗിന് വേണ്ടിയോ വേഗതയ്ക്കായോ ആണ്. സമാഹാരം
വേഗത എന്ന് വിളിക്കപ്പെടുന്നു ഒപ്റ്റിമൈസേഷൻ; ഒപ്റ്റിമൈസേഷൻ ഉപയോഗിച്ച് കംപൈൽ ചെയ്യുന്നത് നിങ്ങളുടെ കോഡ് വരെ പ്രവർത്തിപ്പിക്കാൻ കഴിയും
നിങ്ങളുടെ കോഡ്, പ്രോസസർ, കംപൈലർ എന്നിവയെ ആശ്രയിച്ച് 5 മടങ്ങ് വേഗതയോ അതിൽ കൂടുതലോ.

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

ഡീബഗ്ഗർ പ്രവർത്തിക്കുന്നതിന്, കംപൈലർ സഹകരിക്കുക മാത്രമല്ല, സഹകരിക്കുകയും വേണം
ഒപ്‌റ്റിമൈസുചെയ്യുന്നു, മാത്രമല്ല ചിഹ്നങ്ങളുടെ പേരുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഒബ്‌ജക്‌റ്റിൽ ഇടുന്നതിലൂടെയും
ഫയൽ അങ്ങനെ ഡീബഗ്ഗറിന് എന്താണ് വിളിക്കുന്നതെന്ന് അറിയാം. ഇതാണ് "-ജി" സമാഹാരം
ഓപ്ഷൻ ചെയ്യുന്നു.

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

gcc -O6 -malign-double -c xyz.c -o xyz.o

കേവലമായ ഏറ്റവും മികച്ചതിനായി നിങ്ങൾക്ക് വ്യത്യസ്ത ഒപ്റ്റിമൈസേഷൻ ഓപ്ഷനുകൾ പരീക്ഷിക്കേണ്ടി വന്നേക്കാം
പ്രകടനം. വ്യത്യസ്ത കോഡ് കഷണങ്ങൾക്കായി നിങ്ങൾക്ക് വ്യത്യസ്ത ഓപ്ഷനുകൾ ആവശ്യമായി വന്നേക്കാം. പൊതുവെ
സംസാരിക്കുമ്പോൾ, "-O6" പോലെയുള്ള ഒരു ലളിതമായ ഒപ്റ്റിമൈസേഷൻ ഫ്ലാഗ് പല കംപൈലറുകളിലും സാധാരണയായി പ്രവർത്തിക്കുന്നു
നല്ല ഫലങ്ങൾ നൽകുന്നു.

മുന്നറിയിപ്പ്: അപൂർവ സന്ദർഭങ്ങളിൽ, നിങ്ങളുടെ പ്രോഗ്രാം യഥാർത്ഥത്തിൽ ഒരേ കാര്യം ചെയ്യില്ല
ഒപ്റ്റിമൈസേഷൻ ഉപയോഗിച്ചാണ് ഇത് സമാഹരിച്ചിരിക്കുന്നത്. ഇത് (1) നിങ്ങൾ നടത്തിയ ഒരു അസാധുവായ അനുമാനം മൂലമാകാം
നിങ്ങളുടെ കോഡിൽ ഒപ്റ്റിമൈസേഷൻ ഇല്ലാതെ നിരുപദ്രവകരമായിരുന്നു, എന്നാൽ പ്രശ്നങ്ങൾ ഉണ്ടാക്കുന്നു കാരണം
നിങ്ങൾ ഒപ്റ്റിമൈസ് ചെയ്യുമ്പോൾ കാര്യങ്ങൾ പുനഃക്രമീകരിക്കുന്നതിനുള്ള സ്വാതന്ത്ര്യം കംപൈലർ എടുക്കുന്നു; അല്ലെങ്കിൽ (2) ദുഃഖകരമെന്നു പറയട്ടെ
കംപൈലറുകൾക്കും അവരുടെ ഒപ്റ്റിമൈസറുകളിലെ ബഗുകൾ ഉൾപ്പെടെ ബഗുകൾ ഉണ്ട്. ഒരു സ്ഥിരതയുള്ള കംപൈലറിനായി
പെന്റിയം പോലെയുള്ള ഒരു പൊതു പ്ലാറ്റ്‌ഫോമിൽ "gcc", ഒപ്റ്റിമൈസേഷൻ ബഗുകൾ അപൂർവ്വമായി ഒരു പ്രശ്‌നമാണ് (ഇത് പോലെ
വർഷം 2000 - കുറച്ച് വർഷങ്ങൾക്ക് മുമ്പ് പ്രശ്നങ്ങൾ ഉണ്ടായിരുന്നു).

നിങ്ങളുടെ കംപൈലേഷൻ കമാൻഡിൽ "-g" അല്ലെങ്കിൽ "-O" എന്നിവ നിങ്ങൾ വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, തത്ഫലമായുണ്ടാകുന്ന ഒബ്ജക്റ്റ്
ഡീബഗ്ഗിംഗിനോ വേഗത്തിൽ പ്രവർത്തിപ്പിക്കാനോ ഫയൽ അനുയോജ്യമല്ല. ചില കാരണങ്ങളാൽ, ഇതാണ്
സ്ഥിരസ്ഥിതി. അതിനാൽ എല്ലായ്പ്പോഴും "-g" അല്ലെങ്കിൽ "-O" എന്നിവ വ്യക്തമാക്കുക.

ചില സിസ്റ്റങ്ങളിൽ, സമാഹരണത്തിലും ലിങ്കിംഗ് ഘട്ടങ്ങളിലും നിങ്ങൾ "-g" നൽകണം; മറ്റുള്ളവരിൽ
(ഉദാ: Linux), ഇത് സമാഹരിക്കുന്ന ഘട്ടത്തിൽ മാത്രമേ നൽകാവൂ. ചില സിസ്റ്റങ്ങളിൽ, "-O"
യഥാർത്ഥത്തിൽ ലിങ്കിംഗ് ഘട്ടത്തിൽ വ്യത്യസ്‌തമായ എന്തെങ്കിലും ചെയ്യുന്നു, അതേസമയം മറ്റുള്ളവയിൽ അതിന് യാതൊരു ഫലവുമില്ല.
ഏത് സാഹചര്യത്തിലും, രണ്ട് കമാൻഡുകൾക്കും "-g" അല്ലെങ്കിൽ "-O" നൽകുന്നത് എല്ലായ്പ്പോഴും ദോഷകരമല്ല.

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

gcc -g -Wall -c xyz.c -o xyz.o

(ചിലപ്പോൾ ഞാൻ "-Wno-uninitialized" എന്ന് "-Wall" എന്നതിന് ശേഷം ചേർക്കുന്നു, കാരണം ഒരു മുന്നറിയിപ്പ്
ഒപ്റ്റിമൈസ് ചെയ്യുമ്പോൾ സാധാരണയായി തെറ്റാണ്.)

ഈ മുന്നറിയിപ്പുകൾ നിരവധി മണിക്കൂർ ഡീബഗ്ഗിംഗ് എന്നെ രക്ഷിച്ചു.

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

ഉദാഹരണത്തിന്, നിങ്ങൾ Qt ലൈബ്രറികൾ ഉപയോഗിക്കുന്ന ഒരു ആപ്ലിക്കേഷൻ എഴുതുകയാണെന്ന് കരുതുക. നിങ്ങൾ
ക്യുടി ലൈബ്രറിയുടെ ഒരു പ്രാദേശിക പകർപ്പ് ഇൻസ്റ്റാൾ ചെയ്തു /home/users/joe/qt, അതിനർത്ഥം
ഫയലുകൾ ഡയറക്‌ടറിയിൽ സൂക്ഷിച്ചിരിക്കുന്നു /home/users/joe/qt/ഉൾപ്പെടുന്നു. നിങ്ങളുടെ കോഡിൽ, നിങ്ങൾ
ഇതുപോലുള്ള കാര്യങ്ങൾ ചെയ്യാൻ ആഗ്രഹിക്കുന്നു:

#ഉൾപ്പെടുന്നു

ഇതിനുപകരമായി

#ഉൾപ്പെടുത്തുക "/home/users/joe/qt/include/qwidget.h"

ഉപയോഗിച്ച് മറ്റൊരു ഡയറക്‌ടറിയിൽ ഫയലുകൾ ഉൾപ്പെടുത്തുന്നത് നോക്കാൻ നിങ്ങൾക്ക് കമ്പൈലറോട് പറയാനാകും
"-I" സമാഹാര ഓപ്ഷൻ:

g++ -I/home/users/joe/qt/ഉൾപ്പെടുന്നു -g -c mywidget.cpp -o mywidget.o

"-I" എന്നതിനും ഡയറക്ടറി നാമത്തിനും ഇടയിൽ സാധാരണയായി ഇടമില്ല.

C++ കംപൈലർ ഫയലിനായി തിരയുമ്പോൾ qwidget.h, അത് നോക്കും
/home/users/joe/qt/ഉൾപ്പെടുന്നു സിസ്റ്റം ഉൾപ്പെടുന്ന ഡയറക്ടറിയിൽ നോക്കുന്നതിന് മുമ്പ്. നിങ്ങൾക്ക് കഴിയും
നിങ്ങൾക്ക് ആവശ്യമുള്ളത്ര "-I" ഓപ്ഷനുകൾ വ്യക്തമാക്കുക.

ഉപയോഗിക്കുന്നു ലൈബ്രറികൾ
നിങ്ങളാണെങ്കിൽ, നിർദ്ദിഷ്‌ട ബാഹ്യ ലൈബ്രറികളുമായി ലിങ്ക് ചെയ്യാൻ നിങ്ങൾ പലപ്പോഴും ലിങ്കറോട് പറയേണ്ടിവരും
സ്റ്റാൻഡേർഡ് C ലൈബ്രറിയുടെ ഭാഗമല്ലാത്ത ഏതെങ്കിലും ഫംഗ്‌ഷനുകൾ വിളിക്കുന്നു. "-l" (ചെറിയക്ഷരം
L) ഒരു പ്രത്യേക ലൈബ്രറിയുമായി ലിങ്ക് ചെയ്യാൻ ഓപ്ഷൻ പറയുന്നു:

cc -g xyz.o -o xyz -lm

സിസ്റ്റം ഗണിത ലൈബ്രറിയുമായി ലിങ്ക് ചെയ്യാൻ "-lm" പറയുന്നു, നിങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ അത് ആവശ്യമാണ്
"sqrt" പോലുള്ള പ്രവർത്തനങ്ങൾ.

സൂക്ഷിക്കുക: നിങ്ങൾ ഒന്നിൽ കൂടുതൽ "-l" ഓപ്‌ഷനുകൾ വ്യക്തമാക്കിയാൽ, ഓർഡർ ചിലതിൽ വ്യത്യാസം വരുത്തും
സംവിധാനങ്ങൾ. നിങ്ങൾ ഉൾപ്പെടുത്തിയതായി അറിയുമ്പോൾ നിങ്ങൾക്ക് നിർവചിക്കാത്ത വേരിയബിളുകൾ ലഭിക്കുകയാണെങ്കിൽ
അവ നിർവചിക്കുന്ന ലൈബ്രറി, നിങ്ങൾക്ക് ആ ലൈബ്രറി കമാൻഡിന്റെ അവസാനത്തിലേക്ക് നീക്കാൻ ശ്രമിക്കാം
ലൈൻ, അല്ലെങ്കിൽ കമാൻഡ് ലൈനിന്റെ അവസാനത്തിൽ ഇത് രണ്ടാം തവണ ഉൾപ്പെടുത്തുക.

ചിലപ്പോൾ നിങ്ങൾക്ക് ആവശ്യമായ ലൈബ്രറികൾ സിസ്റ്റത്തിനായുള്ള സ്ഥിരസ്ഥിതി സ്ഥലത്ത് സൂക്ഷിക്കില്ല
ലൈബ്രറികൾ. "-labc" എന്ന ഫയലിനായി തിരയുന്നു libabc.a or libabc.so or libabc.sa ലെ
സിസ്റ്റം ലൈബ്രറി ഡയറക്ടറികൾ (/ Usr / lib സാധാരണയായി മറ്റ് ചില സ്ഥലങ്ങളും, എന്തിനെ ആശ്രയിച്ചിരിക്കുന്നു
നിങ്ങൾ പ്രവർത്തിപ്പിക്കുന്ന ഒരുതരം Unix). "-L" ഓപ്ഷൻ തിരയാനുള്ള ഒരു അധിക ഡയറക്ടറി വ്യക്തമാക്കുന്നു
ലൈബ്രറികൾക്കായി. മുകളിലെ ഉദാഹരണം വീണ്ടും എടുക്കാൻ, നിങ്ങൾ Qt ലൈബ്രറികൾ ഇൻസ്റ്റാൾ ചെയ്തുവെന്ന് കരുതുക
in /home/users/joe/qt, അതിനർത്ഥം ലൈബ്രറി ഫയലുകൾ ഉള്ളിലാണെന്നാണ് /home/users/joe/qt/lib.
നിങ്ങളുടെ പ്രോഗ്രാമിനായുള്ള ലിങ്ക് ഘട്ടം ഇതുപോലെയായിരിക്കാം:

g++ -g test_mywidget.o mywidget.o -o test_mywidget -L/home/users/joe/qt/lib -lqt

(ചില സിസ്റ്റങ്ങളിൽ, നിങ്ങൾ Qt-ൽ ലിങ്ക് ചെയ്യുകയാണെങ്കിൽ, മറ്റ് ലൈബ്രറികളും ചേർക്കേണ്ടി വരും (ഉദാ,
"-L/usr/X11R6/lib -lX11 -lXext"). നിങ്ങൾ ചെയ്യേണ്ടത് നിങ്ങളുടെ സിസ്റ്റത്തെ ആശ്രയിച്ചിരിക്കും.)

"-L" നും ഡയറക്‌ടറി നാമത്തിനും ഇടയിൽ ഇടമില്ലെന്ന് ശ്രദ്ധിക്കുക. സാധാരണയായി "-L" ഓപ്ഷൻ
അത് ബാധിക്കുമെന്ന് കരുതുന്ന ഏതെങ്കിലും "-l" ഓപ്ഷനുകൾക്ക് മുമ്പായി പോകുന്നു.

നിങ്ങൾക്ക് ഏതൊക്കെ ലൈബ്രറികൾ ആവശ്യമാണെന്ന് നിങ്ങൾക്ക് എങ്ങനെ അറിയാം? പൊതുവേ, ഇത് ബുദ്ധിമുട്ടുള്ള ഒരു ചോദ്യമാണ്, വ്യത്യസ്തമാണ്
നിങ്ങൾ ഏത് തരത്തിലുള്ള Unix ആണ് പ്രവർത്തിപ്പിക്കുന്നത് എന്നതിനെ ആശ്രയിച്ച്. ഫംഗ്‌ഷനുകൾക്കായുള്ള ഡോക്യുമെന്റേഷൻ അല്ലെങ്കിൽ
നിങ്ങൾ ഉപയോഗിക്കുന്ന ക്ലാസുകളിൽ നിങ്ങൾ ലിങ്ക് ചെയ്യേണ്ട ലൈബ്രറികൾ എന്തൊക്കെയാണെന്ന് പറയണം. നിങ്ങൾ ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ
ഒരു ബാഹ്യ പാക്കേജിൽ നിന്നുള്ള ഫംഗ്‌ഷനുകൾ അല്ലെങ്കിൽ ക്ലാസുകൾ, സാധാരണയായി നിങ്ങൾ ലിങ്ക് ചെയ്യേണ്ട ഒരു ലൈബ്രറിയുണ്ട്
കൂടെ; ലൈബ്രറി സാധാരണയായി "libabc.a" അല്ലെങ്കിൽ "libabc.so" അല്ലെങ്കിൽ "libabc.sa" എന്ന് വിളിക്കപ്പെടുന്ന ഒരു ഫയലായിരിക്കും.
നിങ്ങൾക്ക് ഒരു "-labc" ഓപ്ഷൻ ചേർക്കണമെങ്കിൽ.

കുറെ മറ്റ് ചിന്താക്കുഴപ്പമുള്ള കാര്യങ്ങൾ
സാധാരണയായി ബാധകമാകുന്ന ഓപ്ഷനുകൾ വ്യക്തമാക്കുന്നത് സാധ്യമാണെന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചിരിക്കാം
ലിങ്കിംഗ് സ്റ്റെപ്പിലെ സമാഹാരം, കൂടാതെ ലിങ്ക് ചെയ്യുന്നതിന് സാധാരണയായി ബാധകമായ ഓപ്ഷനുകൾ
സമാഹാര ഘട്ടം. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കമാൻഡുകൾ സാധുവാണ്:

cc -g -L/usr/X11R6/lib -c xyz.c -o xyz.o
cc -g -I/എവിടെയോ/xyz.o -o xyz ഉൾപ്പെടുത്തുക

അപ്രസക്തമായ ഓപ്ഷനുകൾ അവഗണിക്കപ്പെടുന്നു; മുകളിലുള്ള കമാൻഡുകൾ ഇതിന് തുല്യമാണ്:

cc -g -c xyz.c -o xyz.o
cc -g xyz.o -o xyz

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