Tablice obiektów
Definiowanie
" mo\
na tworzyć tablice obiektów klas lub wskaz
ników do
takich obiektów  analogicznie jak obiektów typów
wbudowanych czy klasycznych struktur
Przykład:
class osoba1 {
public:
char imie[20];
char nazwisko[30];
int wiek;
int waga;
};
osoba1 o1,o2; // pojedyncze obiekty
osoba1 grupa[10]; // tablica obiektow
osoba1 *rok[40]; // tablica wskaz
ników
" odniesienia do składowych elementów tablicy
grupa[0].imie;
grupa[9].wiek;
" odniesienia z wykorzystaniem wskaz
ników
osoba1 *wsk;
wsk=&grupa[2];
wsk->nazwisko; // równowa\
ne: grupa[2].nazwisko
wsk++;
wsk->wiek; // równowa\
ne: grupa[3].wiek
" dynamiczna alokacja tablic
o wykonanie:
osoba1 *wsk;
wsk = new osoba1[25];
o odniesienie do elementów tablicy
*(wsk+10);
wsk[10];
o odniesienie do pól składowych
(*(wsk+10)).wiek;
(wsk+10)->wiek;
wsk[10].wiek;
o zwolnienie pamięci
delete [ ] wsk;
Uwaga: nale\
y zadbać, by nie zmienić wskaz
nika
zwróconego przez new !!!
Inicjalizacja
" sposób przeprowadzenia zale\
y od typu obiektu
podstawowego oraz sposobu definicji tablicy  mo\
liwe
przypadki:
o inicjalizacja tablic  agregatów
o inicjalizacja tablic nie będących agregatami
o inicjalizacja danych alokowanych dynamicznie
" agregat (skupisko danych)  tablica obiektów klas, które
o nie mają składników prywatnych ani chronionych
o nie mają konstruktorów
o nie mają klas podstawowych
o nie mają funkcji wirtualnych
" inicjalizacja tablic agregatów: poprzez listę inicjalizatorów
ujętej w nawias { }
osoba1 student = { Jan ,  Kowalski , 20, 75};
osoba1 grupa[10] = {  Karol ,  Nowak , 21,67,
 Jan ,  Kowalski , 20, 75,
 Robert ,  Kula , 33,100};
o na liście inicjalizatorów mo\
e być mniej danych ni\

elementów tablicy
o brakujące elementy (tu: grupa[3] .. grupa[9] 
wypełnione zerami stosownego rodzaju)
" inicjalizacja tablic nie będących agregatami
o nie mo\
na stosować listy inicjalizatorów  danych
(część składowych  niedostępna)
o wyjście u\
ycie konstruktorów  na liście
inicjalizatorów umieszczamy wywołanie
konstruktorów dla poszczególnych elementów tablicy
Przykład:
#include
#include
#include
class osoba2 {
char imie[20];
char nazwisko[30];
int wiek;
int waga;
public:
static int suma_wag;
osoba2();
osoba2(char *i, char *n, int wi, int wg);
void raport();
};
int osoba2::suma_wag;
osoba2::osoba2() : wiek(0), waga(0)
{
strcpy(imie,"N");
strcpy(nazwisko,"N");
}
osoba2::osoba2(char *i, char *n, int wi, int wg) : wiek(wi), waga(wg)
{
strcpy(imie,i);
strcpy(nazwisko,n);
suma_wag+=wg;
}
void osoba2::raport()
{
cout << imie << " " << nazwisko << ", waga " << waga << " kg.\n";
}
main()
{
osoba2 premier("Kazimierz","Marcinkiewicz",46,69);
premier.raport();
const int ile_minister=10;
osoba2 minister[ile_minister]=
{osoba2("Jan","Rokita",46,77),
osoba2("Ludwik","Dorn",51,80),
osoba2(),
osoba2(),
osoba2("Zbigniew","Ziobro",35,82),
osoba2("Bronislaw","Komorowski",53,84)
};
for(int k=0; k minister[k].raport();
cout <<"---------------------------------------------------\n";
cout <<"Laczna waga rzadu = " << osoba2::suma_wag <<" kg.\n";
system("PAUSE");
}
Kazimierz Marcinkiewicz, waga 69 kg.
Jan Rokita, waga 77 kg.
Ludwik Dorn, waga 80 kg.
N N, waga 0 kg.
N N, waga 0 kg.
Zbigniew Ziobro, waga 82 kg.
Bronisław Komorowski, waga 84 kg.
N N, waga 0 kg.
N N, waga 0 kg.
N N, waga 0 kg.
N N, waga 0 kg.
---------------------------------------------------
Laczna waga rzadu = 392 kg.
przebieg inicjalizacji:
o jawne wywołanie konstruktora  powstanie obiektu
chwilowego
o inicjalizacja właściwego elementu tablicy przez
konstruktor kopiujący (na wzór obiektu chwilowego)
o gdy mniej elementów na liście ni\
rozmiar tablicy 
niejawne wywołania konstruktora domniemanego 
powinien być dostępny !!!
" incjalizacja tablic alokowanych dynamicznie
o takie tablice nie mogą mieć jawnej inicjalizacji
o są mo\
liwe do wykreowania tylko wtedy, gdy klasa
elementów składowych
nie ma \
adnego konstruktora, albo
wśród swoich konstruktorów ma konstruktor
domniemamy
o do inicjalizacji jest u\
ywany konstruktor domniemany
osoba2 *wsk;
wsk = new osoba2[10];
(wsk+8)->raport();
_______________________________
N N, waga 0 kg.
_______________________________
o gdy brak konstruktora domniemanego (a są inne) 
błąd kompilacji
Wskaz
niki do składowych klasy
" do tej pory  wskaz
niki słu\
ące do wskazywania
konkretnego miejsca w pamięci
" takie wskaz
niki mogą pokazywać tak na obiekt klasy, jak
te\
na jego (publiczną) składową
#include
#include
class numer {
public:
int nn;
static int aa;
void schowaj(int k){nn=k;}
int zwracaj() {return nn;}
};
int numer::aa=100;
main()
{
numer a,*wo;
wo=&a;
int *wi,*ws;
wi=&(a.nn);
ws=&numer::aa;
wo->schowaj(10);
cout << "skladowa nn obiektu a zawiera "< cout << "wi wskazuje na " << *wi << endl;
cout << "ws wskazuje na " << *ws << endl;
system("PAUSE");
}
___________________________________
Skladowa nn obiektu a zawiera 10
wi wskazuje na 10
ws wskazuje na 100
________________________________________
" nowy typ wskaz
ników  do pokazywania na niestateczne
publiczne składniki klasy (tak dane jak i metody)
" nie wskazuje na konkretne miejsce w pamięci  zamiast
tego mówi, gdzie w definicji klasy umieszczona jest dana
składowa (o ile komórek początek składowej jest
przesunięta względem początku całego obiektu)
" odwołanie do konkretnej składowej konkretnego obiektu 
wymaga zło\
enie dwóch rodzajów informacji:
o gdzie w pamięci jest obiekt, który nas interesuje
o jak mając obiekt dotrzeć do składowej
" składnia takiego odwołania:
obiekt.*wsk_skł
wsk_obiekt->*wsk_skł
gdzie: obiekt  nazwa (referencja obiektu)
wsk_obiekt  klasyczny wskaz
nik (do obiektu)
wsk_skł  nowego typu wskaz
nik do składnika
" definicja nowego typu musi określać
o klasę, której składniki chcemy wskazywać
o typ składnika, który chcemy wskazywać
Przykład:
class osoba3 {
public:
char imie[20];
char nazwisko[30];
int wiek;
int waga;
int wzrost;
osoba3(char *i, char *n, int wi, int wg, int wz);
int zw_wiek() {return wiek;}
int zw_waga() {return waga;}
int zw_wzrost() {return wzrost;}
};
osoba3::osoba3(char *i, char *n, int wi, int wg, int wz) :
wiek(wi), waga(wg), wzrost(wz)
{
strcpy(imie,i);
strcpy(nazwisko,n);
}
int osoba3::*wsk_skl; // definicja wskaz
nika do pokazywania
// na składowe klasy osoba3 typu int
wsk_skl=&osoba3::wiek; // ustawienie wskaz
nika
osoba3 o1( Jan , Nowak ,20,180,75); // definicja obiektu o1
jas.*wsk_skl; // to samo co jas.wiek
osoba3 *wo=&jas;
wo->*wsk_skl; // inna forma odniesienia do jas.wiek
" uwagi dotyczące wskaz
ników do składowych klasy
o nie mo\
na ich ustawiać na coś co nie jest składnikiem
klasy (próba takiego ustawienia  błąd kompilacji)
o nie mogą one wskazywać składowych prywatnych
o nie mogą one wskazywać składowych static
o nie mogą one wskazywać czegoś, co nie ma swojej
nazwy (np. konkretny element tablicy)
Wskaz
nik do funkcji składowej
" wskaz
niki do składowych mogą równie\
wskazywać
metody klasy
" definicja wskaz
nika  określa klasę i typ funkcji:
typ (K::*wsk_fun)(argumenty); np.:
int (osoba::*wsk_fun)();
" ustawienie wskaz
nika  wskazanie na funkcję skłądową
klasy
wsk_fun=&K::nazwa_metody; np.:
wsk_fun=&osoba3::zw_waga
" wywołanie
K obiekt;
(obiekt.*wsk_fun)(argumenty) np.:
osoba 3 o1( Jan , Nowak ,20,180,75);
(o1.*wsk_fun)(); // o1.zw_waga();
Tablice wskaz
ników do składowych klasy
" mo\
emy u\
ywać tablic wskaz
ników do publicznych,
niestatycznych składowych klas  tak danych jak i metod
" tablice wskaz
ników do metod  u\
yteczne przy tworzeniu
menu (ponumerowanie metod klasy)
Przykład:
int osoba3::*tab[3]; // definicja
tab[0]=&osoba3::wiek; // ustawienie
tab[2]=&osoba3::waga;
osoba3 o1( Jan , Nowak ,20,180,75);
cout << o1.*tab[2]; // u\
ycie
int (osoba3::*tab_fun[3])(); // definicja
tab_fun[0]=&osoba3::zw_wiek; // ustawienie
tab_fun[2]=&osoba3::zw_waga;
(o1.*fun_wsk[2])(); // u\
ycie