പ്രവർത്തനങ്ങൾ#

ആമുഖം #

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

C+±ൽ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്നതിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ ഈ പേജ് ഉൾക്കൊള്ളുന്നു, അവയിൽ ഇവ ഉൾപ്പെടുന്നു:

ഫംഗ്ഷൻ ഘടനയും വാക്യഘടനയും — റിട്ടേൺ തരങ്ങൾ, പേരുകൾ, പാരാമീറ്ററുകൾ എന്നിവയുൾപ്പെടെ C+±ൽ ഫംഗ്ഷനുകൾ എങ്ങനെ എഴുതപ്പെടുന്നു.
ഫംഗ്ഷൻ പ്രോട്ടോടൈപ്പുകൾ — പ്രോട്ടോടൈപ്പ് ഫംഗ്ഷനുകൾ എന്തൊക്കെയാണ്, അവ എന്തിനാണ് ഉപയോഗിക്കുന്നത്.
ഫംഗ്ഷനുകൾ നിർവചിക്കുകയും വിളിക്കുകയും ചെയ്യുന്നു — നിങ്ങളുടെ പ്രോഗ്രാമിൽ നിന്ന് ഫംഗ്ഷനുകൾ സൃഷ്ടിച്ച് അവയെ എങ്ങനെ വിളിക്കാം.
റിട്ടേൺ മൂല്യങ്ങൾ — ഫംഗ്ഷനുകൾക്ക് കോളറിലേക്ക് ഡാറ്റ തിരികെ അയയ്ക്കാൻ കഴിയുന്നതെങ്ങനെ.
റഫറൻസ് വഴി കടന്നുപോകുന്നു — ഫംഗ്ഷനുകൾക്ക് അവയുടെ സ്വന്തം പരിധിക്ക് പുറത്ത് വേരിയബിളുകൾ എങ്ങനെ പരിഷ്കരിക്കാനാകും.
കോൾബാക്ക് ഫംഗ്ഷനുകൾ — ഇവന്റുകൾക്ക് മറുപടിയായി ഫംഗ്ഷനുകൾ മറ്റ് ഫംഗ്ഷനുകളിലേക്ക് എങ്ങനെ കൈമാറാമെന്നും യാന്ത്രികമായി വിളിക്കാമെന്നും.
ഡിഫോൾട്ട് ആർഗ്യുമെന്റുകളുള്ള പ്രവർത്തനങ്ങൾ — ഒരു ആർഗ്യുമെന്റും നൽകാത്തപ്പോൾ പാരാമീറ്ററുകൾക്ക് ഡിഫോൾട്ട് മൂല്യങ്ങൾ എങ്ങനെ നൽകാം.

ഫംഗ്ഷൻ ഘടനയും വാക്യഘടനയും #

C+±ൽ, ഫംഗ്ഷനുകൾ അവയുടെ റിട്ടേൺ തരം, പേര്, പാരാമീറ്ററുകൾ എന്നിവ ഉപയോഗിച്ച് പ്രഖ്യാപിക്കണം. അടിസ്ഥാന വാക്യഘടന ഇതാണ്:

return_type function_name(parameters) {
  // Code to execute when the function is called
  return result;  // Optional, used to return a value
}

പ്രവർത്തന ഭാഗങ്ങൾ	വിവരണം
`return_type`	ഫംഗ്ഷൻ നൽകുന്ന ഡാറ്റാ തരം, ചില സാധാരണ ഓപ്ഷനുകൾ ഇവയാണ്: `void` — nothing `int` നൽകുന്നു — ഒരു പൂർണ്ണസംഖ്യ മൂല്യം നൽകുന്നു `double` — ഒരു ഫ്ലോട്ടിംഗ്-പോയിന്റ് നമ്പർ നൽകുന്നു `bool` — `true` അല്ലെങ്കിൽ `false` `char` — ഒരു സിംഗിൾ ക്യാരക്ടർ നൽകുന്നു `const char*` — ഒരു ടെക്സ്റ്റ് സ്ട്രിംഗ് നൽകുന്നു ഉപയോക്തൃ-നിർവചിച്ച തരങ്ങൾ — ഒരു `struct` അല്ലെങ്കിൽ class object നൽകുന്നു
`function_name`	ഫംഗ്ഷന്റെ പേര്.
`parameters`	ഓപ്ഷണൽ. `type name`എന്ന് എഴുതിയിരിക്കുന്ന ടൈപ്പ് ചെയ്ത പാരാമീറ്ററുകളുടെ കോമയാൽ വേർതിരിച്ച ഒരു ലിസ്റ്റ്, ഇവിടെ `type` പാരാമീറ്ററിന്റെ ഡാറ്റ തരം വ്യക്തമാക്കുന്നു, കൂടാതെ `name` ഫംഗ്ഷനുള്ളിൽ ആ മൂല്യം ആക്‌സസ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന ഐഡന്റിഫയറാണ്. ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ പാരാമീറ്ററുകൾക്ക് ഇൻപുട്ട് മൂല്യങ്ങൾ ലഭിക്കും.
`result`	ഓപ്ഷണൽ. ഫംഗ്ഷൻ നൽകുന്ന മൂല്യം. ഫംഗ്ഷന്റെ `return_type` `void`അല്ലെങ്കിൽ, ഈ മൂല്യം നൽകണം, കൂടാതെ അതിന്റെ തരം വ്യക്തമാക്കിയ `return_type` മായി കൃത്യമായി പൊരുത്തപ്പെടണം.

കുറിപ്പ്: ഒരു ഫംഗ്ഷൻ വിളിക്കുന്നതിന് മുമ്പ് *എല്ലായ്‌പ്പോഴും *ഡിക്ലയർ ചെയ്യണം, അല്ലെങ്കിൽ നിങ്ങൾ ഒരു ഫംഗ്ഷൻ പ്രോട്ടോടൈപ്പ് നൽകണം.

ഫംഗ്ഷൻ പ്രോട്ടോടൈപ്പുകൾ #

C+±ൽ, കോഡ് മുകളിൽ നിന്ന് താഴേക്ക് വായിക്കുന്നു. അതായത്, ഒരു ഫംഗ്ഷൻ വിളിക്കുന്നതിന് മുമ്പ് കംപൈലറിന് അത് അറിയണം.

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

ഒരു പ്രോട്ടോടൈപ്പ് ഇല്ലെങ്കിൽ, main()ന് മുകളിലുള്ള ഓരോ ഫംഗ്ഷനും നിങ്ങൾ നിർവചിക്കേണ്ടിവരും, ഇത് പ്രോജക്റ്റുകൾ വളരുന്തോറും പിന്തുടരുന്നത് ബുദ്ധിമുട്ടാക്കും.

// The function's prototype
void greeting();

int main() {
  greeting();
}

// Write the function's body after
void greeting() {
  Brain.Screen.print("Hello!");
}

ഫംഗ്ഷനുകൾ നിർവചിക്കലും വിളിക്കലും #

Functions with No Parameters #

ഒരു ഫംഗ്ഷന് ഇൻപുട്ട് ആവശ്യമില്ലെങ്കിൽ, പാരാമീറ്ററുകൾ ഇല്ലാതെ തന്നെ നിങ്ങൾക്ക് അത് നിർവചിക്കാം. ഫംഗ്ഷൻ ഒരു മൂല്യം നൽകുന്നില്ലെങ്കിൽ റിട്ടേൺ തരമായി void ഉപയോഗിക്കുക.

// Define a function to display a message
void greeting() {
    Brain.Screen.print("Hello!");
}

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    // Call the function to display the message
    greeting();
}

Functions with Parameters #

ഫംഗ്ഷനുകളിലേക്ക് നിങ്ങൾക്ക് പാരാമീറ്ററുകൾ ചേർക്കാനും കഴിയും, അത് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതിനായി വിവരങ്ങൾ കൈമാറാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

കുറിപ്പ്: സി-സ്റ്റൈൽ സ്ട്രിംഗുകൾ (const char*) അല്ലെങ്കിൽ സി++ സ്ട്രിംഗുകൾ (std::string ) ഉപയോഗിച്ച് ടെക്സ്റ്റ് കൈമാറാൻ കഴിയും.

// Define a function with a parameter
void namedGreeting(const char* name) {
    Brain.Screen.print("Hello, %s!", name);
}

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    namedGreeting("Stranger");
}

റിട്ടേൺ മൂല്യങ്ങൾ #

return കീവേഡ് ഉപയോഗിച്ച് ഫംഗ്ഷനുകൾക്ക് കോളറിലേക്ക് ഡാറ്റ തിരികെ അയയ്ക്കാൻ കഴിയും. ഇത് നിങ്ങളുടെ പ്രോജക്റ്റിലെ ഔട്ട്‌പുട്ട് പിടിച്ചെടുക്കാനും ഉപയോഗിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു.

// Define a function that multiplies numbers by 2
int timesTwo(int number) {
    return number * 2;
}

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    // Display the return value
    Brain.Screen.print("%d", timesTwo(2));
}

പാസിംഗ് ബൈ റഫറൻസ്#

ഡിഫോൾട്ടായി, C++ ഫംഗ്ഷൻ പാരാമീറ്ററുകളെ മൂല്യം പ്രകാരം കൈമാറുന്നു, അതായത് ഫംഗ്ഷന് യഥാർത്ഥ വേരിയബിൾ ന്റെ ഒരു പകർപ്പ് ലഭിക്കുന്നു. ഫംഗ്ഷനുള്ളിൽ വരുത്തുന്ന മാറ്റങ്ങൾ യഥാർത്ഥ മൂല്യത്തെ ബാധിക്കില്ല.

// Add 1 to the number
void addOne(int number) {
  number++;
}

int main() {
  int value = 5;
  addOne(value);
  // "value" will still be 5
}

ഒരു ഫംഗ്ഷന് യഥാർത്ഥ വേരിയബിൾ പരിഷ്കരിക്കാൻ അനുവദിക്കുന്നതിന്, & ചിഹ്നങ്ങൾ ഉപയോഗിച്ച് റഫറൻസ് വഴി പാരാമീറ്ററുകൾ കൈമാറാൻ കഴിയും.

// Add 1 to the number
void addOne(int& number) {
  number++;
}

int main() {
  int value = 5;
  addOne(value);
  // "value" will now be 6
}

റഫറൻസ് വഴി കടന്നുപോകുന്നത്, ഒരു മൂല്യം തിരികെ നൽകാതെ ഫംഗ്ഷന് പുറത്ത് നിർവചിച്ചിരിക്കുന്ന വേരിയബിളുകൾ അപ്ഡേറ്റ് ചെയ്യാൻ ഫംഗ്ഷനുകളെ അനുവദിക്കുന്നു.

കോൾബാക്ക് ഫംഗ്ഷനുകൾ #

ഒരു കോൾബാക്ക് ഫംഗ്ഷൻ എന്നത് മറ്റൊരു ഫംഗ്ഷനിലേക്ക് കൈമാറുകയും ഒരു പ്രത്യേക സംഭവം സംഭവിക്കുമ്പോൾ യാന്ത്രികമായി വിളിക്കപ്പെടുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷനാണ്.

ബട്ടൺ അമർത്തൽ അല്ലെങ്കിൽ സെൻസർ അപ്‌ഡേറ്റുകൾ പോലുള്ള ഇവന്റുകൾക്കാണ് കോൾബാക്കുകൾ സാധാരണയായി ഉപയോഗിക്കുന്നത്.

ചടങ്ങ് സ്വയം വിളിക്കുന്നതിനുപകരം, പരിപാടി നടക്കുമ്പോൾ പ്രോജക്റ്റ് അത് നിങ്ങൾക്കായി വിളിക്കുന്നു.

void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

// Call onPressed whenever the screen is pressed
int main() {
  vexcodeInit();
  Brain.Screen.pressed(onPressed);
}

Callback Signatures #

ഓരോ കോൾബാക്ക് ഫംഗ്ഷനും ഒരു പ്രത്യേക ഒപ്പ് പിന്തുടരണം, അത് നിർവചിക്കുന്നത്:

റിട്ടേൺ തരം
പാരാമീറ്ററുകളുടെ എണ്ണം
പാരാമീറ്റർ തരങ്ങൾ

ആവശ്യമായ ഒപ്പ് നിർണ്ണയിക്കുന്നത് API ആണ്. കോൾബാക്ക് ഫംഗ്ഷൻ ഈ ഒപ്പുമായി കൃത്യമായി പൊരുത്തപ്പെടണം.

// This callback function cannot include any parameters
void callback(void);

// This callback function includes four parameters
void callback(axisType axis, double x, double y, double z);

പാരാമീറ്റർ പേരുകൾ വിവരണാത്മകമാണ്, അവ വ്യത്യാസപ്പെടാം, പക്ഷേ റിട്ടേൺ തരം, പാരാമീറ്റർ ക്രമം, പാരാമീറ്റർ തരങ്ങൾ എന്നിവ കൃത്യമായി പൊരുത്തപ്പെടണം.

ഡിഫോൾട്ട് ആർഗ്യുമെന്റുകളുള്ള പ്രവർത്തനങ്ങൾ #

ഒന്നോ അതിലധികമോ പാരാമീറ്ററുകൾക്കുള്ള ഡിഫോൾട്ട് മൂല്യങ്ങൾ ഫംഗ്ഷനുകൾക്ക് നിർവചിക്കാൻ കഴിയും. ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ ആ പാരാമീറ്ററിന് ഒരു മൂല്യവും നൽകാത്തപ്പോൾ ഒരു ഡിഫോൾട്ട് ആർഗ്യുമെന്റ് ഉപയോഗിക്കുന്നു.

ഡിഫോൾട്ട് ആർഗ്യുമെന്റുകൾക്കുള്ള നിയമങ്ങൾ:

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

// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

int main() {
    vexcodeInit();

    // Say what name to greet (V5) and
    // use default value for repeatCount (1)
    greeting("V5");

    Brain.Screen.newLine();

    // Overrides the default value to 3
    greeting("V5", 3);
}