Proposita Discendi

Expleta hac lectione, didiceris:

• Intellegere finem functionum et cur sint necessariae in C++.
• Creare functiones recte, ut codex structus sit.
• Invocare functiones intra programma et comprehendere quomodo exsequantur.
• Distinguere inter functiones quae valores reddunt et eas quae tantum praecepta exsequuntur.
• Comparare varias formas functiones definiendi et optimam eligere secundum condicionem.

Declaratio, Invocatio et Definitio Functionum

In C++, functiones sunt segmenta codicis iterabilia quae sinunt programmata modo modulari atque ordinato componi. Unaquaeque functio proprium munus includit, quod adiuvat ad claritatem et conservabilitatem codicis augendam. Ut functio in programmate adhiberi possit, tres gradus fundamentales sequi debemus: declaratio, invocatio et definitio.

Hi tres conceptus sunt essentiales, et unusquisque proprium propositum in structura codicis implet. Videamus unumquemque diligentius.

1. Declaratio functionis

   Antequam functio in codice adhiberi possit, compilatori nuntiandum est eius existentiam. Hoc fit per declarationem functionis seu prototypon.

   Declaratio functionis tria elementa fundamentalia compilatori indicat:

   • Genus datorum quod functio reddet (vel void si nihil reddit).
   • Nomen functionis.
   • Parametri quos accipit (si adsunt), una cum generibus eorum.

   Syntaxis generalis declarationis functionis est:

   tipo_de_retorno nombre_de_funcion (lista_de_parametros);
   

   Declaratio functionis plerumque ponitur ante main() aut in archivo capitis .h cum cum pluribus archivis laboramus.

2. Invocatio functionis

   Postquam functio declarata est, eam invocare possumus, id est, in codice appellare ut exsequi possit.

   Cum functio invocatur:

   • Exsequitur codicem in eius definitione contentum.
   • Si functio valorem reddit, hic in variabili reponi potest aut directe in expressione adhiberi.
   • Si functio est generis void, simpliciter suas instructiones exsequitur sine ullo reditu.

   Syntaxis invocationis functionis est simpliciter scribere eius nomen cum parenthesibus et argumentis (si opus sunt):

   nombre_de_funcion(argumentos);
   

3. Definitio functionis:

   Denique definitio functionis est pars in qua eius actio impletur. Hic specificantur instructiones quae exsequentur cum functio invocabitur.

   Syntaxis generalis definitionis functionis est:

   tipo_de_retorno nombre_de_funcion (lista_de_parametros) {
       // Corpus functionis: instructiones exsequendae
       return valor; // (si functio valorem reddit)
   }
   

   Unaquaeque definitio functionis regulas sequentes observare debet:

   • Debet congruere cum declaratione (si antea declarata est).
   • Si functio valorem reddit (exempli gratia, int), oportet includere praeceptionem return cum valore reddendo.
   • Si functio nihil reddit (void), simpliciter suas instructiones exsequitur nec return indiget.

Fluxus exsecutionis

Cum programma exsequitur, functiones vocantur eo ordine quo apparent in main(). Fluxus exsecutionis est hic:

1. Compilator agnoscit declarationem functionis.
2. In main(), cum inventa est invocatio functionis, imperium programmatis transfertur ad definitionem functionis.
3. Functio suas instructiones exsequitur.
4. Si functio valorem redit, hic redditur ad lineam ubi invocata est.
5. Fluxus programmatis redit ad main() vel ad functionem quae invocationem fecit.

Momentum declarationis praeviæ

Declaratio functionum antequam adhibeantur est maximi momenti quia compilator C++ codicem desuper deorsum pertractat. Si conemur functionem vocare antequam definita vel declarata sit, errorem accipiemus.

Duae formae principales ad hoc tractandum exstant:

1. Declarare functionem ante main() et eam postea definire (ut hucusque vidimus).
2. Definire functionem ante main(), ita necessitatem declarationis praeviæ vitans.

Uterque modus est validus, sed primus utilior est in magnis programmatibus ubi functiones in diversis archivis sunt.

Ratio: Declarare – Invocare – Definire

Unus ex usitatissimis modis ad functiones in C++ ordinandas est declarare – invocare – definire. Hac ratione sequenda, codicem nostrum in tres gradus fundamentales disponimus:

1. Declaratio: Compilatori nuntiatur de existentia functionis antequam adhibeatur, specificando eius nomen, genus reditus et parametros (si adsunt).
2. Invocatio: Functio vocatur intra codicem principalem (main() in plerisque casibus), exsequens suum contentum.
3. Definitio: Explanatur implementatio functionis, specificando quas instructiones exsequetur cum invocabitur.

Haec structura permittit emendare ordinationem codicis, conservationem et amplificabilitatem faciliorem reddens. Exemplum recognoscamus quo hoc consilium adhibemus:

Exemplum: Functio consoladice()

In sequenti codice, sequimur seriem declarare – invocare – definire:

#include <iostream>
using namespace std;
// Primo functionem declaramus
void consoladice();
int main() {
    // Functionem invocamus
    consoladice();
    return 0;
}
// Functionem antea declaratam definimus, eius internum munus explicantes
void consoladice() {
    cout << "Hoc est simplex vinculum characterum sive literalium." << endl;
    cout << "Nunc tibi ostendo numerum quinque. Ecce hic est: " << 5 << endl;
    cout << "Videamus quid efficiatur si facimus 10/5. Eventus est: " << 10/5 << endl;
    cout << "Via typica ad numerum Pi approximandum est faciendo 22/7. Eventus est: " << 22/7 << endl;
    cout << "In C++ non idem est scribere 22/7 quam 22.0/7, tractatio diversa est." << endl;
    cout << "Hoc simplici mutamento videre possumus quod 22.0/7 est aequale " << 22.0/7 << endl;
    cout << "Nonne hoc tibi melior approximatio videtur?" << endl;
}

Eventus exspectatus huius codicis est

Hoc est simplex vinculum characterum sive literalium.
Nunc tibi ostendo numerum quinque. Ecce hic est: 5
Videamus quid efficiatur si facimus 10/5. Eventus est: 2
Via typica ad numerum Pi approximandum est faciendo 22/7. Eventus est: 3
In C++ non idem est scribere 22/7 quam 22.0/7, tractatio diversa est.
Hoc simplici mutamento videre possumus quod 22.0/7 est aequale 3.14286
Nonne hoc tibi melior approximatio videtur?

Ad melius intellegendum rationem declarare – invocare – definire, intendamus in tribus partibus praecipuis codicis:

1. Linea 5: Declaratio functionis
   • void consoladice(); indicat compilatori quod aliquo loco in codice exstabit functio nomine consoladice().
   • Specificatur eius genus reditus esse void, quod significat nullum valorem reddituram esse.
   • Quamquam adhuc non cognoscitur implementatio consoladice(), haec declaratio permittit compilatori eam agnoscere cum postea adhibeatur.
2. Linea 9: Invocatio functionis
   • Intra functionem main(), linea consoladice(); functionem exsequitur.
   • Hoc momento, compilator iam agnoscit existentiam consoladice() gratias eius declarationi praeviæ.
   • Cum functio invocatur, imperium programmatis transfertur ad eius definitionem, ubi contentum exsequitur.
3. Lineae 14 ad 22: Definitio functionis
   • Hic invenitur implementatio accurata consoladice(), instructiones eius specificans.
   • Hoc in casu functio plura nuntia in consolio imprimit, inter numeros et operationes mathematicas.
   • Res magni momenti est differentia inter 22/7 et 22.0/7. Cum 22/7 adhibetur, ambo numeri sunt integri, quod efficit 3 propter divisionem integram. Attamen, cum scribitur 22.0/7, cogitur operatio in numero fluitante fieri, obtinens 3.14286.

Ratio: Declarare et Implementare antequam Invoces

In C++, praeter rationem declarare – invocare – definire, alia quoque via valida exstat ad functiones nostras ordinandas: declarare et implementare antequam invoces. Hic modus declarationem et definitionem in unum gradum coniungit, antequam functio in main() adhibeatur.

Hoc in consilio, pro declaratione praeviâ functionis et eius definitione post main(), eam directe declaramos atque definimus eodem loco antequam invocetur. Hoc commodum habet declarationem separatam vitandi et codicem reddendi compendiorem ac faciliorem ad legendum in parvis programmatibus.

Structura generalis huius consilii talis est:

// Functionem ante main() definimus
tipo_de_retorno nombre_de_funcion(lista_de_parametros) {
    // Corpus functionis
    return valor; // si necesse est
}
int main() {
    // Invocatio functionis
    nombre_de_funcion(argumentos);
}

Quia ante main() definita est, compilator eam iam novit cum invocatur, ideo declaratio praeviâ necessaria non est.

Exemplum: Functio consoladice() sine declaratione praeviâ

Nunc videamus exemplum practicum ubi hoc consilium adhibemus:

#include <iostream>
using namespace std;
// Functionem antequam invocetur definimus
void consoladice() {
    cout << "Hoc est simplex vinculum characterum sive literalium." << endl;
    cout << "Nunc tibi ostendo numerum quinque. Ecce hic est: " << 5 << endl;
    cout << "Videamus quid efficiatur si facimus 10/5. Eventus est: " << 10/5 << endl;
    cout << "Via typica ad numerum Pi approximandum est faciendo 22/7. Eventus est: " << 22/7 << endl;
    cout << "In C++ non idem est scribere 22/7 quam 22.0/7, tractatio diversa est." << endl;
    cout << "Hoc simplici mutamento videre possumus quod 22.0/7 est aequale " << 22.0/7 << endl;
    cout << "Nonne hoc tibi melior approximatio videtur?" << endl;
}
int main() {
    // Functionem invocamus
    consoladice();
    return 0;
}

In hoc codice videre possumus:

1. Inter lineas 5 et 13, declaratio et definitio coniunguntur

   Functio consoladice() directe ante main() definita est, sine necessitate declarationis separatae.

2. In linea 17, functio invocatur intra main()

   Quia functio iam antea definita est, compilator eam agnoscit et sine difficultate eius exsecutionem permittit.

3. Eventus omnino idem est

   Ad gradum functionis, hoc consilium idem effectum producit ac ratio declarare – invocare – definire, sed cum structura compendiore.

✅ Commoda:

• Codex directior et compendiosior in parvis programmatibus.
• Declaratio praeviâ non requiritur, quod numerum linearum codicis minuit.
• Faciliorem reddit lectionem in scriptis brevibus ubi omnes functiones in uno archivo continentur.

❌ Incommoda:

• In magnis programmatibus, ordinatio difficilior fieri potest si multae functiones ante main() definiuntur.
• Minus utile cum laboratur cum pluribus archivis (.h et .cpp), ubi praeferendum est declarationem in archivo separato servare.

Propagatio Valorís Rediti

Adhuc laboravimus cum functionibus quae simpliciter instructiones exsequuntur sine ullo effectu reddendo. Attamen, in multis casibus necesse est ut functio valorem reddat, ut in aliis computationibus adhibeatur aut in variabilibus reponatur. Hic processus vocatur propagatio valorís rediti.

In hac sectione discebimus quomodo functiones valores reddentes operantur, quomodo differant ab functionibus generis void, et quomodo hoc instrumentum in C++ adhiberi possit.

Exemplum Practicum: Functio quae aream rectanguli computat

Ad illustrandam propagationem valorís rediti, implebimus functionem quae basim et altitudinem rectanguli accipiat atque aream eius computet.

#include <iostream>
using namespace std;
// Functio quae aream rectanguli computat et eventum reddit
double calcularArea(double base, double altura) {
    return base * altura;
}
int main() {
    double base, altura;
    
    // Rogamus usorem ut valores inserat
    cout << "Ingredere basim rectanguli: ";
    cin >> base;
    cout << "Ingredere altitudinem rectanguli: ";
    cin >> altura;
    // Functionem vocamus et eius eventum reponimus
    double area = calcularArea(base, altura);
    // Eventum ostendimus
    cout << "Area rectanguli est: " << area << endl;
    
    return 0;
}

1. Functio calcularArea() valorem reddit
   • Duo valores (base et altura) ut parametros accipit.
   • Aream per multiplicationem base * altura computat.
   • return adhibet ut eventum operationis ad partem programmatis quae eam invocavit mittat.
2. Usus valoris rediti in main()
   • Valores base et altura ab usore inseruntur.
   • Functio calcularArea() vocatur, et eius eventus in variabili area reponitur.
   • Denique eventus in consolio ostenditur.
3. Differentia praecipua cum functione void

   Si calcularArea() generis void esset, necesse esset eventum directe intra functionem ostendere, pro eo quod ad main() reddatur ad usum posteriorem.

Exemplum: Functio quae determinat utrum numerus sit par vel impar

#include <iostream>
using namespace std;
bool esPar(int numero) {
    return numero % 2 == 0;
}
int main() {
    int numero;
    cout << "Ingredere numerum: "; cin >> numero;
    if (esPar(numero)) {
        cout << "Numerus est par." << endl;
    } else {
        cout << "Numerus est impar." << endl;
    }
    return 0;
}

Hic functio esPar() reddit true si numerus est par et false si impar est, permittens main() uti eventu ad decernendum quem nuntium ostendere debeat.

Recursio: Functiones quae se ipsas vocant

Recursio est ars qua functio se ipsam invocat ad problemata solvenda ea dividendo in versiones minores sui ipsius. Haec praecipue utilis est in algorithmis ut calculus factorialis, series Fibonacci et peragrationes in structuris datorum sicut arbores.

Exemplum: Factorialis Numeri

Factorialis numeri n est n!=n\cdot(n-1)\cdot(n-2) \cdots 3 \cdot2 \cdot 1. Haec formulatio structuram recursive habet quam mathematice repraesentare possumus hoc modo:

\begin{array}{rl} 0! &=1\\ n! &= n\cdot(n-1)!\\ \end{array}

His habitis, hanc functionem in C++ ita programmare possumus:

#include <iostream>
using namespace std;
 
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n*factorial(n - 1);
}
 
int main() {
    int numero;
    cout << "Ingredere numerum: "; cin >> numero;
    cout << "Factorialis " << numero << " est " << factorial(numero) << endl;
    return 0;
}

In hoc codice:

• Functio factorial(n) se ipsam vocat cum n-1 donec ad casum basalem perveniat (n == 0 vel n == 1).
• Functio recursivo modo solvitur, valores multiplicans donec eventus inveniatur.

Exemplum: Numeri Fibonacci

Numeri Fibonacci sunt illi qui comprehenduntur in serie 1, 1, 2, 3, 5, 8, 13, \cdots. Haec series eo distinguitur quod unusquisque numerus aequalis est summae duorum praecedentium.

Mathematice, si fibo(n) est functio cuius eventus numeri Fibonacci sunt, tunc talem structuram mathematicam habet

\begin{array}{rl} fibo(0) &= 1\\ fibo(1) &= 1 \\ fibo(n) &= fibo(n-1) + fibo(n-2) \end{array}

Exemplum codicis in C++ quod numeros Fibonacci ostendit tale est:

#include<iostream>
 
using namespace std;
 
int fibo(int numero){
    if (numero==0||numero==1){
        return 1;
        }
    return fibo(numero-1)+fibo(numero-2);
    }
 
int main(){
    int x=0, i=0;
    cout << "Ingredere numerum: "; cin >> x;
     
    while (i < x){
        cout <<"Numerus Fibonacci in positione " << i+1 << " est: " << fibo(i)<<endl;
        i=i+1;
    }   
}

Reditus Multiplex in Functionibus

In C++, functio plures valores reddere potest utens structuris sicut std::pair, std::tuple vel referentiis ad variabiles.

Exemplum: Functio quae duos valores cum std::pair reddit

#include <iostream>
#include <utility> // Ad utendum std::pair
using namespace std;
 
pair<int, int> dividir(int a, int b) {
    return make_pair(a / b, a % b);
}
 
int main() {
    int numerador=0, denominador=1;
     
    cout << "Ingredere numeratorem: "; cin >> numerador;
    cout << "Ingredere denominatorem: "; cin >> denominador;
     
    pair<int, int> resultado = dividir(numerador, denominador);
 
    cout << "Quotientia: " << resultado.first << endl;
    cout << "Reliquum: " << resultado.second << endl;
 
    return 0;
}

Hic functio dividir() duos valores reddit: quotientiam et residuum divisionis integralis.

Exemplum: Functio quae duos valores cum std::tuple reddit

#include <iostream>
#include <tuple>
using namespace std;
tuple<int, int, int> operaciones(int a, int b) {
    return make_tuple(a + b, a - b, a * b);
}
int main() {
    int suma=0, resta=0, producto=0;
    int a=0, b=0;
    
    cout << "Ingredere numerum: "; cin >> a;
    
    cout << "Ingredere alium numerum: "; cin >> b;
    
    std::tie(suma, resta, producto) = operaciones(a, b);
    cout << "Additio: " << suma << ", Subtractio: " << resta << ", Productum: " << producto << endl;
    return 0;
}

Onus functionum (overloading)

Onus functionum permittit definire plures functiones eodem nomine sed diversis generibus vel quantitatibus parameterum. Hoc legibilitatem et iterationem codicis meliorat.

#include <iostream>
#include <string> // Necessarium ad utendum std::string
#include <cmath>
using namespace std;
// Area quadrati vel circuli (figurae cum uno dato)
double area(double lado) {
    return lado * lado;
}
// Area rectanguli (vel figurarum cum duobus datis)
double area(double base, double altura) {
    return base * altura;
}
// Area trianguli (vel figurarum cum tribus datis)
double area(double a, double b, double c){
	return 0.25*sqrt((a+b+c)*(a+b-c)*(a-b+c)*(-a+b+c));
}
int main() {
    string figura;
    double resultado = 0;
    double l1=0, l2=0, l3=0;
    // Rogare figuram
    cout << "Quae figura est? (quadratum, circulus, rectangulum vel triangulum): ";
    cin >> figura;
    // Figuram per if-else aestimare
    if (figura == "cuadrado") {
        cout << "Quantum latus metitur? "; cin >> l1;
        resultado = area(l1);
        cout << "Area quadrati est: " << resultado << endl;
    } 
    else if (figura == "rectangulo"){
        cout << "Quantum basis metitur? "; cin >> l1;
        cout << "Quantum altitudo metitur? ";cin >> l2;
        resultado = area(l1, l2);
        cout << "Area rectanguli est: " << resultado << endl;
    } 
    else if (figura == "circulo") {
		l1 = 3.141592653;
        cout << "Quantum radius metitur? "; cin >> l2;
        resultado = area(l1, l2);
        cout << "Area circuli est: " << resultado << endl;
    } 
    else if (figura == "triangulo"){
    	cout << "Quantum latera eius metiuntur?" << endl;
    	cout << "latus 1: "; cin >> l1;
		cout << "latus 2: "; cin >> l2;
		cout << "latus 3: "; cin >> l3;
			
		if ((l1+l2+l3)*(l1+l2-l3)*(l1-l2+l3)*(-l1+l2+l3)<0){
			cout << "triangulum impossibile est";
		}	
		else {
			resultado = area(l1,l2,l3);
			cout << "Area trianguli est: " << resultado << endl;
		} 			
	}
    else {
        cout << "Figura non valida." << endl;
    }
    return 0;
}

Functiones inline in C++

Functiones inline in C++ praebent rationem ad emendandam celeritatem programmatis minuendo onus vocationum functionis. Pro vocatione conventionali exsequenda, compilator conatur codicem functionis directe expandere in unoquoque loco ubi invocatur.

Syntaxis functionis inline

inline tipo_de_retorno nombre_de_funcion(lista_de_parametros) {
    // Corpus functionis
    return valor; // Si necesse est
}

Utendo inline, tollimus necessitatem ad aliam memoriam regionem saliendi ut functionem exsequamur, quod potest minuere tempus exsecutionis.

Differentiae inter functionem inline et functionem communem

Exemplum functionis inline

#include <iostream>
using namespace std;
inline int cuadrado(int x) {
    return x * x;
}
int main() {
    cout << "Quadratum 5 est: " << cuadrado(5) << endl;
    return 0;
}

🔍 Processus compilatoris:

1. Compilator vocem cuadrado(5) directe substituit cum 5 * 5.
2. Nullus est saltus exsecutionis.
3. Computatio fit in eadem linea ubi functio invocata est.

Commoda et incommoda inline

✅ Commoda

• Onus vocationum functionis tollit: Minuit tempus exsecutionis in functionibus brevibus et saepe vocatis.
• Optimizationem a compilatore facilitat: Potest augere celeritatem vitando usum registrarum CPU et pilae.
• Praestat ut codex functionis tempore compilationis praesto sit.

❌ Incommoda

• Magnitudinem binarii auget: Si functio inline multoties in magno programmate adhibetur, codex in unoquoque loco invocationis duplicabitur. Hoc fit cum adhibetur in functionibus longis aut saepius repetitis in codice.
• Non semper expansionem in linea praestat: Compilator petitionem inline neglegere potest si censet id non esse optimum.