C++#

VEXcode C++ പ്രോജക്റ്റുകളിൽ ഉപയോഗിക്കുന്ന ക്ലാസുകൾ, വസ്തുക്കൾ, കൺസ്ട്രക്റ്ററുകൾ, അംഗ ഫംഗ്ഷനുകൾ, വേരിയബിളുകൾ എന്നിവ VEX IQ (ഒന്നാം തലമുറ) C++ API റഫറൻസ് വിശദീകരിക്കുന്നു.

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

VEXcode IQ C++ പ്രോജക്റ്റുകളിൽ C++ കമാൻഡുകൾ ഉപയോഗിക്കുന്നു. പല കമാൻഡുകളും ഒരു ക്ലാസിൽ ഉൾപ്പെടുന്നതിനാൽ, C++ പേജുകൾ ബ്ലോക്ക് പേജുകളിൽ നിന്ന് വ്യത്യസ്തമായി ക്രമീകരിച്ചിരിക്കുന്നു. ഒരു പേജ് ആദ്യം ക്ലാസും ഒരു ഒബ്ജക്റ്റ് എങ്ങനെ സൃഷ്ടിക്കാമെന്നും വിശദീകരിച്ചേക്കാം, തുടർന്ന് ആ ഒബ്ജക്റ്റിൽ വിളിക്കാവുന്ന അംഗ ഫംഗ്ഷനുകൾ പട്ടികപ്പെടുത്തിയേക്കാം.

ഒരു സി++ ക്ലാസ് പേജ് എങ്ങനെ വായിക്കാം#

ഒരു C++ ക്ലാസ് പേജ് സാധാരണയായി ഈ ക്രമം പിന്തുടരുന്നു:

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

എല്ലാ പേജുകളിലും ഓരോ സെക്ഷനില്ല. ഉദാഹരണത്തിന്, ചില പേജുകളിൽ ഡിറൈവ്ഡ് ക്ലാസുകൾ ഉൾപ്പെടുന്നില്ല, കൂടാതെ ചില ഫംഗ്ഷനുകളിൽ പാരാമീറ്ററുകളോ റിട്ടേൺ മൂല്യങ്ങളോ ഇല്ല.

സാധാരണ C++ API ഘടകങ്ങൾ#

ഘടകം	അതിന്റെ അർത്ഥം
ക്ലാസ്	`bumper` അല്ലെങ്കിൽ `drivetrain` പോലുള്ള ഒരു ഉപകരണത്തിനോ ഫീച്ചറിനോ വേണ്ടിയുള്ള C++ തരം.
വസ്തു	`bumper Bumper1` അല്ലെങ്കിൽ `drivetrain myDrivetrain` പോലുള്ള ഒരു ക്ലാസിൽ നിന്ന് സൃഷ്ടിച്ച പേരുള്ള ഒരു ഉദാഹരണം.
നിർമ്മാതാവ്	ഒരു ക്ലാസ്സിൽ നിന്ന് ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന കോഡ്.
അംഗ പ്രവർത്തനം	`myDrivetrain.drive(…)` പോലുള്ള ഒരു ഒബ്‌ജക്റ്റിൽ ഒരു കമാൻഡ് വിളിച്ചു.
ലഭ്യമായ പ്രവർത്തനം	ഒരു അംഗ ഫംഗ്ഷന് ഉപയോഗിക്കാൻ കഴിയുന്ന ഒരു കൃത്യമായ ഫംഗ്ഷൻ ഒപ്പ്. ചില അംഗ ഫംഗ്ഷനുകൾക്ക് ഒന്നിലധികം ഫംഗ്ഷനുകൾ ലഭ്യമാണ്.
പാരാമീറ്റർ	ഒരു കൺസ്ട്രക്റ്ററിലേക്കോ ഫംഗ്ഷനിലേക്കോ അത് ചെയ്യുന്നതിനെ നിയന്ത്രിക്കാൻ ഒരു മൂല്യം കൈമാറുന്നു.
റിട്ടേൺ മൂല്യം	ഒരു ഫംഗ്ഷൻ തിരികെ നൽകുന്ന ഒരു മൂല്യം, ഉദാഹരണത്തിന് `bool`, `int32_t`, അല്ലെങ്കിൽ `double`.

അടിസ്ഥാന സി++ പദാവലി#

കാലാവധി	അതിന്റെ അർത്ഥം
വേരിയബിൾ	`int speed = 50;`.
തരം	`int`, `double`, അല്ലെങ്കിൽ `bool` പോലുള്ള എന്തെങ്കിലും സംഭരിക്കുന്ന തരത്തിലുള്ള ഡാറ്റ.
സ്ട്രിംഗ്	`“Hello”` പോലുള്ള ഉദ്ധരണി ചിഹ്നങ്ങൾക്കുള്ളിലെ വാചകം.
ഇന്റ്	`90` പോലുള്ള ഒരു പോസിറ്റീവ് അല്ലെങ്കിൽ നെഗറ്റീവ് പൂർണ്ണ സംഖ്യ തരം.
ഇരട്ട	`25.5` പോലുള്ള ഒരു ദശാംശം ഉൾപ്പെടുത്താവുന്ന ഒരു സംഖ്യാ തരം.
പൂൾ	`true` അല്ലെങ്കിൽ `false` ആയ ഒരു മൂല്യം.
വാദം	ഒരു അംഗ ഫംഗ്ഷനിലേക്കോ ഫംഗ്ഷൻ കോളിലേക്കോ ഒരു മൂല്യം കൈമാറി, ഉദാഹരണത്തിന് `forward` ഇൻ `myDrivetrain.drive(forward)`.

കൺസ്ട്രക്റ്ററുകളും വസ്തുക്കളും#

നിരവധി C++ ക്ലാസുകളിൽ നിന്നുള്ള അംഗ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നതിന് മുമ്പ്, ഒരു ഒബ്ജക്റ്റ് നിലവിലുണ്ടായിരിക്കണം. ആ ഒബ്ജക്റ്റ് എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് കൺസ്ട്രക്റ്റർ കാണിക്കുന്നു.

ഉദാഹരണത്തിന്, സെൻസർ ബന്ധിപ്പിച്ചിരിക്കുന്ന സ്മാർട്ട് പോർട്ട് കൺസ്ട്രക്റ്ററിന് നൽകി ഒരു ബമ്പർ സ്വിച്ച് ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ കഴിയും:

bumper Bumper1 = bumper(PORT1);

ഒബ്ജക്റ്റ് സൃഷ്ടിച്ച ശേഷം, അതിന്റെ അംഗ പ്രവർത്തനങ്ങളെ ഇങ്ങനെ വിളിക്കാം:

Bumper1.pressing();

VEXcode-ൽ, ഉപകരണ മെനു വഴി ഉപകരണ കോൺഫിഗറേഷൻ പലപ്പോഴും യാന്ത്രികമായി സൃഷ്ടിക്കപ്പെടുന്നു. VS കോഡിൽ, കൺസ്ട്രക്റ്ററുകൾ സ്വമേധയാ എഴുതേണ്ടി വന്നേക്കാം.

ലഭ്യമായ ശരിയായ ഫംഗ്ഷൻ തിരഞ്ഞെടുക്കുന്നു#

ചില അംഗ ഫംഗ്ഷനുകൾക്ക് ഒന്നിലധികം ഫംഗ്ഷനുകൾ ലഭ്യമാണ്. ഓരോ ഫംഗ്ഷനും വ്യത്യസ്ത പാരാമീറ്ററുകൾ ഉപയോഗിക്കുന്നു, അതിനാൽ നിങ്ങളുടെ പ്രോജക്റ്റ് നൽകേണ്ട മൂല്യങ്ങളുമായി പൊരുത്തപ്പെടുന്ന ഒന്ന് തിരഞ്ഞെടുക്കുക.

ഉദാഹരണത്തിന്, ഒരു ഡ്രൈവ്ട്രെയിൻ ഫംഗ്ഷന് നിലവിലെ വേഗത ഉപയോഗിക്കുന്ന ഒരു പതിപ്പും പ്രോജക്റ്റിന് ഒരു വേഗത തിരഞ്ഞെടുക്കാൻ അനുവദിക്കുന്ന മറ്റൊരു പതിപ്പും ഉണ്ടായിരിക്കാം:

void drive(directionType dir);

void drive(directionType dir, double velocity, velocityUnits units);

രണ്ട് പതിപ്പുകളും driveഎന്ന് വിളിക്കുന്നു, പക്ഷേ രണ്ടാമത്തെ പതിപ്പ് കൂടുതൽ നിയന്ത്രണം നൽകുന്നു, കാരണം അതിൽ പ്രവേഗ പാരാമീറ്ററുകൾ ഉൾപ്പെടുന്നു.

ഫംഗ്ഷൻ എൻട്രിയുടെ ഉദാഹരണം#

ഡ്രൈവ് ചെയ്യുക#

drive റോബോട്ടിനെ എന്നെന്നേക്കുമായി മുന്നോട്ട് അല്ലെങ്കിൽ പിന്നിലേക്ക് നീക്കുന്നു. തിരിയുകയോ നിർത്തുകയോ പോലുള്ള മറ്റൊരു പ്രവർത്തനം നൽകുന്നതുവരെ റോബോട്ട് നീങ്ങുന്നത് തുടരും.

ലഭ്യമായ പ്രവർത്തനങ്ങൾ

void drive(directionType dir);

void drive(directionType dir, double velocity, velocityUnits units);

പാരാമീറ്റർ	ടൈപ്പ് ചെയ്യുക	വിവരണം
`dir`	`directionType`	റോബോട്ട് നീങ്ങുന്ന ദിശ: `forward` അല്ലെങ്കിൽ `reverse`.
`velocity`	`double`	`velocityUnits::pct`, `rpm`ഉപയോഗിക്കുമ്പോൾ 0 മുതൽ 120 rpm വരെ, അല്ലെങ്കിൽ `dps`ഉപയോഗിക്കുമ്പോൾ 0 മുതൽ 720 ഡിഗ്രി വരെ. വേഗത നൽകിയിട്ടില്ലെങ്കിൽ, റോബോട്ട് നിലവിലെ ഡ്രൈവ് വേഗതയിൽ ഡ്രൈവ് ചെയ്യുന്നു.
`units`	`velocityUnits`	പ്രവേഗ യൂണിറ്റ്: `velocityUnits::pct` (ശതമാനം), `rpm` (മിനിറ്റിൽ ഭ്രമണങ്ങൾ), അല്ലെങ്കിൽ `dps` (സെക്കൻഡിൽ ഡിഗ്രി).

റിട്ടേൺ മൂല്യം

ഈ ഫംഗ്ഷൻ ഒരു മൂല്യം തിരികെ നൽകുന്നില്ല.

കുറിപ്പുകൾ

drive കാത്തിരിക്കുന്നില്ല. പ്രോജക്റ്റ് ഉടൻ തന്നെ അടുത്ത കോഡ് വരി പ്രവർത്തിപ്പിക്കും.
stop വിളിക്കുന്നത് വരെയോ അല്ലെങ്കിൽ മറ്റൊരു ഡ്രൈവ്ട്രെയിൻ മൂവ്മെന്റ് ഫംഗ്ഷൻ പ്രവർത്തിക്കുന്നത് വരെയോ റോബോട്ട് ചലിക്കുന്നത് തുടരും.
isDone ഉം isMoving ഉം drive നൊപ്പം ഉപയോഗിക്കുന്നില്ല, കാരണം 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 അടുത്ത വരി ഉടൻ പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു.

ഉപവിഭാഗങ്ങളിലെ കമാൻഡുകൾ#

സി++ കമാൻഡുകൾ ഉപകരണം അല്ലെങ്കിൽ വിഷയം അനുസരിച്ചാണ് ക്രമീകരിച്ചിരിക്കുന്നത്. ഉദാഹരണത്തിന്, ബ്രെയിൻ, കൺട്രോളർ, ഡ്രൈവ്ട്രെയിൻ, ഇവന്റുകൾ, മോഷൻ, സ്മാർട്ട് പോർട്ട് ഉപകരണങ്ങൾ, ത്രെഡുകൾ, ലോജിക് എന്നിവയ്ക്കുള്ള കമാൻഡുകൾ അവയുടെ സ്വന്തം ഉപവിഭാഗങ്ങളായി തരംതിരിച്ചിരിക്കുന്നു.