C++#

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

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

VEXcode IQ C++ പ്രോജക്റ്റുകളിൽ C++ കമാൻഡുകൾ ഉപയോഗിക്കുന്നു. VEX വിഷ്വൽ സ്റ്റുഡിയോ കോഡ് എക്സ്റ്റൻഷൻ ഉപയോഗിച്ച് വിഷ്വൽ സ്റ്റുഡിയോ കോഡിൽ എഴുതിയ പ്രോജക്റ്റുകളെ C++ API വിവരങ്ങൾക്ക് പിന്തുണയ്ക്കാനും കഴിയും.

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

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

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

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

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

ഘടകം	അതിന്റെ അർത്ഥം
ക്ലാസ്	`motor` അല്ലെങ്കിൽ `drivetrain` പോലുള്ള ഒരു ഉപകരണത്തിനോ ഫീച്ചറിനോ വേണ്ടിയുള്ള C++ തരം.
വസ്തു	`motor Motor1` അല്ലെങ്കിൽ `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++ ക്ലാസുകളിൽ നിന്നുള്ള അംഗ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നതിന് മുമ്പ്, ഒരു ഒബ്ജക്റ്റ് നിലവിലുണ്ടായിരിക്കണം. ആ ഒബ്ജക്റ്റ് എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് കൺസ്ട്രക്റ്റർ കാണിക്കുന്നു.

ഉദാഹരണത്തിന്, കൺസ്ട്രക്റ്ററിന് ആവശ്യമായ പോർട്ട് അല്ലെങ്കിൽ കോൺഫിഗറേഷൻ വിവരങ്ങൾ നൽകി ഒരു ഉപകരണ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ കഴിയും:

motor Motor1 = motor(PORT1, false);

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

Motor1.spin(forward);

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

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

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

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

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 അടുത്ത വരി ഉടൻ പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു.

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

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