II. fejezet - Moduláris programozás C++ nyelven

A C++ nyelvben a paramétereket - az átadásuk módja szerint - két csoportra oszthatjuk. Megkülönböztetünk érték szerint átadott, bemenő paramétereket és hivatkozással átadott (változó) paramétereket.

double eszam(int n) {
    double f = 1;
    double esor = 1;
    for (int i=2; i<=n; i++) {
        esor += 1.0 / f;
        f *= i;
    }
    return  esor;
}

int main(){
    long x =1000;
    cout << eszam(x)<< endl;
    cout << eszam(123) << endl;
    cout << eszam(x + 12.34) << endl;
    cout << eszam(&x) << endl;  // hiba
}

cout << eszam((int)&x) << endl;

void pcsere(double *p, double *q) {
    double c = *p;
    *p = *q;
    *q = c;
}
 
int main(){
    double a = 12, b =23;
    pcsere(&a, &b);
    cout << a << ", " << b<< endl; // 23, 12
}

void rcsere(double & a,  double & b) {
    double c = a;
    a = b;
    b = c;
}
 
int main(){
    double x = 12, y =23;
    rcsere(x, y);
    cout << x << ", " << y << endl; // 23, 12
}

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
 
struct svektor {
    int meret;
    int a[1000];
};
 
void MinMax(const svektor & sv, int & mi, int & ma) {
mi = ma = sv.a[0];
for (int i=1; i<sv.meret; i++) {
        if (sv.a[i]>ma)
            ma = sv.a[i];
        if (sv.a[i]<mi)
            mi = sv.a[i];
}
}
 
int main() {
    const int maxn = 1000;
    srand(unsigned(time(0)));
    svektor v;
    v.meret=maxn;
    for (int i=0; i<maxn; i++) {
        v.a[i]=rand() % 102 + (rand() % 2012);
    }
    int min, max;
    MinMax(v, min, max);
    cout << min << endl;
    cout << max << endl;
}

int Lnko(const int & a, const int & b ) {
    int min = a<b ? a : b, lnko = 0;  
    for (int n=min; n>0; n--)
        if ( (a % n == 0) && (b % n) == 0) {
            lnko = n;
            break;
        }
    return lnko;
}
 
int main() {
    cout << Lnko(24, 32) <<endl; // 8
}

A következő alfejezetekben különböző típusok esetén, példák segítségével mélyítjük el a paraméterek használatával kapcsolatos ismereteket. Az alfejezet példáiban a függvények definícióját - kipontozott sor után - követi a hívás bemutatása. Természetesen bonyolultabb esetekben teljes programlistát is közlünk.

void KiirF(double adat, int mezo, int pontossag) {
    cout.width(mezo);
    cout.precision(pontossag);
    cout << fixed << adat << endl;
}
...
KiirF(123.456789, 10, 4);  //  123.4568

long Szorzat(int a, int b) {
   return long(a) * b;
}
...
cout << Szorzat(12, 23) <<endl; // 276

void Kocka(double a, double & felszin, double & terfogat, 
           double & atlo) {
    felszin = 6 * a * a;
    terfogat = a * a * a;
    atlo = a * sqrt(3.0);
}
...
double f, v, d;
Kocka(10, f, v, d);

struct komplex {
           double re, im;
       };

void KOsszeg1(const komplex*pa,const komplex*pb,komplex *pc){
  pc->re = pa->re + pb->re;
  pc->im = pa->im + pb->im;
}

komplex KOsszeg2(komplex a, komplex b) {
  komplex c;
  c.re = a.re + b.re;
  c.im = a.im + b.im;
  return c;
}

komplex KOsszeg3(const komplex & a, const komplex & b) {
  komplex c;
  c.re = a.re + b.re;
  c.im = a.im + b.im;
  return c;
}

int main() {
    komplex c1 = {10, 2}, c2 = {7, 12}, c3;
    
    KOsszeg1(&c1, &c2, &c3); // mindhárom argumentum pointer
    
    c3 = KOsszeg2(c1, c2);   // két struktúra az argumentum
    
    // két struktúra referencia az argumentum
    c3 = KOsszeg3(c1, c2);   
}

long VektorOsszeg1 (const int vektor[], int n) {
  long osszeg = 0;
  for (int i = 0; i < n; i++) {
     osszeg+=vektor[i];   // vagy osszeg+=*(vektor+i);
  }
  return osszeg;
}
...
int v[7] = { 10, 2, 11, 30, 12, 7, 23};
cout <<VektorOsszeg1(v, 7)<< endl;  // 95
cout <<VektorOsszeg1(v, 3)<< endl;  // 23

long VektorOsszeg2 (const int * const vektor, int n) {
  long osszeg = 0;
  for (int i = 0; i < n; i++) {
     osszeg+=vektor[i];   // vagy osszeg+=*(vektor+i);
  }
  return osszeg;
}

void Rendez(double v[], int n) {
    double temp;
    for (int i = 0; i < n-1; i++) 
        for (int j=i+1; j<n; j++)
            if (v[i]>v[j]) {
                temp = v[i];
                v[i] = v[j];
                v[j] = temp;
            }
}
 
int main() {
    const int meret=7;
    double v[meret]={10.2, 2.10, 11, 30, 12.23, 7.29, 23.};
    Rendez(v, meret);
    for (int i = 0; i < meret; i++) 
        cout << v[i]<< '\t';
    cout << endl;
}

long VektorOsszeg3 (const int (&vektor)[6]) {
  long osszeg = 0;
  for (int i = 0; i < 6; i++) {
     osszeg+=vektor[i];   // vagy osszeg+=*(vektor+i);
  }
  return osszeg;
}
...
int v[6] = { 10, 2, 11, 30, 12, 7};
cout << VektorOsszeg3(v) << endl;

int m[2][3];

void PrintMatrix23(const int matrix[2][3]) {
  for (int i=0; i<2; i++) {
     for (int j=0; j<3; j++)
       cout <<matrix[i][j] <<'\t';
     cout<<endl;
  }
}
...
int m[2][3] = { {10, 2, 12}, {23, 7, 29} };
PrintMatrix23(m);

10      2       12
23      7       29

void PrintMatrixN3(const int matrix[][3], int n) {
  for (int i=0; i<n; i++) {
     for (int j=0; j<3; j++)
       cout <<matrix[i][j] <<'\t';
     cout<<endl;
  }
}
...
int m[2][3] = { {10, 2, 12}, {23, 7, 29} };
PrintMatrixN3(m, 2);
cout << endl;
int m2[3][3] = { {1}, {0, 1}, {0, 0, 1} };
PrintMatrixN3(m2, 3);

10      2       12
23      7       29

1       0       0
0       1       0
0       0       1

void PrintMatrixNM(const void *pm, int n, int m) {
  for (int i=0; i<n; i++) {
     for (int j=0; j<m; j++)
        cout <<*((int *)pm+i*m+j) <<'\t';
     cout<<endl;
  }
}
...
int m[2][3] = { {10, 2, 12}, {23, 7, 29} };
PrintMatrixNM(m, 2, 3);
cout << endl;
int m2[4][4] = { {0,0,0,1}, {0,0,1}, {0,1}, {1} };
PrintMatrixNM(m2, 4, 4);

10     2      12
23     7      29
 
0      0      0      1
0      0      1      0
0      1      0      0
1      0      0      0

unsigned SzamolChC1(const char s[], char ch) {    
    unsigned db = 0;
    for (int i=0; s[i]; i++) {
        if (s[i] == ch) 
            db++;
    }
    return db;
}

unsigned SzamolChC2(const char *s, char ch) {    
    unsigned db = 0;
    while (*s) {
        if (*s++ == ch) 
            db++;
    }
    return db;
}

unsigned SzamolChCpp(const string & s, char ch) {    
    int db = -1, pozicio = -1;
    do {
        db++;
        pozicio = s.find(ch, pozicio+1);
    } while (pozicio != string::npos); 
    return db;
}

char s1[] = "C, C++, Java, C++/CLI / C#";
string s2 = s1;
cout<<SzamolChC1("C, C++, Java, C++/CLI / C#", 'C')<<endl;
cout<<SzamolChC2(s1, 'C')<<endl;

cout << SzamolChC2(s2.c_str(), 'C') << endl;
cout << SzamolChCpp(s2, 'C') << endl;

char * StrForditC1(char s[]) {
    char ch;
    int hossz = -1; 
    while(s[++hossz]); // a sztring hosszának meghatározása
    for (int i = 0; i < hossz / 2; i++) {
        ch = s[i];
        s[i] = s[hossz-i-1];
        s[hossz-i-1] = ch;
    }
    return s;
}
 
char * StrForditC2(char *s) {
    char *q, *p, ch;
    p = q = s; 
    while (*q) q++;     // lépkedés a sztringet záró 0 bájtra
    p--;            // p sztring első karaktere elé mutat
    while (++p <= --q) {
        ch = *p;
        *p = *q;
        *q = ch;    
    }
    return s;
}
 
string& StrForditCpp(string &s) {
    char ch;
    int hossz = s.size();
    for (int i = 0; i < hossz / 2; i++) {
        ch = s[i];
        s[i] = s[hossz-i-1];
        s[hossz-i-1] = ch;
    }
    return s;
}

int main() {
    char s1[] = "C++ programozas";
    cout << StrForditC1(s1) << endl;     // sazomargorp ++C
    cout << StrForditC2(s1) << endl;     // C++ programozas
    string s2 = s1;
    cout << StrForditCpp(s2) << endl;     // sazomargorp ++C
    cout << StrForditCpp(string(s1));    // sazomargorp ++C
}

II.1.3.2.5. A függvény, mint argumentum

Matematikai alkalmazások készítése során jogos az igény, hogy egy jól megvalósított algoritmust különböző függvények esetén tudjunk használni. Ehhez a függvényt argumentumként kell átadni az algoritmust megvalósító függvénynek.

II.1.3.2.5.1. A függvénytípus és a typedef

A typedef segítségével a függvény típusát egyetlen szinonim névvel jelölhetjük. A függvénytípus deklarálja azt a függvényt, amely az adott számú és típusú paraméterkészlettel rendelkezik, és a megadott adattípussal tér vissza. Tekintsük például a harmadfokú polinom helyettesítési értékeit számító függvényt, melynek prototípusa és definíciója:

double poli3(double);    // prototípus 
 
double poli3(double x)    // definíció
{
    return x*x*x - 6*x*x - x + 30;
}

II.3. ábra - A harmadfokú polinom grafikonja

Vegyük a függvény prototípusát, tegyük elé a typedef kulcsszót, végül cseréljük le a poli3 nevet mathfv-re!

        typedef double matfv(double);

A mathfv típus felhasználásával a poli3() függvény prototípusa:

        matfv poli3;

II.1.3.2.5.2. Függvényre mutató pointerek

A C++ nyelvben a függvényneveket kétféle módon használhatjuk. A függvénynevet a függvényhívás operátor bal oldali operandusaként megadva, függvényhívás kifejezést kapunk

        poli3(12.3)

melynek értéke a függvény által visszaadott érték. Ha azonban a függvénynevet önállóan használjuk

        poli3

akkor egy mutatóhoz jutunk, melynek értéke az a memóriacím, ahol a függvény kódja elhelyezkedik (kódpointer), típusa pedig a függvény típusa.

Definiáljunk egy olyan mutatót, amellyel a poli3() függvényre mutathatunk, vagyis értékként felveheti a poli3() függvény címét! A definíciót egyszerűen megkapjuk, ha a poli3 függvény fejsorában szereplő nevet a (*fvptr) kifejezésre cseréljük:

        double (*fvptr)(double);

Az fvptr olyan pointer, amely double visszatérési értékkel és egy double típusú paraméterrel rendelkező függvényre mutathat.

A definíció azonban sokkal olvashatóbb formában is megadható, ha használjuk a typedef segítségével előállított matfv típust:

        matfv *fvptr;

Az fvptr mutató inicializálása után a poli3 függvényt indirekt módon hívhatjuk:

        fvptr = poli3;

        double y = (*fvptr)(12.3);    vagy    doubley = fvptr(12.3);

Hasonló módon kell eljárnunk, ha a függvényhez referenciát akarunk készíteni. Ebben az esetben a kezdőértéket már a definíció során meg kell adni:

        double (&fvref)(double) = poli3;

vagy

        matfv &fvref = poli3;

A függvényhívás a referencia felhasználásával:

        double y = fvref(12.3);

II.1.3.2.5.3. Függvényre mutató pointer példák

A fentiek alapján érthetővé válik a qsort () könyvtári függvény prototípusa:

void qsort(void *base, size_t nelem, size_t width,
           int (*fcmp)(const void *, const void *));

A qsort () segítségével tömbben tárolt adatokat rendezhetünk a gyorsrendezés algoritmusának felhasználásával. A függvénnyel a base címen kezdődő, nelem elemszámú, elemenként width bájtot foglaló tömböt rendezhetünk. A rendezés során hívott összehasonlító függvényt magunknak kell megadni az fcmp paraméterben.

Az alábbi példában a qsort () függvényt egy egész, illetve egy sztringtömb rendezésére használjuk:

#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;
 
int icmp(const void *p, const void *q) {
 return *(int *)p-*(int *)q;
}
 
int scmp(const void *p, const void *q) {
 return strcmp((char *)p,(char *)q);
}
 
void main() {
    int m[8]={2, 10, 7, 12, 23, 29, 11, 30};
    char nevek[6][20]={"Dennis Ritchie", "Bjarne Stroustrup",
                       "Anders Hejlsberg","Patrick Naughton",
                       "James Gosling", "Mike Sheridan"};
 
    qsort(m, 8, sizeof(int), icmp);
    for (int i=0; i<8; i++)
      cout<<m[i]<<endl;
 
    qsort(nevek, 6, 20, scmp);
    for (int i=0; i<6; i++)
      cout<<nevek[i]<<endl;
}

A következő példaprogramokban szereplő tabellaz() függvény tetszőleges double típusú paraméterrel és double visszatérési értékkel rendelkező függvény értékeinek táblázatos megjelenítésére alkalmas. A tabellaz() függvény paraméterei között szerepel még az intervallum két határa és a lépésköz.

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
 
// Prototípusok
void tabellaz(double (*)(double), double, double, double);
double sqr(double); 
 
int main() {
    cout<<"\n\nAz sqr() fuggveny ertekei ([-2,2] dx=0.5)"<<endl;
    tabellaz(sqr, -2, 2, 0.5);
    cout<<"\n\nAz sqrt() fuggveny ertekei ([0,2] dx=0.2)"<<endl;
    tabellaz(sqrt, 0, 2, 0.2);
}
// A tabellaz() függvény definíciója
void tabellaz(double (*fp)(double), double a, double b,
              double lepes){
    for (double x=a; x<=b; x+=lepes) {
        cout.precision(4);
        cout<<setw(12)<<fixed<<x<< '\t';
        cout.precision(7);
        cout<<setw(12)<<fixed<<(*fp)(x)<< endl;
    }
}
// Az sqr() függvény definíciója
double sqr(double x) {
    return x * x;
}

A program futásának eredménye:

Az sqr() fuggveny ertekei ([-2,2] dx=0.5) -2.0000 4.0000000 -1.5000 2.2500000 -1.0000 1.0000000 -0.5000 0.2500000 0.0000 0.0000000 0.5000 0.2500000 1.0000 1.0000000 1.5000 2.2500000 2.0000 4.0000000 Az sqrt() fuggveny ertekei ([0,2] dx=0.2) 0.0000 0.0000000 0.2000 0.4472136 0.4000 0.6324555 0.6000 0.7745967 0.8000 0.8944272 1.0000 1.0000000 1.2000 1.0954451 1.4000 1.1832160 1.6000 1.2649111 1.8000 1.3416408 2.0000 1.4142136

// prototípus
long SorOsszeg(int n = 10, int d = 1, int a0 = 1); 
 
long SorOsszeg(int n, int d, int a0) {  // definíció 
    long osszeg = 0, ai;
    for(int i = 0; i < n; i++) {
        ai = a0 + d * i;
        cout << setw(5) << ai;
        osszeg += ai;
    }
    return osszeg;
}

int printf(const char * formatum, ... );

char nev[] = "Bjarne Stroustrup";
double a=12.3, b=23.4, c=a+b;
printf("C++ nyelv\n");
printf("Nev: %s \n", nev);
printf("Eredmeny: %5.3f + %5.3f = %8.4f\n", a, b, c);

#include<iostream>
#include<cstdarg>
using namespace std;
 
double Atlag(int darab, ... ) {
    va_list szamok; 
    // az első (darab) argumentum átlépése
    va_start(szamok, darab); 
    double osszeg = 0;
    for(int i = 0; i < darab; ++i ) {
        // double argumentumok elérése
        osszeg += va_arg(szamok, double);  
    }
    va_end(szamok);
    return (osszeg/darab);
}
 
int main() {
    double avg = Atlag(7,1.2,2.3,3.4,4.5,5.6,6.7,7.8);
    cout << avg << endl;
}

II.1.3.2.8. A main() függvény paraméterei és visszatérési értéke

A main () függvény különlegességét nemcsak az adja, hogy a program végrehajtása azzal kezdődik, hanem az is, hogy többféle paraméterezéssel rendelkezik:

int main( )
 
int main( int argc) ( )
 
int main( int argc, char *argv[]) ( )

Az argv egy karakter mutatókat tartalmazó tömbre (vektorra) mutat, az argc pedig a tömbben található sztringek számát adja meg. (Az argc értéke legalább 1, mivel az argv[0] mindig a program nevét tartalmazó karaktersorozatra hivatkozik.)

II.4. ábra - Az argv paraméter értelmezése

A main () visszatérési értékét, amely a szabvány ajánlása alapján int típusú, a main () függvényen belüli return utasításban, vagy a program tetszőleges pontján elhelyezett exit () könyvtári függvény argumentumaként adhatjuk meg. Az cstdlib fejállomány szabványos konstansokat is tartalmaz,

#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1

amelyeket kilépési kódként használva jelezhetjük a program sikeres, illetve sikertelen végrehajtását.

A main () sok mindenben különbözik a normál C++ függvényektől: nem deklarálhatjuk static vagy inline függvényként, nem kötelező benne a return használata, és nem lehet túlterhelni. A szabvány ajánlása alapján, a programon belülről nem hívható, és nem kérdezhető le a címe sem.

Az alábbi parancs1.cpp program kiírja a parancssor argumentumok számát, és megjeleníti az argumentumokat:

#include <iostream> 
using namespace std;
 
int main(int argc, char *argv[]) { 
    cout << "az argumentumok szama: " << argc << endl;   
    for (int narg=0; narg < argc; narg++)   
        cout << narg << " " << argv[narg] << endl; 
    return 0; 
}

A parancssor argumentumokat a konzol ablakban

C:\C++Konyv>parancs1 elso 2. harmadik

és a Visual Studio fejlesztői környezetben (II.5. ábra) egyaránt megadhatjuk.

II.5. ábra - Parancssor argumentumok megadása

A parancs1.exe program futtatásának eredményei:

Konzol ablakban	Fejlesztői környezetben
C:\C++Konyv>parancs1 elso 2. harmadik az argumentumok szama: 4 0 parancs1 1 elso 2 2. 3 harmadik C:\C++Konyv>	C:\C++Konyv>parancs1 elso 2. harmadik az argumentumok szama: 4 0 C:\C++Konyv\parancs1.exe 1 elso 2 2. 3 harmadik C:\C++Konyv>

A következő példaprogram (parancs2.cpp) a segédprogramok írásánál jól felhasználható megoldást mutat be, az indítási argumentumok helyes megadásának tesztelésére. A program csak akkor indul el, ha pontosan két argumentummal indítjuk. Ellenkező esetben hibajelzést ad, és kiírja az indítási parancssor formáját bemutató üzenetet.

#include <iostream>
#include <cstdlib>
using namespace std;
 
int main(int argc, char *argv[]) {
    if (argc !=3 ) {
        cerr<<"Hibas parameterezes!"<<endl;
        cerr<<"A program inditasa: parancs2 arg1 arg2"<<endl;
        return EXIT_FAILURE;
    }
    cout<<"Helyes parameterezes:"<<endl;
    cout<<"1. argumentum: "<<argv[1]<<endl;
    cout<<"2. argumentum: "<<argv[2]<<endl;
    return EXIT_SUCCESS;
}

A parancs2.exe program futtatásának eredményei:

Hibás indítás: parancs2	Helyes indítás: parancs2 alfa beta
Hibas parameterezes! A program inditasa: parancs2 arg1 arg2	Helyes parameterezes: 1. argumentum: alfa 2. argumentum: beta

A fenti probléma megoldását logikailag jól elkülöníthető részekre tagolhatjuk, nevezetesen:

A felsorol tevékenységek közül az első négyet önálló függvények formájában valósítjuk meg, amelyek közös elérésű (globális) változókon keresztül kommunikálnak egymással és a main() függvénnyel. A globális változókat a függvényeken kívül, a függvények definíciója előtt kell megadnunk. (Ne feledkezzünk meg a prototípusok megadásáról sem!)

#include <iostream>
#include <cmath>
using namespace std;
 
// globális változók
double a, b, c;
 
// prototípusok
void AdatBeolvasas();
bool HaromszogEgyenlotlenseg();
double Kerulet();
double Terulet();
 
int main() {
    AdatBeolvasas();
    cout << "kerulet: " << Kerulet()<<endl;
    cout << "terulet: " << Terulet()<<endl;
}
 
void AdatBeolvasas() {
    do {
        cout <<"a oldal: "; cin>>a;
        cout <<"b oldal: "; cin>>b;
        cout <<"c oldal: "; cin>>c;
    } while(!HaromszogEgyenlotlenseg() );
}
 
bool HaromszogEgyenlotlenseg() {
    if ((a<b+c) && (b<a+c) && (c<a+b))
        return true;
    else
        return false;
}
 
double Kerulet() {
    return a + b + c;
}
 
double Terulet() {
    double s = Kerulet()/2;
    return sqrt(s*(s-a)*(s-b)*(s-c));
}

A program jobb olvashatósága nem tagadható, azonban a széles körben való használhatósága akadályokba ütközik. Például, ha több háromszög adatait szeretnénk eltárolni, majd pedig a számításokban felhasználni, ügyelnünk kell a globális a, b és c változók értékének megfelelő beállítására.

int main() {
    double a1, b1, c1, a2, b2, c2;
    AdatBeolvasas();
    a1 = a, b1 = b, c1 = c;
    AdatBeolvasas();
    a2 = a, b2 = b, c2 = c;
    a = a1, b = b1, c = c1;
    cout << "kerulet: " << Kerulet()<<endl;
    cout << "terulet: " << Terulet()<<endl;
    a = a2, b = b2, c = c2;
    cout << "kerulet: " << Kerulet()<<endl;
    cout << "terulet: " << Terulet()<<endl;
}

Ebből a szempontból jobb megoldáshoz jutunk, ha a háromszög oldalait paraméterként adjuk át az érintett függvényeknek.

Nem merülünk el a megoldás részletezésében, hiszen a szükséges ismereteket már az Olvasó elé tártuk az előző részekben.

#include <iostream>
#include <cmath>
using namespace std;
 
void AdatBeolvasas(double &a, double &b, double &c);
bool HaromszogEgyenlotlenseg(double a, double b, double c);
double Kerulet(double a, double b, double c);
double Terulet(double a, double b, double c);
 
int main() {
    double x, y, z;
    AdatBeolvasas(x , y , z);
    cout << "kerulet: " << Kerulet(x, y, z) <<endl;
    cout << "terulet: " << Terulet(x, y, z) <<endl;
}
 
void AdatBeolvasas(double &a, double &b, double &c) {
    do {
        cout <<"a oldal: "; cin>>a;
        cout <<"b oldal: "; cin>>b;
        cout <<"c oldal: "; cin>>c;
    } while(!HaromszogEgyenlotlenseg(a, b, c) );
}
 
bool HaromszogEgyenlotlenseg(double a, double b, double c) {
    if ((a<b+c) && (b<a+c) && (c<a+b))
        return true;
    else
        return false;
}
 
double Kerulet(double a, double b, double c) {
    return a + b + c;
}
 
double Terulet(double a, double b, double c) {
    double s = Kerulet(a, b, c)/2;
    return sqrt(s*(s-a)*(s-b)*(s-c));
}

Nézzük meg a main () függvényt, ha két háromszöget kívánunk kezelni!

int main() {
    double a1, b1, c1, a2, b2, c2;
    AdatBeolvasas(a1, b1, c1);
    AdatBeolvasas(a2, b2, c2);
    cout << "kerulet: " << Kerulet(a1, b1, c1)<<endl;
    cout << "terulet: " << Terulet(a1, b1, c1)<<endl;
    cout << "kerulet: " << Kerulet(a2, b2, c2)<<endl;
    cout << "terulet: " << Terulet(a2, b2, c2)<<endl;
}

Összehasonlításképpen elmondhatjuk, hogy a globális változókkal hatékonyabb (gyorsabb) program­kódot kapunk, hiszen elmarad az argumentumok hívás előtti verembe másolása. Láttuk a megoldás negatív következményeit is, melyek erősen korlátozzák a kód újrahasznosítását. Hogyan lehetne csökkenti a sok paraméterrel járó kényelmetlenségeket, és elkerülni a hosszú argumentumlistákat?

Az alábbi megoldás általánosan javasolt a globális változók használata helyett. A globális változókat, illetve a nekik megfelelő paramétereket struktúrába kell gyűjteni, melyet aztán referenciával, vagy konstans referenciával adunk át a függvényeknek.

#include <iostream>
#include <cmath>
using namespace std;
 
struct haromszog {
    double a, b, c;
};
 
void AdatBeolvasas(haromszog &h);
bool HaromszogEgyenlotlenseg(const haromszog &h);
double Kerulet(const haromszog &h);
double Terulet(const haromszog &h);
 
int main() {
    haromszog h1, h2;
    AdatBeolvasas(h1);
    AdatBeolvasas(h2);
    cout << "kerulet: " << Kerulet(h1)<<endl;
    cout << "terulet: " << Terulet(h1)<<endl;
    cout << "kerulet: " << Kerulet(h2)<<endl;
    cout << "terulet: " << Terulet(h2)<<endl;
}
 
void AdatBeolvasas(haromszog &h) {
    do {
        cout <<"a oldal: "; cin>>h.a;
        cout <<"b oldal: "; cin>>h.b;
        cout <<"c oldal: "; cin>>h.c;
    } while(!HaromszogEgyenlotlenseg(h) );
}
 
bool HaromszogEgyenlotlenseg(const haromszog &h) {
    if ((h.a<h.b+h.c) && (h.b<h.a+h.c) && (h.c<h.a+h.b))
        return true;
    else
        return false;
}
 
double Kerulet(const haromszog &h) {
    return h.a + h.b + h.c;
}
 
double Terulet(const haromszog &h) { 
    double s = Kerulet(h)/2;
    return sqrt(s*(s-h.a)*(s-h.b)*(s-h.c));
}

A szöveges felületű programjaink vezérlését egyszerű menü segítségével kényelmesebbé tehetjük. A megoldáshoz a menüpontokat egy sztring tömbben tároljuk:

// A menü definíciója
char * menu[] = {"\n1. Oldalak",
                 "2. Kerulet",
                 "3. Terulet",
                 "----------",
                 "0. Kilep" , NULL };

Az előző példa main () függvényében pedig kezeljük a menüválasztásokat:

int main() {
    haromszog h = {3,4,5};
    char ch;
    do {
      // a menü kiírása
      for (int i=0; menu[i]; i++)
          cout<<menu[i]<< endl;
    
      // A választás feldolgozása
      cin>>ch; cin.get();
      switch (ch) {
        case '0': break;
        case '1': AdatBeolvasas(h);
                  break;
        case '2': cout << "kerulet: " << Kerulet(h)<<endl;
                  break;
        case '3': cout << "terulet: " << Terulet(h)<<endl;
                  break;
        default:  cout<<'\a';
      }
    } while (ch != '0');
}

A program futásának ablaka

1. Oldalak
2. Kerulet
3. Terulet
----------
0. Kilep
1
a oldal: 3
b oldal: 4
c oldal: 5
 
1. Oldalak
2. Kerulet
3. Terulet
----------
0. Kilep
2
kerulet: 12
 
1. Oldalak
2. Kerulet
3. Terulet
----------
0. Kilep
3
terulet: 6

A matematikában lehetőség van bizonyos adatok és állapotok rekurzív módon történő előállítására. Ekkor az adatot vagy az állapotot úgy definiáljuk, hogy megadjuk a kezdőállapoto(ka)t, majd pedig egy általános állapotot az előző(, véges számú állapot) segítségével határozunk meg.

Tekintsünk néhány jól ismert rekurzív definíciót!

        faktoriális:

        Fibonacci-számok:

        legnagyobb közös osztó (lnko):

        binomiális számok:

Programozás szempontjából rekurzív algoritmusnak azt tekintjük, ami közvetlenül (közvetlen rekurzió) vagy más függvények közbeiktatásával (közvetett rekurzió) hívja önmagát. Klasszikus példaként tekintsük először a faktoriális számítását!

A faktoriális számítás fenti, rekurzív definíciója alapján 5! meghatározásának lépései az alábbi szemléletes formában ábrázolhatók:

5! = 5 * 4!
         4 * 3!
             3 * 2!
                 2 * 1! 
                     1 * 0!
                          1  = 5 * 4 * 3 * 2 * 1 * 1 = 120

A fenti számítási menetet megvalósító C++ függvény:

unsigned long long Faktorialis(int n) 
{
    if (n == 0)
       return 1;
     else
       return n * Faktorialis(n-1);
}

A rekurzív függvények általában elegáns megoldást adnak a problémákra, azonban nem elég hatékonyak. A kezdőállapot eléréséig a függvények hívási láncolata által lefoglalt memóriaterület (veremterület) elég jelentős méretű is lehet, és a függvényhívási mechanizmus is igen sok időt vehet igénybe.

Ezért fontos az a megállapítás, hogy minden rekurzív problémának létezik iteratív (ciklust használó) megoldása is, amely általában nehezebben programozható, azonban hatékonyabban működik. Ennek fényében a faktoriális számítást végző nem rekurzív függvény:

unsigned long long Faktorialis(int n)
{
    unsigned long long f=1;
    while (n != 0)
        f *= n--;
    return f;
}

A következőkben tekintsük a Fibonacci számsorozat n-edik elemének meghatározását! A

0, 1, 1, 2, 3, 5, 8, 13, 21, ...

sorozat n-edik elemének számítására az alábbi rekurziós szabály alkalmazható:

A rekurziós szabály alapján elkészített függvény szerkezete teljes mértékben követi a matematikai definíciót:

unsigned long Fibonacci( int n ) {
   if (n<2)
      return n;
   else
      return Fibonacci(n-1) + Fibonacci(n-2);
}

A számítási idő és a memóriaigény jelentős mértéke miatt itt is az iteratív megoldás használatát javasoljuk:

unsigned long Fibonacci( int n ) {
   unsigned long f0 = 0, f1 = 1, f2 = n;
   while (n-- > 1) {
      f2 = f0 + f1;
      f0 = f1;
      f1 = f2;
   }
   return f2;
}

Amíg az iteratív megoldás futásideje az n függvényében lineárisan nő, addig a rekurzív függvényhívás ideje hatványozottan növekszik ().

Fejezetünk befejező részében a felvetett feladatoknak csak a rekurzív megoldását közöljük, az iteratív megközelítés programozását az Olvasóra bízzuk.

Két természetes szám legnagyobb közös osztóját rekurzív módon igen egyszerűen meghatározhatjuk:

int Lnko(int p, int q) {
    if (q == 0)
        return p;
    else
        return Lnko(q, p % q);
}

A binomiális együtthatók számításhoz kétféle rekurzív függvény közül is választhatunk:

int Binom1(int n, int k)
{
    if (k == 0 || k == n)
        return 1;
    else
        return Binom1(n-1,k-1) + Binom1(n-1,k);
}
 
int Binom2(int n, int k)
{
    if (k==0)
        return 1;
    else
        return Binom2(n, k-1) * (n-k+1) / k;
}

A két megoldás közül a Binom2() a hatékonyabb.

Az utolsó példában determináns kiszámításához használjuk a rekurziót. A megoldás lényege, hogy az N-ed rendű determináns meghatározását N darab (N-1)-ed rendű determináns számítására vezetjük vissza. Tesszük ezt mindaddig, míg el nem jutunk a másodrendű determinánsokig. A megoldás szép és áttekinthető, azonban nem elég hatékony. A számítás során a hívások fastruktúrában láncolódnak, ami sok futásidőt és memóriát igényel.

Például, a 4x4-es determináns számításakor 17-szer (1 darab 4x4-es, 4 darab 3x3-as és 4·3 darab 2x2-es mátrixszal) hívódik meg a Determinans() függvény, a hívások száma azonban az 5-öd rendű esetben 5·17+1 = 86-ra emelkedik. (Megjegyezzük, hogy 12x12-es mátrix esetén a Determinans() függvény, több mint 300 milliószor hívódik meg, ami perceket is igénybe vehet.)

#include <iostream>
#include <iomanip>
using namespace std;
 
typedef double Matrix[12][12];
 
double Determinans(Matrix m, int n);
void MatrixKiir(Matrix m, int n);
 
int main() {
  Matrix m2 = {{1, 2},
               {2, 3}};
 
  Matrix m3 = {{1, 2, 3},
               {2, 1, 1},
               {1, 0, 1}};
 
  Matrix m4 = {{ 2, 0, 4, 3},
               {-1, 2, 6, 1},
               {10, 3, 4,-2},
               { 2, 1, 4, 0}};
 
  MatrixKiir(m2,2);
  cout << "Determinans(m2) = " << Determinans(m2,2) << endl;
 
  MatrixKiir(m3,3);
  cout << "Determinans(m3) = " << Determinans(m3,3) << endl; 
 
  MatrixKiir(m4,4);
  cout << "Determinans(m4) = " << Determinans(m4,4) << endl;
 
  cin.get();
  return 0;
}
void MatrixKiir(Matrix m, int n)
{
   for (int i=0; i<n; i++) {
       for (int j=0; j<n; j++) {
         cout << setw(6) << setprecision(0) << fixed;
         cout << m[i][j];
       }
       cout << endl;
   }
}
 
double Determinans(Matrix m, int n)
{
  int q;
  Matrix x;
 
  if (n==2)
    return m[0][0]*m[1][1]-m[1][0]*m[0][1];
 
  double s = 0;
  for (int k=0; k<n; k++)  // n darab aldetermináns
  {
        // az almátrixok létrehozása
        for (int i=1; i<n; i++)    // sorok
        {
           q = -1;
           for (int j=0; j<n; j++) // oszlopok
            if (j!=k)
              x[i-1][++q] = m[i][j];
        }
        s+=(k % 2 ? -1 : 1) * m[0][k] * Determinans(x, n-1);
  }
  return s;
}

A program futásának eredménye:

     1     2
     2     3
Determinans(m2) = -1

     1     2     3
     2     1     1
     1     0     1
Determinans(m3) = -4

     2     0     4     3
    -1     2     6     1
    10     3     4    -2
     2     1     4     0
Determinans(m4) = 144

A sablonok deklarációja a template kulcsszóval indul, mely után a < és > jelek között adjuk meg a sablon paramétereit. Ezek a paraméterek elsősorban általánosított típusnevek azonban változók is szerepelhetnek közöttük. Az általánosított típusnevek előtt a class vagy a typename kulcsszavakat kell használnunk.

A függvénysablon előállításakor egy működő függvényből érdemes kiindulni, amelyben a lecserélendő típusokat általános típusokkal (TIPUS) helyettesítjük. Ezek után közölnünk kell a fordítóval, hogy mely típusokat kell majd lecserélni a függvénymintában (template<class TIPUS>). Tekintsük például az első a lépést az Abszolut() függvényünk esetén

inline TIPUS Abszolut(TIPUS x) {
    return x < 0 ? -x : x;
}

majd pedig a végleges forma kétféleképpen megadva:

template <class TIPUS>
inline TIPUS Abszolut(TIPUS x) {
    return x < 0 ? -x : x;
}
 
template <typename TIPUS>
inline TIPUS Abszolut(TIPUS x) {
    return x < 0 ? -x : x;
}

Az elkészült függvénysablonból a fordító állítja elő a szükséges függvényváltozatot, amikor először találkozik egy hívással. Felhívjuk a figyelmet arra, hogy az Abszolut() sablon csak numerikus típusokkal használható, amelyek körében értelmezettek az kisebb és az előjelváltás műveletek.

A szokásos függvényhívás esetén a fordítóprogram az argumentum típusából dönti el, hogy az Abszolut() függvény mely változatát állítja elő, és fordítja le.

cout << Abszolut(123)<< endl;        // TIPUS = int
cout << Abszolut(123.45)<< endl;        // TIPUS = double

Típus-átalakítás segítségével az automatikus típusválasztás eredményéről magunk is gondoskodhatunk:

cout << Abszolut((float)123.45)<< endl;    // TIPUS = float
cout << Abszolut((int)123.45)<< endl;    // TIPUS = int

Ugyanerre az eredményre jutunk, ha a függvény neve után, a < és > jelek között megadjuk a típusnevet:

cout << Abszolut<float>(123.45)<< endl;    // TIPUS = float
cout << Abszolut<int>(123.45)<< endl;     // TIPUS = int

A függvénysablonban természetesen több, azonos típus helyettesítése is megoldható, mint ahogy azt a következő példában láthatjuk:

template <typename T>
inline T Maximum(T a, T b) {
   return (a>b ? a : b);
}
 
int main() {
    int a = 12, b=23;
    float c = 7.29, d = 10.2;
 
    cout<<Maximum(a, b); // Maximum(int, int)
    cout<<Maximum(c, d); // Maximum(float, float)
  ↯ cout<<Maximum(a, c); // nem található Maximum(int, float)
    cout<<Maximum<int>(a,c);  
    // a Maximum(int, int) függvény hívódik meg konverzióval
}

A különböző típusok alkalmazásához több általánosított típust kell a sablonfejben megadnunk:

template <typename T1, typename T2>
inline T1 Maximum(T1 a, T2 b) {
   return (a>b ? a : b);
}
 
int main() {
    cout<<Maximum(5,4);       // Maximum(int, int)
    cout<<Maximum(5.6,4);     // Maximum(double, int)
    cout<<Maximum('A',66L);   // Maximum(char, long)
    cout<<Maximum<float, double>(5.6,4); 
                              // Maximum(float, double)
    cout<<Maximum<int, char>('A',66L);   
                              // Maximum(int, char)
}

Amikor a C++ fordítóprogram először találkozik egy függvénysablon hívásával, az adott típussal/típusokkal elkészíti a függvény egy példányát. Minden függvénypéldány az adott függvénysablon, adott típusokkal specializált változata. A lefordított programkódban minden felhasznált típushoz pontosan egy függvénypéldány tartozik. A fenti hívásokban erre az ún. implicit példányosításra láttunk példát.

A függvénysablont explicit módon is példányosíthatjuk, amennyiben a függvény fejlécét magában foglaló template sorban konkrét típusokat adunk meg:

template inline int Abszolut<int>(int);
template inline float Abszolut(float);
template inline double Maximum(double, long);
template inline char Maximum<char, float>(char, float);

Fontos megjegyeznünk, hogy adott típus(ok)ra vonatkozó explicit példányosítás csak egyszer szerepelhet a programkódban.

Mivel a C++ fordító a függvénysablonokat fordítási időben dolgozza fel, a függvényváltozatok elkészítéséhez a sablonoknak forrásnyelven kell rendelkezésre állniuk. Ajánlott a függvénysablonokat a fejállományban elhelyezni, biztosítva azt, hogy a fejállományt csak egyszer lehessen beépíteni a C++ modulokba.

Vannak esetek, amikor az elkészített általános függvénysablonban definiált algoritmustól eltérő működésre van szükségünk bizonyos típusok vagy típuscsoportok esetén. Ebben az esetben magát a függvénysablont kell túlterhelnünk (specializálnunk) – explicit specializáció.

Az alábbi példában a Csere() függvénysablon a hivatkozással átadott argumentumok értékét felcseréli. Az első specializált változat a mutató argumentumok esetén nem a mutatókat, hanem a hivatkozott értékeket cseréli fel. A másik, tovább specializált változat kimondottan C-stílusú sztringek cseréjére használható.

#include <iostream>
#include <cstring>
using namespace std;
 
// Az alap sablon
template< typename T > void Csere(T& a, T& b) {
   T c(a);
   a = b;
   b = c;
}
 
// A mutatókra specializált sablon
template<typename T> void Csere(T* a, T* b) {
   T c(*a);
   *a = *b;
   *b = c;
}
 
// C-sztringekre specializált sablon
template<> void Csere(char *a, char *b) {
   char puffer[123];
   strcpy(puffer, a);
   strcpy(a, b);
   strcpy(b, puffer);
}
 
int main() {
    int a=12, b=23;
    Csere(a, b);
    cout << a << "," << b << endl;     // 23,12
 
    Csere(&a, &b);
    cout << a << "," << b << endl;        // 12,23
 
    char *px = new char[32]; strcpy(px, "Elso");
    char *py = new char[32]; strcpy(py, "Masodik");
    Csere(px, py);
    cout << px << ", " << py << endl;    // Masodik, Elso
    delete px;
    delete py;
}

Fordító a különböző specializált változatok közül mindig a leginkább specializált (konkrét) sablont alkalmazza először a függvényhívás fordításához.

A függvénysablonok összefoglalásaként nézzünk meg néhány összetettebb példát! Kezdjük a sort a II.2.2. szakasz VektorOsszeg() függvényének általánosításával! A sablon segítségével tetszőleges típusú, egydimenziós, numerikus tömb elemösszegét meg tudjuk határozni:

#include <iostream>
using namespace std;
 
template<class TIPUS>
TIPUS VektorOsszeg(TIPUS a[], int n) {
   TIPUS sum = 0;
   for (int i=0; i<n; i++)
      sum += a[i];
   return sum;
}
 
int main() {
   int       ai[]={1,1,2,3,5,8,13};
   const int ni=sizeof(ai) / sizeof(ai[0]);
   cout << "\nAz int    tomb elemosszege: "
        <<VektorOsszeg(ai,ni);
 
   double    ad[]={1.2,2.3,3.4,4.5,5.6};
   const int nd=sizeof(ad) / sizeof(ad[0]);
   cout << "\nA  double tomb elemosszege: "
        <<VektorOsszeg(ad,nd);
 
   float     af[]={3, 2, 4, 5};
   const int nf=sizeof(af) / sizeof(af[0]);
   cout << "\nA  float  tomb elemosszege: "
        <<VektorOsszeg(af,nf);
 
   long      al[]={1223, 19800729, 2004102};
   const int nl=sizeof(al) / sizeof(al[0]);
   cout << "\nA  long   tomb elemosszege: "
        <<VektorOsszeg(al,nl);
}

A Rendez() függvénysablon egy Tip típusú és Meret méretű egydimenziós tömb elemeit rendezi növekvő sorrendbe. A függvény a tömbön belül mozgatja az elemeket, és az eredmény is ugyanabban a tömbben áll elő. Mivel ebben az esetben a típus paraméter (Tip) mellett egy egész értéket fogadó paraméter (Meret) is helyet kapott a deklarációban, a hívás bővített formáját kell használnunk:

        Rendez<int, meret>(tomb);

A példaprogramban a Rendez() sablonból a Csere() sablont is hívjuk:

#include <iostream>
using namespace std;
 
template< typename T > void Csere(T& a, T& b) {
   T c(a);
   a = b;
   b = c;
}
 
template<class Tip, int Meret> void Rendez(Tip vektor[]) {
   int j;
   for(int i = 1; i < Meret; i++){
      j = i;
      while(0 < j && vektor[j] < vektor[j-1]){
          Csere<Tip>(vektor[j], vektor[j-1]);
          j--;
      }
   }
}
 
int main() {
    const int meret = 6;
    int tomb[meret] = {12, 29, 23, 2, 10, 7};
    Rendez<int, meret>(tomb);
    for (int i = 0; i < meret; i++)
        cout << tomb[i] << " ";
    cout << endl;
}

Az utolsó példánkban a Fuggveny() különböző változatainak hívásakor megjelenítjük a fordító által használt függvényváltozatokat. A specializált változatokból az általános sablont aktivizáljuk, amely a Kiir() sablon segítségével megjelenti a teljes hívás elemeit. A típusok nevét a typeid operátor által visszaadott objektum name () tagja adja vissza. A Karakter() függvénysablonnal a megjeleníthető karaktereket aposztrófok között másoljuk a kiírt szövegbe. Ez a kis példa betekintést enged a függvénysablonok használatának boszorkánykonyhájába.

#include <iostream>
#include <sstream>
#include <string>
#include <typeinfo>
#include <cctype>
using namespace std;
 
template <typename T> T Karakter(T a) { 
    return a; 
}
 
string Karakter(char c) {
    stringstream ss;
    if (isprint((unsigned char)c)) 
        ss << "'" << c << "'";
    else 
        ss << (int)c;
    return ss.str();
}
 
template <typename TA, typename TB> 
void Kiir(TA a, TB b){
    cout << "Fuggveny<" << typeid(TA).name() << "," 
         << typeid(TB).name();
    cout << ">(" << Karakter(a) << ", " << Karakter(b)
         << ")\n";
}
 
template <typename TA, typename TB> 
void Fuggveny(TA a = 0, TB b = 0){
    Kiir<TA, TB>(a,b);
}
 
template <typename TA> 
void Fuggveny(TA a = 0, double b = 0) {
    Fuggveny<TA, double>(a, b);
}
 
void Fuggveny(int a = 12, int b = 23) {
    Fuggveny<int, int>(a, b);
}
 
int main() {
        Fuggveny(1, 'c');
        Fuggveny(1.5); 
        Fuggveny<int>(); 
        Fuggveny<int, char>(); 
        Fuggveny('A', 'X');
        Fuggveny();
}

A program futásának eredménye:

Fuggveny<int,char>(1, 'c')
Fuggveny<double,double>(1.5, 0)
Fuggveny<int,double>(0, 0)
Fuggveny<int,char>(0, 0)
Fuggveny<char,char>('A', 'X')
Fuggveny<int,int>(12, 23)

A tárolási osztállyal szoros kapcsolatban álló fogalom a változók elérhetősége, hatóköre (scope). Minden azonosító csak a hatókörén belül látható. A hatókörök több fajtáját különböztetjük meg: blokk szintű (lokális), fájl szintű és program szintű (globális) (II.7. ábra).

A változók elérhetőségét alapértelmezés szerint a definíció programban elfoglalt helye határozza meg. Így csak blokk szintű és program szintű elérhetőséggel rendelkező változókat hozhatunk létre. A tárolási osztályok közvetlen megadásával árnyalhatjuk a képet.

A hatókör fogalma hasonló a kapcsolódás (linkage) fogalmához, azonban nem teljesen egyezik meg azzal. Azonos nevekkel különböző hatókörökben, különböző változókat jelölhetünk. Azonban a különböző hatókörben deklarált, illetve az azonos hatókörben egynél többször deklarált azonosítók a kapcsolódás felhasználásával ugyanarra a változóra hivatkozhatnak. A C++ nyelvben háromféle kapcsolódásról beszélhetünk: belső, külső, és amikor nincs kapcsolódás.

C++ programban a változók az alábbi hatókörök valamelyikével rendelkezhetnek:

A fájl és a program szintű hatóköröket a később ismertetett névterek (namespace) tovább bontják a minősített azonosítók bevezetésével.

II.7. ábra - A változók hatókörei

Az élettartam (lifetime) a program végrehajtásának azon időszaka, amelyben az adott változó létezik. Az élettartam szempontjából az azonosítókat három csoportra oszthatjuk: statikus, automatikus és dinamikus élettartamú nevek.

Azok a változók, amelyeket programblokkon/függvényblokkon belül, illetve a függvények paraméterlistájában definiálunk alapértelmezés szerint automatikus (auto) változók. Az auto kulcsszót általában nem használjuk, sőt a legújabb C++11 verzióban új értelmezéssel látták el a nyelv fejlesztői. A blokk szintű változókat gyakran lokális változóknak hívjuk.

{
   definíciók, deklarációk és
   utasítások
}

int main()
{
    double hatar = 123.729;
    // a double típusú hatar értéke 123.729 
    {
        long hatar = 41002L;
        // a long típusú hatar értéke 41002L 
    }
    // a double típusú hatar értéke 123.729
}

for (int i=12; i<23; i+=2)
   cout << i << endl;
↯ cout << i << endl; // fordítási hiba, nem definiált az i

void Csere(register int &a, register int &b) {
   register int c = a;
                a = b;
                b = c;
}

long StrToLong(const string& str)
{
    register int index = 0;
    register long elojel = 1, szam = 0;
    // a bevezető szóközök átlépése
    for(index=0; index < str.size() 
                 && isspace(str[index]); ++index);
    // előjel?
    if( index < str.size()) {
        if( str[index] == '+' ) { elojel =  1; ++index; }
        if( str[index] == '-' ) { elojel = -1; ++index; }
    }
    // számjegyek
    for(; index < str.size() && isdigit(str[index]); ++index)
        szam = szam * 10 + (str[index] - '0');
    return elojel * szam;
}

#include <iostream>
using namespace std;
 
unsigned Fibo() {
    static unsigned a0 = 0, a1 = 1;
    unsigned a2 = a0 + a1;
    a0 = a1;
    a1 = a2;
    return a2;
}
 
int main() {
    for (register int i=2; i<10; i++)
        cout << Fibo() << endl;
}

A függvényeken kívül definiált változók automatikusan külső, vagyis program szintű hatókörrel rendelkeznek. Amikor több modulból (forrásfájlból) álló programot fejlesztünk, a moduláris programozás elveinek megvalósításához nem elegendő, hogy vannak globális változóink. Szükségünk lehet olyan modul szinten definiált változókra is, amelyek elérését a forrásállományra korlátozhatjuk (adatrejtés). Ezt a static tárolási osztály külső változók előtti megadásával érhetjük el. A függvényeken kívüli konstans definíciók alapértelmezés szerint szintén belső kapcsolódásúak.

Az alábbi Fibonacci-számokat előállító programban az a0 és a1 változókat modulszinten definiáltuk annak érdekében, hogy egy másik függvénnyel (FiboInit()) is elérjük a tartalmukat.

#include <iostream>
using namespace std;
 
const unsigned elso = 0, masodik = 1;
static unsigned a0 = elso, a1 = masodik;
 
void FiboInit() {
    a0 = elso;
    a1 = masodik;
}
 
unsigned Fibo() {
    unsigned register a2 = a0 + a1;
    a0 = a1;
    a1 = a2;
    return a2;
}
 
int main() {
    for (register int i=2; i<5; i++)
        cout << Fibo() << endl;
    FiboInit();
    for (register int i=2; i<8; i++)
        cout << Fibo() << endl;
}

A statikus változók inicializálása a programba való belépés során egyszer megy végbe. Amennyiben nem adunk meg kezdőértéket a definícióban, úgy a fordító automatikusan 0-val inicializálja a változót (feltöltve annak területét nullás bájtokkal). C++-ban a statikus változók kezdőértékeként tetszőleges kifejezést használhatunk.

A C++ szabvány a statikus külső változók helyett a névtelen névterek használatát javasolja (lásd később).

A függvényeken kívül definiált változók, amelyeknél nem adunk meg tárolási osztályt, alapértelmezés szerint extern tárolási osztállyal rendelkeznek. (Természetesen az extern kulcsszó közvetlenül is megadható.)

Az extern (globális) változók élettartama a programba való belépéstől a program befejezésig terjed. Azonban a láthatósággal lehetnek problémák. Egy adott modulban definiált változó csak akkor érhető el egy másik modulból, ha abban szerepeltetjük a változó deklarációját (például deklarációs állomány beépítésével).

A program szintű globális változók használata esetén mindig tudnunk kell, hogy a változót definiáljuk , vagy deklaráljuk . Ha a függvényeken kívül tárolási osztály nélkül szerepeltetünk egy változót, akkor ez a változó definícióját jelenti (függetlenül attól, hogy adunk-e explicit kezdőértéket vagy sem). Ezzel szemben az extern explicit megadása kétféle eredményre vezethet: kezdőérték megadás nélkül a változót deklaráljuk , míg kezdőértékkel definiáljuk . Az elmondottakat jól szemléltetik az alábbi példák:

Felhívjuk a figyelmet arra, hogy a globális változók deklarációi a programon belül bárhova elhelyezhetők, azonban hatásuk a deklaráció helyétől az adott hatókör (blokk vagy modul) határáig terjed. Szokásos megoldás, hogy a deklarációkat modulonként fejállományokban tároljuk, és azt minden forrásfájl elején beépítjük a kódba.

A globális változók inicializálása a programba való belépés során egyszer megy végbe. Amennyiben nem adunk meg kezdőértéket, úgy a fordító automatikusan 0-val inicializálja a változót. C++-ban a globális változók kezdőértékeként tetszőleges kifejezést használhatunk.

Fontos megjegyeznünk, hogy a globális változókat csak indokolt esetben, átgondolt módon szabad használni. Egy nagyobb program esetén is csak néhány, központi extern változó alkalmazása a megengedett.

A C++ fordító a függvények általunk megadott nevét a tárgykódban kiegészíti a függvény paraméterlistáját leíró betűkkel. Ez a C++ kapcsolódásnak (linkage) hívott megoldás teszi lehetővé a fejezet korábbi részeiben bemutatott lehetőségeket (túlterhelés, függvénysablon).

A C++ nyelv születésekor a C nyelv már közel tízéves múltra tekintett vissza. Jogos volt az igény, hogy a C nyelvű programokhoz kifejlesztett, lefordított tárgymodulok és függvénykönyvtárak algoritmusait C++ programokból is elérjük. (A C forráskódú programok felhasználása - kisebb módosításokkal - megoldottnak volt tekinthető.) A C fordító a függvényneveket változtatás nélkül helyezi el a tárgykódban (C kapcsolódás), így azok az eddig megismert C++ deklarációkkal nem érhetők el.

A probléma leküzdésére a C++ nyelv tartalmazza az extern "C" típusmódosítót. Ha például a C nyelven megírt sqrt() függvényt szeretnénk használni a C++ programból, szükséges az

extern "C" double sqrt(double a);

deklaráció megadása. Ennek hatására a C++ fordító a szokásos C névképzést alkalmazza az sqrt() függvényre. Ebből persze az is következik, hogy a C függvényeket nem lehet átdefiniálni (túlterhelni)!

Amennyiben több C függvényt kívánunk elérni a C++ programból, akkor az extern "C" deklaráció csoportos formáját használhatjuk:

extern "C" {
   double sin(double a);
   double cos(double a);
}

Ha egy C-könyvtár függvényeinek leírását külön deklarációs állomány tartalmazza, akkor az alábbi megoldás a célravezető:

extern "C" {
   #include <rs232.h>
}

Ugyancsak az extern "C" deklarációt kell alkalmaznunk akkor is, ha C++ nyelven megírt és lefordított függvényeket C programból kívánjuk elérni.

Megjegyezzük, hogy a main () fügvény szintén extern "C" kapcsolódású.

A C nyelven a fájl szinten definiált változók és függvények (a szabványos könyvtár függvényei is) egyetlen közös névtérben helyezkednek el. A C++ nyelv a szabványos könyvtár elemeit az std névtérbe zárja, míg a többi fájl szinten definiált elemet a globális névtér tartalmazza.

A névterek elemeire való hivatkozáshoz meg kell ismerkednünk a hatókör operátorral (::). A hatókör operátor többször is előfordul könyvünk további fejezeteiben, most csak kétféle alkalmazására mutatunk példát.

A :: operátor segítségével a program tetszőleges blokkjából hivatkozhatunk a fájl- és program szintű hatókörrel rendelkező nevekre, vagyis a globális névtér azonosítóira.

#include <iostream>
using namespace std;
 
long a = 12;
static int b = 23;
 
int main() {
   double a = 3.14159265;
   double b = 2.71828182;
   {
      long a = 7, b;
      b = a * (::a + ::b);   
      // a b változó értéke 7*(12+23) = 245
      ::a = 7;
      ::b = 29;
   }
}

Ugyancsak a hatókör operátort alkalmazzuk, ha az std névtérben definiált neveket közvetlenül kívánjuk elérni:

#include <iostream>
int main() {
   std::cout<<"C++ nyelv"<<std::endl;
   std::cin.get();
}

A nagyobb C++ programokat általában több programozó fejleszti. A C++ nyelv eddig bemutatott eszközeivel elkerülhetetlen a globális (program szintű) nevek ütközése, keveredése. A saját névvel ellátott névterek bevezetése megoldást kínál az ilyen problémákra.

namespace nevter {
   deklarációk és definíciók
}

#include <iostream>
#include <string>
 
// deklarációk
namespace nspelda {
    extern int ertek;
    extern std::string nev;
    void Beolvas(int & a, std::string & s);
    void Kiir();
}
 
// definíciók
namespace nspelda {
    int ertek;
    std::string nev;
    void Kiir() {
        std::cout << nev << " = " << ertek << std::endl;
    }
}
 
void nspelda::Beolvas(int & a, std::string & s) {
    std::cout << "nev:   "; getline(std::cin, s);
    std::cout << "ertek: "; std::cin >> a;
}

int main() {
    nspelda::nev = "Osszeg";
    nspelda::ertek = 123;
    nspelda::Kiir();
    nspelda::Beolvas(nspelda::ertek, nspelda::nev);
    nspelda::Kiir();
    std::cin.get();
}

using namespace nspelda;
int main() {
    nev = "Osszeg";
    ertek = 123;
    Kiir();
    Beolvas(ertek, nev);
    Kiir();
    std::cin.get();
}

int Kiir() {
    std::cout << "Nevutkozes" << std::endl;
    return 1;
}
 
int main() {
    using nspelda::nev;
    using nspelda::ertek;
    using nspelda::Beolvas;
    nev = "Osszeg";
    ertek = 123;
    nspelda::Kiir();
    Beolvas(ertek, nev);
    Kiir();
    std::cin.get();
}

namespace Projekt {
    typedef unsigned char byte;
    typedef unsigned short word;
 
    namespace Intel {
        word ToWord(byte lo, byte hi) {
            return lo + (hi<<8);
        }
    }
 
    namespace Motorola {
        word ToWord(byte lo, byte hi) {
            return hi + (lo<<8);
        }
    }
}

using namespace Projekt::Intel;
int main() {
    cout << hex;
    cout << ToWord(0xab,0x12)<< endl;             // 12ab
}
// -------------------------------------------------------
int main() {
    using Projekt::Motorola::ToWord;
    cout << hex;
    cout << ToWord(0xab,0x12)<< endl;            // ab12
}
// -------------------------------------------------------
using namespace Projekt;
int main() {
    cout << hex;
    cout << Intel::ToWord(0xab,0x12)<< endl;     // 12ab
    cout << Motorola::ToWord(0xab,0x12)<< endl;  // ab12
}
// -------------------------------------------------------
int main() {
    cout<<hex;
    cout<<Projekt::Intel::ToWord(0xab,0x12)<< endl;   // 12ab
    cout<<Projekt::Motorola::ToWord(0xab,0x12)<<endl; // ab12
}

namespace alnev =kulsoNS::belsoNS … ::legbelsoNS;

int main() {
    namespace ProcI = Projekt::Intel;
    namespace ProcM = Projekt::Motorola;
    cout << hex;
    cout << ProcI::ToWord(0xab,0x12)<< endl;     // 12ab
    cout << ProcM::ToWord(0xab,0x12)<< endl;     // ab12
}

#include <iostream>
#include <string>
using namespace std;
 
namespace {
    string jelszo;
}
 
namespace {
    bool JelszoCsere() {
        bool sikeres = false;
        string regi, uj1, uj2;
        cout << "Regi jelszo: "; getline(cin, regi);
        if (jelszo == regi) {
            cout << "Uj jelszo: "; getline(cin, uj1);
            cout << "Uj jelszo: "; getline(cin, uj2);
            if (uj1==uj2) {
                jelszo = uj1;
                sikeres = true;
            }
        }
        return sikeres;
    } // JelszoCsere()
}
 
int main() {
    jelszo = "qwerty";
    if (JelszoCsere())
         cout << "Sikeres jelszocsere!" << endl;
    else
         cout << "Sikertelen jelszocsere!" << endl;
}

Szimbolikus konstansok készítéséhez a #define direktíva egyszerű alakját alkalmazzuk:

#define  azonosító
 
#define  azonosító  helyettesítő_szöveg

Nézzünk néhány példát a szimbolikus konstansok definiálására és használatára!

#define MERET 4
#define DEBUG
#define AND &&
#define VERZIO "v1.2.3"
#define BYTE unsigned char
#define EOS '\0'
 
int main() {
    int v[MERET];
    BYTE m = MERET;
    if (m > 2 AND m < 5)
        cout << "2 < m < 5" << endl;
    #ifdef DEBUG
        cout << VERZIO << endl;
    #endif
}

Az előfeldolgozás (helyettesítések) eredményeként keletkező forrásfájl:

int main() {
    int v[4];
    unsigned char m = 4;
    if (m > 2 && m < 5)
        cout << "2 < m < 5" << endl;
        cout << "v1.2.3" << endl;
}

C++-ban a fenti szimbolikus konstansok egy része helyett const és typedef azonosítókat is használhatunk:

#define DEBUG
#define AND &&
const int meret = 4;
const string verzio = "v1.2.3";
const char eos = '\0';
typedef unsigned char byte;
 
int main() {
    int v[meret];
    byte m = meret;
    if (m > 2 AND m < 5)
        cout << "2 < m < 5" << endl;
    #ifdef DEBUG
        cout << verzio << endl;
    #endif
}

A makrók felhasználási területét lényegesen bővíti a makrók paraméterezésének lehetősége. A függvényszerű, paraméteres makrók definíciójának általános formája:

#define  azonosító(paraméterlista)  helyettesítő_szöveg

A makró használata (hívása):

azonosító(argumentumlista)

A makróhívásban szereplő argumentumok számának meg kell egyeznie a definícióban szereplő paraméterek számával.

Annak érdekében, hogy a paraméteres makróink biztonságosan működjenek, be kell tartanunk a következő két szabály:

Az alábbi példaprogramban bemutatunk néhány gyakran használt makró-definíciót és a hívásukat:

// x abszolút értékének meghatározása
#define ABS(x)   ( (x) < 0 ? (-(x)) : (x) )
 
// a és b maximumának kiszámítása 
#define MAX(a,b) ( (a) > (b) ? (a) : (b) )
 
// négyzetre emelés 
#define SQR(X)   ( (X) * (X) )
 
// véletlen szám a megadott intervallumban
#define RANDOM(min, max) \
    ((rand()%(int)(((max) + 1)-(min)))+ (min))
 
int main() {
    int x = -5;
    x = ABS(x);
    cout << SQR(ABS(x));
    int a = RANDOM(0,100);
    cout << MAX(a, RANDOM(12,23));
}

A RANDOM() makró első sorának végén álló fordított perjel azt jelzi, hogy a makró-definíció a következő sorban folytatódik. A main () függvény tartalma az előfordítást követően egyáltalán nem nevezhető jól olvashatónak:

int main() {
   int x = -5;
   x = ( (x) < 0 ? (-(x)) : (x) );
   cout << ( (( (x) < 0 ? (-(x)) : (x) )) * 
          (( (x) < 0 ? (-(x)) : (x) )) );
   int a = ((rand()%(int)(((100) + 1)-(0)))+ (0));
   cout << ( (a) > (((rand()%(int)(((23) + 1)-(12)))+ (12)))
        ? (a) : (((rand()%(int)(((23) + 1)-(12)))+ (12))) );
}

A C++ program olvashatóságának megtartásával elérhetjük a makróhasználat összes előnyét (típusfüggetlenség, gyorsabb kód), ha a makrók helyett inline függvényt/függvénysablont használunk:

template <class tip> inline tip Abs(tip x) {
  return  x < 0 ? -x : x;
}
 
template <class tip> inline tip Max(tip a, tip b) {
  return a > b ? a : b;
}
 
template <class tip> inline tip Sqr(tip x) {
  return x * x;
}
 
inline int Random(int min, int max) {
  return rand() % (max + 1 - min) + min;
}
 
int main() {
    int x = -5;
    x = Abs(x);
    cout << Sqr(Abs(x));
    int a = Random(0,100);
    cout << Max(a, Random(12,23));
}

Egy makró bármikor törölhető, illetve újra létrehozható akár más tartalommal is. A törléshez az #undef direktívát kell használnunk. Egy makró új tartalommal történő átdefiniálása előtt mindig meg kell szüntetnünk a régi definíciót. Az #undef utasítás nem jelez hibát, ha a törölni kívánt makró nem létezik:

#undef azonosító

Az alábbi példában nyomon követhetjük a #define és az #undef utasítások működését:

int main() {
    #define MAKRO(x) (x) + 7
    int a = MAKRO(12);
    #undef MAKRO
    a = MAKRO(12);
    #define MAKRO 123
    a = MAKRO
}

int main() {

    int a = (12) + 7;

    a = MAKRO(12);

    a = 123
}

Az eddigi példáinkban a helyettesítést csak különálló paraméterek esetén végezte el az előfeldolgozó. Vannak esetek, amikor a paraméter valamely azonosítónak a része, vagy az argumentum értékét sztringként kívánjuk felhasználni. Ha a helyettesítést ekkor is el kell végezni, akkor a ## , illetve a # makróoperátorokat kell használnunk.

A # karaktert a makróban a paraméter elé helyezve, a paraméter értéke idézőjelek között (sztringként) helyettesítődik be. Ezzel a megoldással sztringben is lehetséges a behelyettesítés, hisz a fordító az egymás mellett álló sztringliterálokat egyetlen sztring konstanssá kapcsolja össze. Az alábbi példában az INFO() makró segítségével tetszőleges változó neve és értéke megjeleníthető:

#include <iostream>
using namespace std;
 
#define INFO(valtozo) \
        cout << #valtozo " = " << valtozo <<endl;
 
int main() {
   unsigned  x = 23;
   double   pi = 3.14259265;
   string    s = "C++ nyelv";
   INFO(x);
   INFO(s);
   INFO(pi);
}

x = 23
s = C++ nyelv
pi = 3.14259

A ## operátor megadásával két szintaktikai egységet (tokent) lehet összeforrasztani oly módon, hogy a makró törzsében a ## operátort helyezzük a paraméterek közé.

A alábbi példában szereplő SZEMELY() makró segít feltölteni a szemelyek tömb struktúra típusú elemeit:

#include <string>
using namespace std;
 
struct szemely {
    string nev;
    string info;
};
 
string Ivan_Info ="K. Ivan, Budapest,  9";
string Aliz_Info ="O. Aliz, Budapest, 33";
 
#define SZEMELY(NEV) { #NEV, NEV ## _Info }
 
int main(){
    szemely szemelyek[] = {
        SZEMELY (Ivan),
        SZEMELY (Aliz)
    };
}

A main () függvény tartalma az előfeldolgozás után:

int main(){
    szemely szemelyek[] = {
        { "Ivan", Ivan_Info },
        { "Aliz", Aliz_Info }
    };
}

Vannak esetek, amikor egyetlen makró megírásával nem érünk célt. Az alábbi példában a verziószámot sztringben rakjuk össze a megadott szimbolikus konstansokból:

#define FO 7
#define MELLEK 29
 
#define VERZIO(fo, mellek) VERZIO_SEGED(fo, mellek)
#define VERZIO_SEGED(fo, mellek) #fo "." #mellek
 
static char VERZIO1[]=VERZIO(FO,MELLEK);       // "7.29"
static char VERZIO2[]=VERZIO_SEGED(FO,MELLEK); // "FO.MELLEK"

Az ANSI C++ szabvány az alábbi, előre definiált makrókat tartalmazza. (Az azonosítók majd mindegyike két aláhúzás jellel kezdődik és végződik.) Az előre definiált makrók nevét nem lehet sem a #define sem pedig az #undef utasításokban szerepeltetni. Az előre definiált makrók értékét beépíthetjük a program szövegébe, de feltételes fordítás feltételeként is felhasználhatjuk.