C++#
VEXcode EXP C++ പ്രോജക്റ്റുകളിൽ ഉപയോഗിക്കുന്ന ക്ലാസുകൾ, വസ്തുക്കൾ, കൺസ്ട്രക്റ്ററുകൾ, അംഗ ഫംഗ്ഷനുകൾ, വേരിയബിളുകൾ എന്നിവ VEX EXP C++ API റഫറൻസ് വിശദീകരിക്കുന്നു.
ഒരു ഉപകരണം അല്ലെങ്കിൽ സവിശേഷത എങ്ങനെ സൃഷ്ടിക്കപ്പെടുന്നുവെന്ന് മനസ്സിലാക്കാൻ, ഏത് ഫംഗ്ഷൻ സിഗ്നേച്ചർ ഉപയോഗിക്കണമെന്ന് പരിശോധിക്കാൻ, അല്ലെങ്കിൽ ഒരു ക്ലാസിലെ അനുബന്ധ അംഗ ഫംഗ്ഷനുകൾ താരതമ്യം ചെയ്യാൻ ആഗ്രഹിക്കുമ്പോൾ ഈ റഫറൻസ് ഉപയോഗിക്കുക.
VEXcode EXP C++ പ്രോജക്റ്റുകളിൽ C++ കമാൻഡുകൾ ഉപയോഗിക്കുന്നു. VEX വിഷ്വൽ സ്റ്റുഡിയോ കോഡ് എക്സ്റ്റൻഷൻ ഉപയോഗിച്ച് വിഷ്വൽ സ്റ്റുഡിയോ കോഡിൽ എഴുതിയ പ്രോജക്റ്റുകളെ C++ API വിവരങ്ങൾക്ക് പിന്തുണയ്ക്കാനും കഴിയും.
ഒരു സി++ ക്ലാസ് പേജ് എങ്ങനെ വായിക്കാം#
ഒരു C++ ക്ലാസ് പേജ് സാധാരണയായി ഈ ക്രമം പിന്തുടരുന്നു:
ആമുഖം - ക്ലാസ് എന്തിനെ പ്രതിനിധീകരിക്കുന്നുവെന്നും അത് എപ്പോൾ ഉപയോഗപ്രദമാണെന്നും വിശദീകരിക്കുന്നു.
ഉത്ഭവിച്ച ക്ലാസുകൾ - ബാധകമെങ്കിൽ, ഈ ക്ലാസിനെ അടിസ്ഥാനമാക്കിയുള്ള ഏതെങ്കിലും ക്ലാസുകൾ പട്ടികപ്പെടുത്തുന്നു.
ക്ലാസ് കൺസ്ട്രക്റ്റർ അല്ലെങ്കിൽ കൺസ്ട്രക്റ്റർമാർ - ക്ലാസ്സിൽ നിന്ന് ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന വാക്യഘടന കാണിക്കുന്നു.
ക്ലാസ് ഡിസ്ട്രക്റ്റർ - ബാധകമെങ്കിൽ, വസ്തുവിനെ നശിപ്പിക്കാനും അതിന്റെ ഉറവിടങ്ങൾ പുറത്തുവിടാനും ഉപയോഗിക്കുന്ന വാക്യഘടന കാണിക്കുന്നു.
പാരാമീറ്ററുകൾ - ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുമ്പോൾ ഉപയോഗിക്കുന്ന കൺസ്ട്രക്റ്റർ പാരാമീറ്ററുകൾ വിശദീകരിക്കുന്നു.
ഉദാഹരണം - കോഡിൽ ഒബ്ജക്റ്റ് എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് കാണിക്കുന്നു.
മെമ്പർ ഫംഗ്ഷനുകൾ - ക്ലാസിൽ ഉൾപ്പെടുന്ന ഫംഗ്ഷനുകൾ പട്ടികപ്പെടുത്തുന്നു, പലപ്പോഴും ഉദ്ദേശ്യമനുസരിച്ച് ഗ്രൂപ്പുചെയ്യുന്നു.
ഫംഗ്ഷൻ എൻട്രികൾ - ലഭ്യമായ ഫംഗ്ഷനുകൾ, പാരാമീറ്ററുകൾ, റിട്ടേൺ മൂല്യങ്ങൾ, കുറിപ്പുകൾ, ഉദാഹരണങ്ങൾ എന്നിവ ഉൾപ്പെടെ ഓരോ അംഗ ഫംഗ്ഷനും വിശദീകരിക്കുന്നു.
എല്ലാ പേജുകളിലും ഓരോ സെക്ഷനില്ല. ഉദാഹരണത്തിന്, ചില പേജുകളിൽ ഡിറൈവ്ഡ് ക്ലാസുകൾ ഉൾപ്പെടുന്നില്ല, കൂടാതെ ചില ഫംഗ്ഷനുകളിൽ പാരാമീറ്ററുകളോ റിട്ടേൺ മൂല്യങ്ങളോ ഇല്ല.
സാധാരണ C++ API ഘടകങ്ങൾ#
ഘടകം |
അതിന്റെ അർത്ഥം |
|---|---|
ക്ലാസ് |
|
വസ്തു |
|
നിർമ്മാതാവ് |
ഒരു ക്ലാസ്സിൽ നിന്ന് ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന കോഡ്. |
അംഗ പ്രവർത്തനം |
|
ലഭ്യമായ പ്രവർത്തനം |
ഒരു അംഗ ഫംഗ്ഷന് ഉപയോഗിക്കാൻ കഴിയുന്ന ഒരു കൃത്യമായ ഫംഗ്ഷൻ ഒപ്പ്. ചില അംഗ ഫംഗ്ഷനുകൾക്ക് ഒന്നിലധികം ഫംഗ്ഷനുകൾ ലഭ്യമാണ്. |
പാരാമീറ്റർ |
ഒരു കൺസ്ട്രക്റ്ററിലേക്കോ ഫംഗ്ഷനിലേക്കോ അത് ചെയ്യുന്നതിനെ നിയന്ത്രിക്കാൻ ഒരു മൂല്യം കൈമാറുന്നു. |
റിട്ടേൺ മൂല്യം |
ഒരു ഫംഗ്ഷൻ തിരികെ നൽകുന്ന ഒരു മൂല്യം, ഉദാഹരണത്തിന് |
അടിസ്ഥാന സി++ പദാവലി#
കാലാവധി |
അതിന്റെ അർത്ഥം |
|---|---|
വേരിയബിൾ |
|
തരം |
|
സ്ട്രിംഗ് |
|
ഇന്റ് |
|
ഇരട്ട |
|
പൂൾ |
|
വാദം |
ഒരു അംഗ ഫംഗ്ഷനിലേക്കോ ഫംഗ്ഷൻ കോളിലേക്കോ ഒരു മൂല്യം കൈമാറി, ഉദാഹരണത്തിന് |
കൺസ്ട്രക്റ്ററുകളും വസ്തുക്കളും#
നിരവധി C++ ക്ലാസുകളിൽ നിന്നുള്ള അംഗ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നതിന് മുമ്പ്, ഒരു ഒബ്ജക്റ്റ് നിലവിലുണ്ടായിരിക്കണം. ആ ഒബ്ജക്റ്റ് എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് കൺസ്ട്രക്റ്റർ കാണിക്കുന്നു.
ഉദാഹരണത്തിന്, കൺസ്ട്രക്റ്ററിന് ആവശ്യമായ പോർട്ട് അല്ലെങ്കിൽ കോൺഫിഗറേഷൻ വിവരങ്ങൾ നൽകി ഒരു മോട്ടോർ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ കഴിയും:
motor Motor1 = motor(PORT1, false);
ഒബ്ജക്റ്റ് സൃഷ്ടിച്ച ശേഷം, അതിന്റെ അംഗ പ്രവർത്തനങ്ങളെ ഇങ്ങനെ വിളിക്കാം:
Motor1.spin(forward);
VEXcode-ൽ, ഉപകരണ മെനു വഴി ഉപകരണ കോൺഫിഗറേഷൻ പലപ്പോഴും യാന്ത്രികമായി സൃഷ്ടിക്കപ്പെടുന്നു. VEX എക്സ്റ്റൻഷനോടുകൂടിയ വിഷ്വൽ സ്റ്റുഡിയോ കോഡിൽ, കൺസ്ട്രക്റ്ററുകൾ സ്വമേധയാ എഴുതേണ്ടി വന്നേക്കാം.
ലഭ്യമായ ശരിയായ ഫംഗ്ഷൻ തിരഞ്ഞെടുക്കുന്നു#
ചില അംഗ ഫംഗ്ഷനുകൾക്ക് ഒന്നിലധികം ഫംഗ്ഷനുകൾ ലഭ്യമാണ്. ഓരോ ഫംഗ്ഷനും വ്യത്യസ്ത പാരാമീറ്ററുകൾ ഉപയോഗിക്കുന്നു, അതിനാൽ നിങ്ങളുടെ പ്രോജക്റ്റ് നൽകേണ്ട മൂല്യങ്ങളുമായി പൊരുത്തപ്പെടുന്ന ഒന്ന് തിരഞ്ഞെടുക്കുക.
ഉദാഹരണത്തിന്, ഒരു ഡ്രൈവ്ട്രെയിൻ ഫംഗ്ഷന് നിലവിലെ വേഗത ഉപയോഗിക്കുന്ന ഒരു പതിപ്പും പ്രോജക്റ്റിന് ഒരു വേഗത തിരഞ്ഞെടുക്കാൻ അനുവദിക്കുന്ന മറ്റൊരു പതിപ്പും ഉണ്ടായിരിക്കാം:
void drive(directionType dir);
void drive(directionType dir, double velocity, velocityUnits units);
രണ്ട് ഫംഗ്ഷനുകളും driveഎന്ന് വിളിക്കുന്നു, പക്ഷേ രണ്ടാമത്തെ ഫംഗ്ഷനിൽ പ്രവേഗ പാരാമീറ്ററുകൾ ഉൾപ്പെടുന്നതിനാൽ കൂടുതൽ നിയന്ത്രണം നൽകുന്നു.
ഫംഗ്ഷൻ എൻട്രിയുടെ ഉദാഹരണം#
ഡ്രൈവ് ചെയ്യുക#
drive റോബോട്ടിനെ എന്നെന്നേക്കുമായി മുന്നോട്ട് അല്ലെങ്കിൽ പിന്നിലേക്ക് നീക്കുന്നു. തിരിയുകയോ നിർത്തുകയോ പോലുള്ള മറ്റൊരു പ്രവർത്തനം നൽകുന്നതുവരെ റോബോട്ട് നീങ്ങുന്നത് തുടരും. RPM അല്ലെങ്കിൽ DPS-ന്, ഡ്രൈവ്‌ട്രെയിനിന്റെ ഗിയർ അനുപാതം അനുസരിച്ചാണ് പരിധി മാറ്റുന്നത്.
ലഭ്യമായ പ്രവർത്തനങ്ങൾ
void drive(directionType dir);
void drive(directionType dir, double velocity, velocityUnits units);
പാരാമീറ്റർ |
ടൈപ്പ് ചെയ്യുക |
വിവരണം |
|---|---|---|
|
|
റോബോട്ട് നീങ്ങുന്ന ദിശ: |
|
|
|
|
|
പ്രവേഗ യൂണിറ്റ്: |
റിട്ടേൺ മൂല്യം
ഈ ഫംഗ്ഷൻ ഒരു മൂല്യം തിരികെ നൽകുന്നില്ല.
കുറിപ്പുകൾ
driveകാത്തിരിക്കുന്നില്ല; കോൾ കഴിഞ്ഞയുടനെ പ്രോജക്റ്റ് അടുത്ത കോഡ് വരി നടപ്പിലാക്കുന്നത് തുടരും.stopവിളിക്കുന്നത് വരെയോ അല്ലെങ്കിൽ മറ്റൊരു ഡ്രൈവ്ട്രെയിൻ മൂവ്മെന്റ് ഫംഗ്ഷൻ നടപ്പിലാക്കുന്നത് വരെയോ ഡ്രൈവ്ട്രെയിൻ നീങ്ങിക്കൊണ്ടിരിക്കും.isDoneഉംisMovingഉം പോലുള്ള ഫംഗ്ഷനുകൾdriveന് ബാധകമല്ല, കാരണം അത് ലക്ഷ്യാധിഷ്ഠിത ചലനം ഉപയോഗിക്കുന്നില്ല.
ഉദാഹരണം
// Drive forward and back
myDrivetrain.drive(forward);
wait(2, seconds);
myDrivetrain.drive(reverse, 25, rpm);
wait(2, seconds);
myDrivetrain.stop();
കാത്തിരിപ്പും കാത്തിരിപ്പുമില്ലാത്ത പെരുമാറ്റം#
ചില C++ മൂവ്മെന്റ് ഫംഗ്ഷനുകൾ ഒരു പ്രവർത്തനം പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കുന്നു, തുടർന്ന് പ്രോജക്റ്റ് അടുത്ത കോഡ് വരിയിലേക്ക് നീങ്ങുന്നു. മറ്റ് ഫംഗ്ഷനുകൾ ഒരു പ്രവർത്തനം ആരംഭിക്കുകയും അടുത്ത വരി ഉടൻ പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുകയും ചെയ്യുന്നു.
കാത്തിരിക്കുന്നു - ഫംഗ്ഷൻ പൂർത്തിയാകുന്നതുവരെ പ്രോജക്റ്റ് കാത്തിരിക്കുന്നു.
നോൺ-വെയിറ്റിംഗ് - പ്രോജക്റ്റ് ഫംഗ്ഷൻ ആരംഭിച്ച് ഉടൻ തന്നെ അടുത്ത വരിയിലേക്ക് പോകുന്നു.
ചില ഫംഗ്ഷനുകളിൽ ഈ സ്വഭാവം തിരഞ്ഞെടുക്കുന്നതിന് waitForCompletion പോലുള്ള ഒരു പാരാമീറ്റർ ഉൾപ്പെടുന്നു. ആ ഫംഗ്ഷനുകളിൽ, true സാധാരണയായി പ്രോജക്റ്റിനെ കാത്തിരിക്കാൻ പ്രേരിപ്പിക്കുന്നു, അതേസമയം false അടുത്ത വരി ഉടൻ പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു.
ഉപവിഭാഗങ്ങളിലെ കമാൻഡുകൾ#
C++ കമാൻഡുകൾ ഉപകരണം അല്ലെങ്കിൽ വിഷയം അനുസരിച്ചാണ് ക്രമീകരിച്ചിരിക്കുന്നത്. ഉദാഹരണത്തിന്, ഡ്രൈവ്ട്രെയിൻ, മോഷൻ, ബ്രെയിൻ, കൺട്രോളർ, സ്മാർട്ട് പോർട്ട് ഉപകരണങ്ങൾ, 3-വയർ ഉപകരണങ്ങൾ, കൺസോൾ, ലോജിക്, VEXlink എന്നിവയ്ക്കുള്ള കമാൻഡുകൾ അവയുടെ സ്വന്തം ഉപവിഭാഗങ്ങളായി തരംതിരിച്ചിരിക്കുന്നു.