Laboratorium nr 12

Temat: Funkcje zaprzyjaźnione i wstęp do algorytmów programowania. Algorytm rekurencji. 

1. Funkcje zaprzyjaźnione

W przypadku istnienie w deklaracji klasy zmiennych typu private, dostęp do nich jest ograniczony 

do danego obiektu, wynika to z faktu, że w C++ jednostką chronioną przed niepowołanym dostępem jest 
klasa, a nie obiekt. Oznacza to, że funkcja składowa danej klasy może używać wszystkich składowych 
prywatnych dowolnego obiektu tej samej klasy. Natomiast do składowych prywatnych jakiegoś obiektu 
nie ma dostępu funkcja innej klasy, ani jakakolwiek funkcja niezależna. Rozwiązaniem tego problemu 
jest   zastosowanie   funkcji   zaprzyjaźnionych.   Funkcja   zaprzyjaźniona   posiada   dostęp   do   prywatnych 
danych obiektu lub obiektów danej klasy. Deklaracja:

class klasa {
private:

typ dana;

public:

…

friend typ funkcja (np. const class klasa &); 

}

!argumentem funkcji jest najczęściej referencja do obiektu danej klasy

Uwaga: 

C++ pozwala na domyślne przekazywanie parametrów przez referencję, a nie wartość. Oznacza to, 

że   pomimo   wywołania   funkcji   z   pewnymi   argumentami,   a   nie   wskaźnikami,   argumenty   te   będą 
automatycznie   przekazywane   przez   referencję.   W   tym   celu,   należy   jedynie   w   deklaracji   funkcji 
poprzedzić   argument   operatorem   &   -   funkcja   ta   będzie   wówczas   działać   w   stylu   języka,   w   którym 
parametry są przekazywane przez referencję, np.

  

friend klasa * funkcja (const class klasa &);

2. Algorytmy programowania. Algorytm rekurencji.

Algorytmem lub algorytmem programowania nazywamy taki tok postępowania, który prowadzi 

do rozwiązanie określonego zadania . Dobry algorytm charakteryzuje się:

●

jednoznacznie zdefiniowaną procedurą pozwalającą na rozwiązanie zadanego problemu,,

●

wykorzystaniem odpowiednich struktur danych ,

●

minimalną ilością kroków prowadzących do rozwiązania, uniwersalnością i możliwością 
wielokrotnego wykorzystania 

Przykłady algorytmów programowania to: generator liczb pseudolosowych, rekurencja, sortowanie, 
kompresja danych, itp.

Algorytm rekurencji

Rekurencję stosuje się w algorytmach rozwiązujących takie problemy, które można wykonać za 

pomocą   procedur   uzyskanych   dla   prostszych   problemów   tej   samej   klasy,   jak   wyznaczenie   wartości 
funkcji silnia:

1

2

...

1

...

)!

2

(

)

1

(

)!

1

(

!

⋅

⋅

⋅

−

⋅

=

=

−

⋅

−

⋅

=

−

⋅

=

x

x

x

x

x

x

x

x

Rozwiązanie głównego problemu składa się z wyników cząstkowych, wyznaczanych przez podprogram 
wykonywany   rekurencyjnie.   Taki   naturalny   zapis   algorytmów   wspierany   jest   poprzez   mechanizm 
wywołań rekurencyjnych – funkcja może zawierać wywołanie samej siebie. 

Uwaga: taki sposób wykonywania programu charakteryzuje się:

●

przejrzystym zapisem algorytmu,

●

dużym zaangażowaniem pamięci i długim czasem wykonania 

●

zastosowanie rekurencyjnego wywoływania funkcji przedstawiają poniższe przykłady służące do 
określenia ograniczenia zastosowania rekurencji oraz obliczania wartości silni.

# include <stdio.h>
int zlicz(int i){
 float tab[1000];
 printf("\nKrok nr=%d",i);
 zlicz(++i);
 return i;
}
int main() {
  zlicz(0);
  return 0;
}

# include <stdio.h>
int silnia(int x) {
 if (x==0) return 1;
 else return x*silnia(x-1); 
}
int main() {
 int liczba;
 printf("Podaj liczbe=");  
 scanf("%d",&liczba);
 printf("\nSilnia(%d)=%d",liczba,silnia(liczba));
 return 0;
}

Zadanie:  Każde wywołanie funkcji  zlicz(…)  zajmuje na stosie pewną ilość miejsca. Kiedy miejsce na 
stosie skończy się, aplikacja przerwie swoje działanie. Wyznaczyć liczbę kroków rekurencji w zależności 
od wielkości tablicy tab[n] oraz oszacować rozmiar dostępnego stosu. 

main.cpp

#include "klasa.h"

// funkcja friend

void wyswietl(rekord *obiekt){

  if(obiekt!=NULL) {

    cout<<obiekt->imie<<"\t";

    cout<<obiekt->nazwisko<<"\t";

    cout<<obiekt->telefon<<"\n";

    wyswietl(obiekt=obiekt->nastepny);

  }

  else cout << "Koniec listy\n";

};

int main() {

class lista *baza;

  baza=new lista();

  baza->dodaj("Jan","Nowak","1");

  baza->dodaj("Jan","Nowak","2");

  baza->dodaj("Jan","Nowak","3");

  wyswietl(baza->pierwszy);

  return 0;

};

klasa.h

#include <iostream>

#include <string.h>

using namespace std;

class rekord {

private:

public:

  char imie[10];

  char nazwisko[25];

  char telefon[10];

  class rekord *nastepny;

  rekord(char *i, char *n, char *t);

  rekord();

};

class lista : public rekord {

public:

  class rekord *pierwszy;

  void dodaj(char *i,char *n,char *t);

  lista(char *i="Imie", char 

*n="Nazwisko", char *t="Telefon");

  friend void wyswietl(rekord 

*obiekt);

};

klasa.cpp

#include "klasa.h"

// klasa rekord

rekord::rekord(char *i, char *n, char *t){

  strcpy(imie,i);

  strcpy(nazwisko,n);

  strcpy(telefon,t);

  nastepny=NULL;

};

rekord::rekord(){

};

// klasa lista

void lista::dodaj(char *i,char *n,char *t){

  class rekord *obiekt=this->pierwszy;

  while (obiekt->nastepny!=NULL) {

    obiekt=obiekt->nastepny;

  };

  obiekt->nastepny=new rekord;

  strcpy(obiekt->nastepny->imie,i);

  strcpy(obiekt->nastepny->nazwisko,n);

  strcpy(obiekt->nastepny->telefon,t);

  obiekt->nastepny->nastepny=NULL;

};

lista::lista(char *i,char *n,char *t) 

:rekord(i,n,t) {

  this->pierwszy=this;

};

3) Zadanie: Zmodyfikuj program bazy danych z poprzednich ćwiczeń tak, aby umożliwiał wyświetlania i 
kasowania wszystkich danych w bazie w oparciu o funkcje zaprzyjaźnione i algorytm rekurencji.