Notatki

Programowanie 2. Język C++. Wykład 3.
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.1
Programowanie zorientowane obiektowo ................................................................................................ 1
Unie........................................................................................................................................................ 2
Struktury ................................................................................................................................................. 3
Klasy ...................................................................................................................................................... 4
Elementy klasy ....................................................................................................................................... 5
Dostęp do elementów klasy .................................................................................................................... 7
Wskaźnik this..................................................................................................................................... 10
Programowanie zorientowane obiektowo
Zorientowane obiektowo programowanie (object-oriented programming) opiera się na trzech podstawowych
koncepcjach:
• abstrakcyjnych typów danych,
• dziedziczenia,
• wiązań dynamicznych.
Polimorfizm, ‘wiele form’, oznacza, Ŝe obiekty, operacje zachowują się w róŜnych sposób w zaleŜności od
kontekstu.
Przykłady typów polimorficznych:
• zmienne które przyjmują róŜne typy w zaleŜności od kontekstu,
• przeładowane funkcje, metody, operatory,
• typy danych które są w relacji dziedziczenia.
Obiekt (definicja Ecma/TC39-TG5/2004/25) - jest instancją typu.
Obiekt (definicja ISO/IEC 14882:2003(E)) – jest to obszarem pamięci. Obiekt jest tworzony za pomocą definicji,
wyraŜenia new, lub implementacji.
Obiekt ma nazwę, czas Ŝycia, typ.
Uwaga: Funkcja nie jest obiektem, chociaŜ zajmuje obszar w pamięci.
1
Programowanie 2. Język C++. Wykład 3.
3.2
Unie
union <nazwaUnii> { <elementyUnii> };
Własności:
1. Unie moŜna definiować bez nazwy (anonimowe). Anonimowe unie nie mogą mieć elementów
private, protected, zawierać metod.
2. Unie nie mogą dziedziczyć od klas, struktur.
3. Domyślny typ dostępu do elementów unii jest public.
4. Atrybuty unii nie mogą być inicjowane w unii.
Inicjowanie atrybutów moŜe odbywać za pomocą konstruktorów.
5. Unia nie moŜe zawierać referencji, obiektów.
6. Wielkość unii określona jest przez wielkość największego jej elementu.
Przykład 1. Definicja, wielkość unii (w03-01-uniaDefinicja.cpp).
#include <iostream>
using namespace std;
union unia {
char ch;
int i;
float f;
double d;
};
void main() {
unia x;
unia * wsk;
cout << "sizeof(x.ch) = " << sizeof(x.ch) << endl;
cout << "sizeof(x.d) = " << sizeof(x.d) << endl;
cout << "sizeof(unia) = " << sizeof(unia) << endl << endl;
wsk = &x;
cout << "&x
cout << "wsk
= " << (long)&x << endl;
= " << (long)&wsk << endl << endl;
x.ch = 'c';
cout << "x.ch
= " << x.ch << endl;
cout << "wsk->ch = " << wsk->ch << endl << endl;
}
2
Programowanie 2. Język C++. Wykład 3.
3.3
Struktury
struct <nazwa struktury> { <elementy struktury> };
Własności:
1. Domyślny typ dostępu do elementów struktury jest public.
2. Struktura moŜe zawierać konstruktora, destruktora.
3. Struktura moŜe dziedziczyć od struktury, klasy.
4. W strukturze nie moŜna inicjować zmiennych.
5. W strukturze moŜna inicjować zmienne typu static const.
Przykład 1. Definicja struktury (w3-02-strukturaDefinicja.cpp).
#include<iostream>
using namespace std;
struct S {
private:
char c;
public:
int i;
char f();
};
char S :: f() { c = 'a'; return c; }
typedef struct {
char c;
int i;
} tS;
void main() {
S s;
s.i = 99;
char cc;
cc = s.f();
cout <<"s.f() = "
tS s1;
tS *ps = &s1;
ps->c =
ps->i =
cout <<
cout <<
cout <<
<< cc << endl;
'a';
10;
"ps->c = " << ps->c << endl;
"ps->i = " << ps->i << endl;
"&ps
= " << &ps << endl;
}
3
Programowanie 2. Język C++. Wykład 3.
3.4
Klasy
class <nazwa klasy> { <elementy klasy> };
Własności:
1.
2.
3.
4.
Domyślny typ dostępu do elementów struktury jest private.
Klasa moŜe być wirtualna, abstrakcyjna.
Klasy moŜna zagnieŜdŜać.
W klasie moŜna inicjować tylko zmienne typu static const.
Przykład 1. Definicja klasy, metody (w03-03-klasaDefinicja.cpp).
#include <iostream>
using namespace std;
class A
{
public:
void fA();
protected:
private:
};
void A::fA() { cout <<"fA()" << endl; }
void main()
{
A a;
a.fA();
A &ra = a;
ra.fA();
A *pa = &a;
pa->fA();
A *p = new A;
p->fA();
(*p).fA();
delete p;
}
4
Programowanie 2. Język C++. Wykład 3.
3.5
Elementy klasy
W klasie moŜna definiować:
• atrybuty, czyli zmienne, wskaźniki, referencje, obiekty innych klas,
• metody, czyli funkcje w klasie,
• operatory,
• klasy, struktury, unie,
• konstruktory,
• destruktora.
Konstruktor klasy jest to metoda która:
• ma taką samą nazwę jak klasa,
• nie moŜe nic zwracać
• moŜe być przeładowany,
• moŜe być wirtualny,
• moŜe być zdefiniowany w obszarze private.
Konstruktor słuŜy do tworzenia i inicjowanie obiektów.
Destruktor klasy to metoda która:
• ma taką samą nazwę jak klasa, nazwa poprzedzona jest znakiem ~ , np. ~A(){ }, gdzie A jest nazwą klasy,
• nie moŜe nic zwracać,
• nie moŜe mieć argumentów,
• musi być w obszarze public.
Destruktor słuŜy do usuwania obiektów z pamięci.
Przykład 1. Domyślny konstruktor, destruktor obiektu (w03-04-konstruktor.cpp).
#include <iostream>
using namespace std;
class A
{
public:
A(){ cout <<"A()" << endl; }
~A(){ cout <<"~A()" << endl; }
void f() { cout <<" f() w A" << endl;
};
void main()
{
A a;
a.f();
A &r = a;
r.f();
}
// wywoływany jest konstruktor A()
// konstruktor A() nie jest wywoływany
A *p = new A; // wywoływany jest konstruktor A()
p->f();
delete p;
}
5
Programowanie 2. Język C++. Wykład 3.
Przykład 2. Przeładowanie konstruktora (w03-05-konstruktorPrzeladowany.cpp).
#include<iostream>
using namespace std;
class A {
public:
// A(){ cout << "A()" << endl;} // domyślny konstruktor
A(int x) : i(x){ cout << "A(int)" << endl;}
~A(){ cout << "~A()" << endl; }
void f(){ cout << this->i << endl; }
private:
int i;
};
void main(){
//
A a;
// błąd C2512, brak domyślnego konstruktora A()
A b(100);
b.f();
//
//
A *pa1 = new A; // błąd C2512, brak domyślnego konstruktora A()
delete pa1;
A *pa2 = new A(200);
pa2->f();
delete pa2;
}
Przykład 3. Inicjowanie atrybutów klasy (w03-06-klasaAtrybuty.cpp).
#include <iostream>
using namespace std;
class A {
public:
//
A(){}
A(int x) : i(x+2) { ii = x; }
~A(){}
void f(int);
int i;
int g(){return ii;}
private:
int ii;
};
void A :: f(int x){
i = ii*x; }
void main(){
A a(200);
cout << "a.i
cout << "a.ii
= " << a.i
<< endl;
= " << a.g() << endl;
a.i = 300;
a.f(10);
A b(300);
cout << "b.i
cout << "b.ii
= " << b.i
<< endl;
= " << b.g() << endl;
}
6
Programowanie 2. Język C++. Wykład 3.
3.6
Dostęp do elementów klasy
class <nazwa klasy> {
<elementy klasy private>
private:
<elementy klasy>
protected:
<elementy klasy>
public:
<elementy klasy>
};
Typy dostępu do elementów klasy:
Elementy klasy dostępne dla obiektów zdefiniowanych wewnątrz
private
klasy.
protected
Elementy klasy dostępne dla obiektów zdefiniowanych wewnątrz
klasy i obiektów klas dziedzicznych.
public
Elementy klasy dostępne dla obiektów klasy i obiektów klas
dziedzicznych.
7
Programowanie 2. Język C++. Wykład 3.
Przykład 1. Dostęp do elementów klasy (w03-07-TypDostepu.cpp).
#include <iostream>
using namespace std;
class A
{
public:
A(){ ia=99; }
void f1A();
protected:
void f2A() { cout << "protected f2A()" << endl; }
private:
void f3A() { cout << "private f3A()" << endl; }
int ia;
};
void A::f1A() {
cout << "public f1A()" << endl;
this->f3A();
// ok, f3A()jest private
this->ia=100;
// ok, ia jest private
cout << ia << endl;
}
class B : public A
// musi być public
{
public:
void f1B() { this->f2A(); }
//ok, f2A() jest proteced
// void f2B() { this->f3A(); } // błąd, f3A() jest private
protected:
private:
};
void main()
{
B b;
b.f1B();
b.f1A();
// b.f2A();
// B dziedziczy od A, f1A() public
// błąd dostępu, f2A() protected
A a;
a.f1A();
// a.f2A();
// a.f3A();
// a.ia = 101;
//ok, f1A() jest
// błąd dostępu,
// błąd dostępu,
// błąd dostępu,
public
f2A() protected
f3A() private
ia private
}
8
Programowanie 2. Język C++. Wykład 3.
Przykład 2. Dostęp do elementów klasy.
Kompozycja, obiekty zagnieŜdŜone prywatnie. (w03-08-dostep.cpp).
#include <iostream>
using namespace std;
class A {
public:
void fA() { cout << "public fA()" << endl; }
};
class B {
public:
void fB();
private:
A a;
};
void B::fB() {
cout << "public fB()
a.fA();
}
";
void main()
{
B b;
b.fB();
}
Przykład 3. Dostęp do elementów protected (w03-09-dostepProtected.cpp).
#include <iostream>
using namespace std;
class A {
public:
int fA() { this->ia = 100; return this->ia;}
protected:
int ia;
};
class B : A {
public:
int fB() { this->ia = 200; return this->ia;}
};
void
main(){
A a;
B b;
cout << a.fA() << endl;
cout << b.fB() << endl;
// cout << b.fA() << endl; // błąd, musi być class B : public A
}
9
Programowanie 2. Język C++. Wykład 3.
3.7
Wskaźnik this
Wskaźnik this wskazuje na obiekt danej klasy.
SłuŜy do wywoływania metod, manipulowania atrybutami wewnątrz klasy.
Przykład 1. UŜycie wskaźnika this ( w03-10-this.cpp).
#include<iostream>
using namespace std;
class A {
public:
A(int x) : i(x) {}
void f1() const { cout << i << endl; }
void f2() const;
void f3(int);
private:
int i;
};
void A::f2() const {
f1();
cout << this->i << endl;
this->f1();
}
// jawne uŜycie wskaźnika this
void A::f3(int x) {
this->i = x;
cout << i << endl;
}
void main() {
A a(100);
a.f1();
a.f2();
a.f3(200);
}
10