Notatki

Transkrypt

Notatki

Programowanie 2. Język C++. Wykład 4.
3.1
3.2
3.3
3.4
3.5
3.1
Relacje między klasami, klasy zagnieŜdŜone, klasy lokalne ........................................................................... 1
Zaprzyjaźnione klasy, specyfikator friend ................................................................................................... 3
Zaprzyjaźnione funkcje, metody z klasą ......................................................................................................... 4
Relacje dziedziczenia .................................................................................................................................... 6
Agregacja, kompozycja klas ........................................................................................................................... 9
Relacje między klasami, klasy zagnieŜdŜone, klasy lokalne
Przykład 1. Klasy zagnieŜdŜone w klasach (w04-01-klasyZagniezdzone.cpp).
#include<iostream>
using namespace std;
class A {
public:
A(){cout << "A()" << endl;}
~A(){cout << "~A()" << endl;}
class B
{
public:
B();
~B(){cout << "~B()" << endl;};
int pib() const { return ib; }
private:
int ib;
};
private:
class C {
public:
C(){};
int pic() const { return ic; }
private:
int ic;
};
class D; // deklaracacja klasy zagnieŜdŜonej
};
A::B::B()
{
cout << "B()" << endl;
ib = 100;
}
class A::D { };
// definicja klasy zagnieŜdŜonej
void main()
{
A::B b;
cout << b.pib() << endl;
}
1
Przykład 2. Klasa lokalna – klasa zagnieŜdŜona w funkcji (w04-02-klasyLokalne.cpp).
#include<iostream>
void f() {
class A {
public:
A():i(100) { cout << "A()" << endl;}
~A(){ cout << "~A()" << endl;}
int pi(){ return i; }
private:
int i;
};
A a;
cout << a.pi() << endl;
}
void main() {
f();
}
2
3.2
Zaprzyjaźnione klasy, specyfikator friend
Relacja friend daje moŜliwość zaprzyjaźnionym obiektom dostęp do niepublicznych elementów klasy.
Relacja zaprzyjaźnienia moŜe być między
• klasami,
• funkcja z klasą,
• metoda z klasą.
Własności:
1. Relacja friend nie jest dziedziczna (przechodnia).
2. Relacja friend nie jest przemienna.
3. Funkcje deklarowane jako friend są traktowane tak, jakby były definiowane za pomocą deklaracji extern
(MSDN).
Przykład 1. Zaprzyjaźnione klasy (w04-03-klasaFriend.cpp).
#include <iostream>
class A {
public:
A():ia(10){ cout<< "A()"<< endl; }
~A(){ cout<< "~A()"<< endl; }
int pia(){ return ia; }
friend class B;
protected:
//private: // teŜ ok
int ia;
};
class B {
public:
B():ib(100){ cout<< "B()"<< endl; }
~B(){ cout<< "~B()"<< endl; }
void fb(A *p){ p->ia = p->ia + ib;} // klasa B jest zaprzyjaźniona z A
void fb(A & r){ r.ia = r.ia + ib;} // klasa B jest zaprzyjaźniona z A
private:
int ib;
};
void main() {
A a;
B b;
b.fb(a);
cout << a.pia()<< endl;
b.fb(&a);
cout << a.pia()<< endl;
}
3
3.3
Zaprzyjaźnione funkcje, metody z klasą
Przykład 1. Zaprzyjaźnione metody z klasą (w04-04-metodaFriend.cpp).
#include <iostream>
class B;
class A
{
public:
int f1A(B &);
int f2A(B &);
};
class B
{
public:
B():ib(100){}
private:
friend int A::f1A(B &);
int ib;
};
int A::f1A(B& r) { return r.ib; }
// int A::f2A(B& r) { return r.ib; }
// OK, f1A(B&) friend B
// błąd, f2A(B&) nie jest friend
void main() {
A a;
B b;
cout << a.f1A(b);
}
4
Przykład 2. Zaprzyjaźnione funkcje z klasą (w04-05-funkcjeFriend.cpp).
#include <iostream>
class A {
public:
A():i(100){ii=1000;}
friend void g1(A*, int); // funkcja globalna g(A*) zaprzyjazniona z A
friend void g2(A&, int); // funkcja globalna g(A*) zaprzyjazniona z A
friend void h(A);
// funkcja globalna h(A) zaprzyjazniona z A
protected:
int i;
private:
int ii;
};
void g1(A *pa, int n) { // g1(A*) ma dostęp do A::i, A::ii
pa->i = n+ pa->ii;
}
void g2(A &r, int n) {
r.i = n+ r.ii;
}
// g2(A&) ma dostęp do A::i, A::ii
void h(A a) {
cout << a.i << endl;
cout << a.ii << endl;
}
void
{
// h(A) ma dostęp do A::i, A::ii
main()
A a;
A &r = a;
g1(&a, 20);
h(a);
g2(r, 30);
h(a);
}
5
3.4
Relacje dziedziczenia
Dziedziczenie typu:
• public (class B : public A), elementy publiczne klasy głównej A są publiczne dla obiektów klasy dziedzicznej B,
elementy protected klasy głównej A są protected dla obiektów klasy dziedzicznej B,
• protected (class B : protected A), elementy publiczne i protected klasy bazowej A są ‘protected’ dla obiektów
klasy pochodnej B,
• private (class B : private A), (class B : A), elementy publiczne, protected klasy bazowej A są prywatne dla
obiektów klasy pochodnej B.
Przykład 1. Relacje dziedziczenia, dziedziczenie private (w04-06-dziedziczenie.cpp).
#include<iostream>
class A {
public:
A():ia(100), iia(200){}
int
riia(){ return iia;}
int ia;
private:
int iia;
};
class B : A // class B : private A
{
public:
int f1B() { return riia(); }
int f2B();
};
int B::f2B() {
this->ia +=10;
return ia;
}
void main() {
B b;
cout << b.f1B() << endl;
cout << b.f2B() << endl;
//
b.riia();
// metody z B mają dostęp do public A
// metody z B mają dostęp do public A
// błąd dostępu, musi być class B : public A
}
6
Przykład 1. Dziedziczenie public (w04-07-dziedziczeniePublic.cpp).
#include<iostream>
class A {
public:
A(){ cout << "A()"<< endl;}
~A(){ cout << "~A()"<< endl;}
void fA() { cout << "fA" << endl; }
};
class B : public A {
public:
B(){cout << "B()"<< endl;}
~B(){cout << "~B()"<< endl;}
void fB() {cout << "fB" << endl; }
};
void main(){
B b;
// wywoływany jest konstruktor A() i B()
b.fB();
b.fA();
// obiekt b ma dostęp do metody z klasy A
}
Przykład 3. Relacja dziedziczenia jest przechodnia (w04-08-dziedziczenieABC.cpp).
#include<iostream>
class A {
public:
A(){ cout << "A()"<< endl;}
~A(){ cout << "~A()"<< endl;}
void fA() { cout << "fA()" << endl; }
};
class B : public A {
public:
B(){cout << "B()"<< endl;}
~B(){cout << "~B()"<< endl;}
void fB() {cout << "fB()" << endl; }
};
class C : public B {
public:
C(){cout << "C()"<< endl;}
~C(){cout << "~C()"<< endl;}
void fC() {cout << "fC()" << endl; }
};
void main(){
C c;
// wywoływany jest konstruktor A(), B(), C()
c.fB(); // obiekt c ma dostęp do metody public z klasy B
c.fA(); // obiekt c ma dostęp do metody public z klasy A
}
7
Przykład. Dziedziczenie protected (w04-09-dziedziczenieProtected.cpp).
#include <iostream>
class A {
public:
void f1A(){cout << "f1A()" << endl;}
protected:
private:
};
class B : protected A {
public:
void f1B();
protected:
void f2B();
private:
void f3B();
};
void B::f1B(){
cout << "f1B()" << endl;
f1A();
f2A();
//
f3A(); // błąd dostępu
}
void B::f2B(){
f1A();
f2A();
//
}
void B::f3B(){
f1A();
f2A();
//
}
void main()
{
B b;
b.f1B();
// b.f1A(); // błąd dostępu
}
8
3.5
Agregacja, kompozycja klas
Definicja. Agregacja jest relacją między klasami, oznacza Ŝe klasa jest częścią innej klasy.
Przykład. Agregacja klas (w04-10-agregacaja.cpp).
#include<iostream>
class A {
public:
A(){ cout << "A()" << endl;}
~A(){cout << "~A()" << endl;}
void fA(){cout << "fA()" << endl;}
};
class B {
public:
B(){cout << "B()" << endl; }
~B(){cout << "~B()" << endl; }
void fB(){ pa->fA(); }
private:
A *pa;
};
void main(){
B b; // wywoływny jest konstruktor B()
b.fB();
}
9
Definicja. Kompozycja (złoŜenie, ang. composition) oznacza, Ŝe klasa zawiera instancję innej klasy.
Przykład. Kompozycja klas typu private (w04-11-kompozycja.cpp).
Czas Ŝycia obiektu a zaleŜy od czasu Ŝycia obiektów klasy B.
#include<iostream>
class A {
public:
A(){cout << "A()" << endl;}
~A(){cout << "~A()" << endl;}
};
class B {
public:
B(){cout << "B()" << endl;}
~B(){cout << "~B()" << endl;}
private:
A a[4];
};
void main() {
B b; // wywoływne są 4 konstruktory A(), jeden
}
B()
10

Notatki

Transkrypt

Podobne dokumenty

Przetwarzanie tekstu z pliku W pliku tolkien.txt dana jest jedna linia

Programowanie strukturalne i obiektowe Pętle Pętle warunkowe do

Pliki

Przeciążanie funkcji

Gospodyni ma 200 kur. Obserwujemy jej hodowlę od pierwszego dnia

Zadanie

Zadania

Laboratorium 1.