PODSTAWY
PROGRAMOWANIA
Wykład 9
PROWADZ
CY: dr inż. Marcin Głowacki
E-Mail: [e-mail]
Pok.907 C-5
Wrocław 2014
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 2
9. STRUKTURY DANYCH
Dane mogą być grupowane w usystematyzowane formy nazywane
STRUKTURAMI.
struct nazwa{ //struktura posiada swoją nazwę
typ zmienna1; //składnik
typ zmienna2; //składnik
typ zmienna3; //składnik
};
STRUKTURA jest nowym typem zdefiniowanym przez programistę, jednak
należy pamiętać, że bezpośrednio lub pośrednio składa się z typów
wbudowanych.
Podobnie do definicji KLASY, ale z pełnym dostępem do składników i bez
definicji metod, czyli funkcji do przetwarzania zmiennych klasy:
class nazwa{ //klasa posiada nazwę
public: //dostęp do składników bez ograniczeń
typ zmienna1; //składnik
typ zmienna2; //składnik
typ zmienna3; //składnik
};
W dostępie do zmiennych składowych struktury używa się operatora  .
(kropka) oraz  -> jeśli mamy do czynienia ze wskaz
nikiem na strukturę.
nazwa wej, bufor, *wsk_nazwa;
bufor.zmienna1++;
wsk_nazwa=&bufor;
wsk_nazwa->zmienna1; //dostęp do struktury przez wskaz
nik
Przykład: struktura zawierająca liczby zespolone
struct zespol{ //a+bi; składowa rzeczywista a i urojona b
int a,b; //nie można nadawać wartości domniemanych
};
zespol x={2,4},y;
y.a=x.a+5;
y.b=x.b+5;
Rezultat: y=7+9i
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 3
Przykład: Program liczy sumę liczb zespolonych
#include
#include
#include
using namespace std;
struct zespol{
int a,b; //a+bi; składowa rzeczywista a i urojona b
};
void fnWyswietl(zespol z){
cout<<"("<<};
zespol fnDodaj(zespol z1,zespol z2,int fl_wysw=0) {
zespol suma;
suma.a=z1.a+z2.a;
suma.b=z1.b+z2.b;
if(fl_wysw) {
fnWyswietl(z1);cout<<" + ";fnWyswietl(z2);
cout<<" = ";fnWyswietl(suma);cout<}
return suma;
}
int main(){
zespol x={2,3},y={4,5},wynik;
wynik=fnDodaj(x,y,1);
zespol k={4,3};
wynik=fnDodaj(wynik,k,1);
return 0;
Efekt:
};
(2+3i) + (4+5i) = (6+8i)
(6+8i) + (4+3i) = (10+11i)
Aby kontynuować, naciśnij dowolny klawisz . . .
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 4
UNIA
Dane o zadeklarowanych typach mogą być przetwarzane pojedynczo we wspólnej
przestrzeni pamięci nazywanej: UNIA.
union nazwa{ //struktura posiada swoją nazwę
typ zmienna1; //składnik
typ zmienna2; //składnik
typ zmienna3; //składnik
...
};
Rezerwowana jest przestrzeń pamięci operacyjnej dla największego rozmiaru
zmiennej składowej.
UWAGA: Tylko jeden składnik może być użyty w tym samym czasie.
Trzeba pamiętać typ danej zapisanej ostatnio do unii i zgodnie z tym typem używać
unię.
Przykład:
union schowek {
char c; //nie można nadawać wartości domniemanych
int i;
float f;
char int
}; float
schowek S1;
S1.c= A ;
cout<S1.f=2.72;
cout<y
LE: cout<Zastosowanie praktyczne unii jest ... mało praktyczne.
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 5
PRZECI
ŻANIE OPERATORÓW
Operatory, które mogą być przeciążane:
+ - * / % ^ & | ~ !
= < > += -= *= /= %= ^= &=
|= << >> >>= <<= == != <= >= &&
|| ++ -- , ->* -> new delete
Nie mogą być przeciążane: . .* :: ?:
Niektóre operatory mogą być jedno- lub & * - +
dwuargumentowe
Operatory są zdefiniowane i przeciążone dla typów wbudowanych, np.
dla int, long, float, double. Kompilator wykrywa typ zmiennych stojących po
obydwu stronach operatora i dobiera odpowiednią funkcję, która wykona
właściwe operacje. Muszą być zdefiniowane różne funkcje dla różnego typu
liczb i kodowania.
Definicja jako funkcja globalna:
arg1 @ arg2 // gdzie @ to operator
typ operator@(typ arg1, typ arg2);
Istotna jest kolejność argumentów: arg1 + arg2
Po lewej stronie operatora będzie pierwszy argument wywołania funkcji,
a po prawej stronie drugi argument. Ma to znaczenie w procesie wykrywania
typów danych biorących udział w operacji. Nie ma konieczności, żeby typy
argumentów były takie same.
Dzięki wykorzystaniu konwersji można stosować wiele typów danych jako
argumentów, które będą konwertowane do właściwych typów. Należy zadbać
o jednoznaczność kierunku konwersji, tak aby kompilator wiedział który z
argumentów ma konwertować.
Można operatory przeciążyć dla dowolnych typów pisząc odpowiednie
funkcje operatorowe, które mogą być funkcjami globalnymi albo funkcjami
składowymi klasy.
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 6
OPERATORY DWUARGUMENTOWE
Przykład: Operator dodawania  + zdefiniowany jest jako funkcja globalna:
typ operator+(typ arg1, typ arg2){
typ wynik;
...
//operacje zmierzające do wykonania operacji dodawania
// i zwrócenia wyniku zgodnego z typem deklarowanym
...
return wynik;
};
Przykład:
struct zespol{
int a,b; //a+bi; składowa rzeczywista a i urojona b
};
zespol operator+(zespol z1,zespol z2) {
zespol suma={0,0};
suma.a=z1.a+z2.a;
suma.b=z1.b+z2.b;
return suma;
}
zespol operator+=(zespol &z1,zespol z2) {
z1.a=z1.a+z2.a;
z1.b=z1.b+z2.b;
return z1;
}
Wywołanie:
zespol x={2,3},y={4,5},wynik;
wynik=x+y; //użycie operatora przeciążonego +
zespol k={4,3};
wynik+=k; //użycie operatora przeciążonego +=
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 7
UWAGA: Dla większej liczby jednoczesnych operacji zachowana
jest kolejność działań, np. mnożenie i dzielenie wykonywane jest
przed dodawaniem i odejmowaniem.
A + B * C to samo co A + (B * C )
A = B = C = D to samo co A = ( B = ( C =D))
OPERATORY JEDNOARGUMENTOWE
Występują jako przedrostek lub przyrostek z różnicą w działaniu.
- + ! & ~
-- ++
Jednoargumentowe funkcje operatorowe zwykle nic nie zwracają tylko
wykonują operacje na argumentach:
Definicja jako funkcja globalna:
@ arg lub arg @ // gdzie @ to operator
typ operator@(typ arg){
typ wynik;
...
//operacje zmierzające do wykonania funkcji operatorowej
// i zwrócenia wyniku zgodnego z typem deklarowanym
...
return wynik;
};
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 8
Przykład. Program z przeciążonymi operatorami: + += - -=
#include
#include
#include
using namespace std;
struct zespol{
int a,b; //a+bi; składowa rzeczywista a i urojona b
};
void fnWyswietl(zespol z){
cout<<"("<<};
void fnWyswietl(zespol z1,zespol z2,zespol wynik, char operat[4]){
fnWyswietl(z1);cout<<" "<cout<<" = ";fnWyswietl(wynik);cout<}
zespol operator-(zespol z1) { //jednoargumentowy '-'
zespol wynik={0,0};
wynik.a=-1*z1.a;
wynik.b=-1*z1.b;
return wynik;
}
zespol operator+(zespol z1) { //jednoargumentowy '+'
zespol wynik={0,0};
wynik.a=z1.a;
wynik.b=z1.b;
return wynik;
}
zespol operator+(zespol z1,zespol z2) { //dwuargumentowy '+'
zespol suma={0,0};
suma.a=z1.a+z2.a;
suma.b=z1.b+z2.b;
return suma;
}
zespol operator+(zespol z1,int rzeczyw) { //dwuargumentowy '+'
zespol suma={0,0};
suma.a=z1.a+rzeczyw;
suma.b=z1.b;
return suma;
}
zespol operator+(int rzeczyw,zespol z1) { //dwuargumentowy '+'
zespol suma={0,0};
suma.a= rzeczyw+z1.a;
suma.b=z1.b;
return suma;
}
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 9
zespol operator-(zespol z1,zespol z2) { //dwuargumentowy '-'
zespol suma={0,0};
suma.a=z1.a-z2.a;
suma.b=z1.b-z2.b;
return suma;
}
zespol operator-(zespol z1,int rzeczyw) { //dwuargumentowy '+'
zespol suma={0,0};
suma.a=z1.a-rzeczyw;
suma.b=z1.b;
return suma;
}
zespol operator-(int rzeczyw,zespol z1) { //dwuargumentowy '+'
zespol suma={0,0};
suma.a=rzeczyw-z1.a;
suma.b=-1*z1.b;
return suma;
}
zespol operator+=(zespol &z1,zespol z2) {
z1.a=z1.a+z2.a;
z1.b=z1.b+z2.b;
return z1;
}
zespol operator+=(zespol &z1,int rzeczyw) { //dwuargumentowy "+="
suma=z1+rzeczyw;
return z1;
}
zespol operator+=(int rzeczyw, zespol z1) { //dwuargumentowy "+="
zespol suma={0,0};
suma= rzeczyw+z1;
return suma;
}
zespol operator-=(zespol z1,zespol z2) { //dwuargumentowy "-="
zespol suma={0,0};
suma=z1-z2;
return suma;
}
zespol operator-=(zespol z1,int rzeczyw) { //dwuargumentowy "-="
zespol suma={0,0};
suma=z1-rzeczyw;
return suma;
}
zespol operator-=( int rzeczyw, zespol z1) { //dwuargumentowy "-="
zespol suma={0,0};
suma= rzeczyw-z1;
return suma; }
///////////////////////////////////////////// MAIN /////////////////////////////////////////////////
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 10
int main(){
zespol x={2,3},y={4,5},wynik;
wynik=x+y; //dwuargumentowy '+'
fnWyswietl(x,y,wynik,"+");
zespol k={4,3};
fnWyswietl(+wynik,k,wynik+=k,"+"); //jednoargumentowy '+'
//i dwuargumentowy "+="
fnWyswietl(k=-wynik); //jednoargumentowy '-'
cout<wynik=x-y;
fnWyswietl(x,y,wynik,"-");
fnWyswietl(wynik,k,wynik-=k,"-"); //dwuargumentowy "-="
fnWyswietl(x);cout<<" + 5 = ";fnWyswietl(wynik=x+5);cout<//dodawanie rzeczywistej po prawej
cout<<"5 + ";fnWyswietl(x);cout<<" = ";fnWyswietl(wynik=5+x);cout<//dodawanie rzeczywistej po lewej
fnWyswietl(x);cout<<" - 5 = ";fnWyswietl(wynik=x-5);cout<//odejmowanie rzeczywistej po prawej
cout<<"5 - ";fnWyswietl(x);cout<<" = ";fnWyswietl(wynik=5-x);cout<//odejmowanie rzeczywistej po lewej
system("PAUSE");
return 0;
}
Rezultat:
(2+3i) + (4+5i) = (6+8i)
(6+8i) + (4+3i) = (10+11i)
(-6-8i)
(2+3i) - (4+5i) = (-2-2i)
(-2-2i) - (-6-8i) = (4+6i)
(2+3i) + 5 = (7+3i)
5 + (2+3i) = (7+3i)
(2+3i) - 5 = (-3+3i)
5 - (2+3i) = (3-3i)
Aby kontynuować, naciśnij dowolny klawisz . . .
WYKA
AD 9 (2014) Podstawy programowania 1 (dr.inż Marcin Głowacki) 11
OPERATOR STRUMIENIA WYJŚCIA  <<
Ktoś skonstruował klasy ostream oraz istream,
a także przeciążył operator << dla typów wbudowanych, np. dla int:
cout.operator<<(int ...)
Można przeciążyć ten operator dla własnych typów, ponieważ funkcja
operatorowa może być funkcją globalną i nie musi ingerować w definicję klasy
ostream.
Przykład:
#include
#include
#include
using namespace std;
struct zespol{
int a,b; //a+bi; składowa rzeczywista a i urojona b
};
ostream & operator<<(ostream & ekran, zespol &z) {
ekran <<"("< < return ekran;
};
////////////////////////////// MAIN ////////////////////////////////////
int main(){
zespol x={2,3},y={4,5},wynik;
cout<<"Liczba zespolona x = "<cout<<"Liczba zespolona y = "<system("PAUSE");
return 0;
Rezultat:
}
Liczba zespolona x = (2+3i)
Liczba zespolona y = (4+5i)
Aby kontynuować, naciśnij dowolny klawisz . . .
Referencja użyta w argumencie dla wyświetlanych danych zespol &z nie jest
konieczna, bo operator nie ma zamiaru jej modyfikować, ale oszczędza
miejsce w pamięci, ponieważ nie jest tworzona dodatkowa kopia wartości
zespol z na stosie.