Feidhmeanna#

Réamhrá#

Is cuid bhunúsach de chláreoireacht C++ iad feidhmeanna, ag pacáistiú blúiríní cóid i gcodanna cód in-athúsáidte, éifeachtacha atá deartha chun tasc sonrach a dhéanamh. Is féidir feidhmeanna a ghlaoch arís agus arís eile laistigh de chlár, rud a fhágann go bhfuil sé níos éasca eagrú cóid a dhéanamh, agus a chabhraíonn le cód arís agus arís eile a sheachaint. Déanann feidhmeanna níos éasca dífhabhtú cóid a dhéanamh freisin.

Clúdaíonn an leathanach seo bunghnéithe úsáid feidhmeanna i C++, lena n-áirítear:

Struchtúr Feidhme agus Comhréir#

I C++, ní mór feidhmeanna a dhearbhú lena gcineál fillte, a n-ainm, agus a bparaiméadair. Seo an comhréir bhunúsach:

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

Páirteanna Feidhme

Cur síos

return_type

An cineál sonraí a thugann an fheidhm ar ais, seo a leanas roinnt roghanna coitianta:

  • void — Ní thugann sé tada ar ais
  • int — Tugann sé luach slánuimhir ar ais
  • double — Tugann sé uimhir snámhphointe ar ais
  • bool — Tugann sé true nó false
  • char — Tugann sé carachtar aonair ar ais
  • const char* — Tugann sé teaghrán téacs ar ais
  • cineálacha sainmhínithe ag an úsáideoir — Tugann sé réad struct nó ranga ar ais

function_name

Ainm na feidhme.

parameters

Roghnach. Liosta de pharaiméadair chlóscríofa scartha le camóga scríofa mar type name, áit a sonraíonn type cineál sonraí an pharaiméadair agus name an t-aitheantóir a úsáidtear chun rochtain a fháil ar an luach sin laistigh den fheidhm. Faigheann paraiméadair luachanna ionchuir nuair a ghlaotar ar an fheidhm.

result

Roghnach. An luach a thugann an fheidhm ar ais. Murab ionann return_type na feidhme agus void, ní mór an luach seo a sholáthar agus ní mór a chineál a bheith díreach mar an gcéanna leis an return_type sonraithe.

Nóta: Ní mór feidhm a dhearbhú i gcónaí sula nglaotar uirthi, nó ní mór duit fréamhshamhail feidhme a sholáthar.

Fréamhshamhlacha Feidhme#

I C++, léitear cód ó bharr go bun. Ciallaíonn sé seo go gcaithfidh feidhm a bheith ar eolas ag an tiomsaitheoir sula bhféadfar glaoch uirthi.

Le fréamhshamhail feidhme, is féidir leat feidhm a úsáid sula scríobhtar a cód iomlán. Ligeann sé seo duit main() a choinneáil gar do bharr do chláir agus sainmhínithe feidhme a chur níos déanaí, áit a bhfuil siad níos éasca a eagrú agus a léamh.

Gan fréamhshamhail, bheadh ​​ort gach feidhm os cionn main()a shainiú, rud a d’fhéadfadh a bheith níos deacra tionscadail a leanúint de réir mar a fhásann siad.

Sainmhínigh an fhréamhshamhail feidhme (lasmuigh de int main())

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

Glaoigh ar an fheidhm taobh istigh de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  greeting();
}

Scríobh corp na feidhme i ndiaidh

void greeting() {
  Brain.Screen.print("Hello!");
}

Feidhmeanna a Shainmhíniú agus a Ghlaoch#

Functions with No Parameters#

Mura bhfuil ionchur ag teastáil ó fheidhm, is féidir leat í a shainiú gan paraiméadair. Bain úsáid as void mar an cineál tuairisceáin mura dtugann an fheidhm luach ar ais.

Sainmhínigh an fheidhm (lasmuigh de int main())

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

Glaoigh ar an fheidhm taobh istigh de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call the function to display the message
  greeting();
}

Functions with Parameters#

Is féidir leat paraiméadair a chur le feidhmeanna freisin, rud a ligeann duit faisnéis a chur isteach le húsáid ag an bhfeidhm.

Nóta: Is féidir téacs a chur ar aghaidh ag baint úsáide as teaghráin stíl C (const char*) nó teaghráin C++ (std::string).

Sainmhínigh an fheidhm (lasmuigh de int main())

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

Glaoigh ar an bhfeidhm le paraiméadar taobh istigh de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call the function to display the message
  namedGreeting("Stranger");
}

Luachanna Fillte#

Is féidir le feidhmeanna sonraí a sheoladh ar ais chuig an nglaoiteoir ag baint úsáide as an eochairfhocal return Ligeann sé seo duit an t-aschur a ghabháil agus a úsáid i do thionscadal.

Sainmhínigh an fheidhm (lasmuigh de int main())

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

Glaoigh ar an bhfeidhm le paraiméadar taobh istigh de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Display the return value
  Brain.Screen.print("%d", timesTwo(2));
}

Ag Dul Thar Lear Tagairt#

De réir réamhshocraithe, cuireann C++ paraiméadair feidhme de réir luacha ar aghaidh, rud a chiallaíonn go bhfaigheann an fheidhm cóip den athróg bhunaidh. Ní dhéanann athruithe a dhéantar laistigh den fheidhm difear don luach bunaidh.

Sainmhínigh an fheidhm (lasmuigh de int main())

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

Glaoigh ar an bhfeidhm le paraiméadar taobh istigh de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

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

Chun go mbeidh feidhm in ann an athróg bunaidh a mhodhnú, is féidir paraiméadair a chur ar aghaidh trí thagairt ag baint úsáide as na siombailí &.

Sainmhínigh an fheidhm (lasmuigh de int main())

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

Glaoigh ar an bhfeidhm le paraiméadar taobh istigh de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

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

Trí thagairt a dhéanamh, is féidir le feidhmeanna athróga atá sainmhínithe lasmuigh den fheidhm a nuashonrú gan luach a thabhairt ar ais.

Feidhmeanna Athghlaoite#

Is feidhm í feidhm athghlaoite a chuirtear isteach i bhfeidhm eile agus a ghlaotar go huathoibríoch nuair a tharlaíonn teagmhas ar leith.

Is gnách go n-úsáidtear glaonna siar le haghaidh imeachtaí amhail brúigh cnaipe nó nuashonruithe braiteoirí.

In ionad glaoch ar an fheidhm tú féin, glaonn an tionscadal uirthi ar do shon nuair a tharlaíonn an teagmhas.

Sainmhínigh an fheidhm athghlaoite (lasmuigh de int main())

// Create a callback function
void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

Cláraigh an glao ar ais taobh istigh de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call onPressed whenever the screen is pressed
  Brain.Screen.pressed(onPressed);
}

Callback Signatures#

Caithfidh gach feidhm athghlaoite síniú sonrach a leanúint, a shainmhíníonn:

  • An cineál tuairisceáin

  • Líon na bparaiméadar

  • Na cineálacha paraiméadair

Is é an API a chinneann an síniú riachtanach. Caithfidh an fheidhm athghlaoite a bheith mar an gcéanna go díreach leis an síniú seo.

// 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);

Bíonn ainmneacha paraiméadair tuairisciúil agus féadfaidh siad a bheith éagsúil, ach ní mór don chineál tuairisceáin, ord na bparaiméadar, agus cineálacha na bparaiméadar a bheith mar an gcéanna go beacht.

Feidhmeanna le hArgóintí Réamhshocraithe#

Is féidir le feidhmeanna luachanna réamhshocraithe a shainiú do pharaiméadar amháin nó níos mó. Úsáidtear argóint réamhshocraithe nuair nach soláthraítear aon luach don pharaiméadar sin nuair a ghlaotar ar an bhfeidhm.

Rialacha maidir le hargóintí réamhshocraithe:

  • Ní mór na hargóintí réamhshocraithe a bheith ar na paraiméadair dheireanacha i sainmhíniú na feidhme.

  • Nuair a bhíonn luach réamhshocraithe ag paraiméadar, ní mór luachanna réamhshocraithe a bheith ag gach paraiméadar ina dhiaidh freisin.

  • Mura sonraíonn feidhm argóintí réamhshocraithe ina prototype, ní féidir na luachanna réamhshocraithe sin a shonrú arís i sainmhíniú na feidhme.

Sainmhínigh an fheidhm (lasmuigh de int main())

// 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();
    }
}

Glaoigh ar an fheidhm taobh istigh de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

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

  Brain.Screen.newLine();

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


// 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 (EXP) and
    // use default value for repeatCount (1)
    greeting("EXP");

    Brain.Screen.newLine();

    // Overrides the default value to 3
    greeting("EXP", 3);
}
On this page