1. Komentarze

1. Komentarze w jednym wierszu

C	C++
c=a+b; /*c = sume a oraz b*/	c=a+b; //c = sume a oraz b

2. Komentarze w kilku wierszach

C	C++
/*To jest długi komentarz wjęzyku C który nie mieści się w jednym wierszu*/	//To jest długi komentarz w //języku C++ który nie mieści się //w jednym wierszu

2. Wejście / wyjście

1. Pliki nagłówkowe

C	C++
#include <stdio.h>	#include <iostream.h> #include <iomanip.h>

2. printf => cout

C	C++
printf("\n");	cout<<endl;

3. scanf => cin

C	C++
int x; scanf("%d",&x); printf("%d",x);	int x; cin>>x; cout<<x;
long x; scanf("%ld",&x); printf("%ld",x);	long x; cin>>x; cout<<x;
float x; scanf("%f",&x); printf("%f",x);	float x; cin>>x; cout<<x;
double x; scanf("%lf",&x); printf("%lf",x);	double x; cin>>x; cout<<x;
char x; scanf("%c",&x); printf("%c",x);	char x; cin>>x; cout<<x;
char Slowo[]="Czesc"; printf("%s",Slowo);	char Slowo[]="Czesc"; cout<<Slowo;
int x=144; printf("f(%d)=%lg\n",x,sqrt(x));	int x=144; cout<<"f("<<x<<")="<<sqrt(x)<<endl;

3. Formatowanie wejścia / wyjścia

1. Szerokość drukowania

C	C++
int x=12,y=13; printf("%8d%8d",x,y);	int x=12,y=13; cout<<setw(8)<<x<<setw(8)<<y;

2. Precyzja

C	C++
double x=12.34567; printf("%6.3lf",x);	double x=12.34567; cout<<setw(6)<<setprecision(3)<<x;

3. Tryb domyślny / naukowy

C	C++
double x=12345.6789; printf("%lf\n%le\n",x,x);	double x=12345.6789; cout.setf(ios::fixed); cout<<x<<endl; cout.setf(ios::scientific); cout<<x<<endl;

4. Struktury

1. Dla struktur typedef jest zbędny

C	C++
struct SX { int x; }; struct SX S;	struct SX { int x; }; SX S;
typedef struct { int x; }SX; SX S;

5. Deklaracja/Inicjalizacja zmiennych

1. Deklaracja w dowolny miejscu

C	C++
int main() { int x; double y; printf("Podaj wartosc x: "); scanf("%d",&x); y=sqrt(x); printf("sqrt(%d)=%lf\n",x,y); return(0); }	int main() { cout<<"Podaj wartosc x: "; int x; cin>>x; double y; y=sqrt(x); cout<<"sqrt("<<x<<")="<<y<<endl; return(0); }

2. Deklaracja nawet w instrukcji for

C	C++
int main() { int i; for(i=0;i<10;++i) { printf("%d\n",i); } return(0); }	int main() { for(int i=0;i<10;++i) { cout<<i<<endl; } return(0); }

3. Inicjalizacja nawet wynikiem funkcji

C	C++
char Slowo[]="Kakao"; int main() { int i,n; n=strlen(Slowo); for(i=0;i<n;++i) { printf("%c",Slowo[i]); } return(0); }	char Slowo[]="Kakao"; int main() { int n=strlen(Slowo); for(int i=0;i<n;++i) { cout<<Slowo[i]; } return(0); }

4. Rozmiar tablicy jako stała

C	C++
#define N 50 long Tablica[N];	const int N=50; long Tablica[N];

6. Struktury = Klasy

1. Struktura to klasa z publicznymi składowymi

C	C++
typedef struct { double x,y; }Punkt;	struct Punkt { double x,y; };
	class Punkt { public: double x,y; }; int main() { Punkt P; Punkt *W=&P; P.x=0; //korzystanie dokładnie W->y=0; //jak ze struktur return(0); }

7. Dynamiczne przydzielanie pamięci

1. malloc, realloc, free => new, delete

C	int main() { double *Tablica; Tablica=(double*)malloc(10*sizeof(double)); Tablica=(double*)realloc(Tablica,20*sizeof(double)); free(Tablica); return(0); }
C++	int main() { double *Tablica=new double[10]; double *Tmp=new double[20]; memcpy(Tablica,Tmp,10*sizeof(double)); delete[] Tablica; Tablica=Tmp; delete[] Tablica; return(0); }

2. Dynamiczne struktury lub klasy

C	typedef struct { double x,y; }Punkt; int main() { Punkt *P; Punkt *Tablica; P=(Punkt*)malloc(sizeof(Punkt)); Tablica=(Punkt*)malloc(10*sizeof(Punkt)); free(Tablica); free(P); return(0); }
C++	struct Punkt { double x,y; }; int main() { Punkt *Tablica=new Punkt[10]; Punkt *P=new Punkt; delete[] Tablica; // delete[] => zwalniamy tablice delete P; // delete => zwalniamy jeden element return(0); }
C++	class Punkt { public: double x,y; }; int main() { Punkt *Tablica=new Punkt[10]; //Punkt *Tablica=new Punkt()[10]; Punkt *P=new Punkt; //Punkt *P=new Punkt(); delete[] Tablica; delete P; return(0); }

8. Referencja

1. Przekazywanie zmiennych przez referencje

C	C++
void Swap(int *x,int *y) { int pom; pom=*x; *x=*y; *y=pom; } int main() { int a=3,b=7; Swap(&a,&b); return(0); }	void Swap(int &x,int &y) { int pom=x; x=y; y=pom; } int main() { int a=3,b=7; Swap(a,b); return(0); }

2. przekazywanie struktur lub klas przez referencje

C	C++
typedef struct { double x,y; }Punkt; void InicjalizujPunkt(Punkt *P) { P->x=P->y=0; } int main() { Punkt P; InicjalizujPunkt(&P); return(0); }	struct Punkt { double x,y; }; void InicjalizujPunkt(Punkt &P) { P.x=P.y=0; } int main() { Punkt P; InicjalizujPunkt(P); return(0); }

3. Referencja musi być zainicjalizowana tuz przy powstaniu

C	C++
struct Punkt { double x,y; }; int main() { Punkt X; //Punkt &P1; P1=X; //Źle //Punkt &P2; P2=*(new Punkt); //delete &P2; return(0); }	struct Punkt { double x,y; }; int main() { Punkt X; Punkt &P1=X; Punkt &P2=*(new Punkt); delete &P2; return(0); }

9. Funkcji

1. Przeciążenie funkcji

int Suma(int a,int b) { return(a+b); } long Suma(long a,long b) { return(a+b); } double Suma(double a,double b) { return(a+b); } int main() { cout<<Suma(3,7)<<endl; cout<<Suma(333333333L,666666666L)<<endl; cout<<Suma(2.5,7.5)<<endl; return(0); }

2. Funkcje inline

// Szybciej działa zaś powiększa rozmiar programu dla dużych funkcji // W przypadku małych funkcji nawet zmniejsza rozmiar programu inline void Swap(int &x,int &y) { register tmp=x; x=y; y=tmp; }

3. Parametry domyślne

inline int max(int a,int b) { return(a>b?a:b); } int max(int a,int b,int c,int d=0,int e=0,int f=0,int g=0,int h=0) { return(max(max(max(a,b),max(c,d)),max(max(e,f),max(g,h)))); } int main() { cout<<max(2,1)<<endl; cout<<max(2,1,7)<<endl; cout<<max(2,1,7,4)<<endl; cout<<max(2,1,7,4,9,3,5)<<endl; cout<<max(2,1,7,4,9,3,5,6)<<endl; return(0); }

4. Funkcje inline

// Szybciej działa zaś powiększa rozmiar programu dla dużych funkcji // W przypadku małych funkcji nawet zmniejsza rozmiar programu inline void Swap(int &x,int &y) { register tmp=x; x=y; y=tmp; }

10. Funkcje składowe

1. Korzystanie z funkcji składowych

C	C++
typedef struct { double x,y; }Punkt; void InicjalizujPunkt(Punkt *P) { P->x=P->y=0; } int main() { Punkt P; InicjalizujPunkt(&P); return(0); }	struct Punkt { double x,y; void InicjalizujPunkt(void); }; void Punkt::InicjalizujPunkt(void) { x=y=0; } int main() { Punkt P; P.InicjalizujPunkt(); return(0); }
	class Punkt { public: double x,y; void InicjalizujPunkt(void); }; void Punkt::InicjalizujPunkt(void) { x=y=0; } int main() { Punkt P; P.InicjalizujPunkt(); return(0); }

2. Funkcje składowe inline

struct Punkt { double x,y; void InicjalizujPunkt() { x=y=0; } }; int main() { Punkt P; P.InicjalizujPunkt(); return(0); }

class Punkt { public: double x,y; void InicjalizujPunkt() { x=y=0; } }; int main() { Punkt P; P.InicjalizujPunkt(); return(0); }

3. Wskaźnik this (autoreferencja)

struct Punkt { double x,y; void Ustaw(double x,double y) { this->x=x; this->y=y; } }; int main() { Punkt P; P.Ustaw(3,4); return(0); }

class Punkt { public: double x,y; void Ustaw(double x,double y) { this->x=x; this->y=y; } }; int main() { Punkt P; P.Ustaw(3,4); return(0); }

11. Konstruktor / destruktor

1. Konstruktor

struct Punkt { double x,y; Punkt(void); }; Punkt::Punkt(void) { x=y=0; } int main() { Punkt P; // P już po inicjalizacji return(0); }

class Punkt { public: double x,y; Punkt(void); }; Punkt::Punkt(void) { x=y=0; } int main() { Punkt P; // P już po inicjalizacji return(0); }

2. Lista inicjalizująca

struct Punkt { double x,y; Punkt():x(0),y(0) {} };	class Punkt { public: double x,y; Punkt():x(0),y(0) {} };
struct Punkt { double x,y; Punkt(void); }; Punkt::Punkt():x(0),y(0) {}	class Punkt { public: double x,y; Punkt(void); }; Punkt::Punkt():x(0),y(0) {}

3. Destruktor

class Punkt { public: char *Nazwa; double x,y; Punkt(const char *Nazwa):Nazwa(strdup(Nazwa)),x(0),y(0) {} Punkt(Punkt &P):Nazwa(strdup(P.Nazwa)),x(P.x),y(P.y) {} ~Punkt() { if(Nazwa) delete Nazwa; } // nie da się przeciążyć destruktor }; // Struktura również może mieć destruktor

4. Konstruktorze dodatkowe

struct Punkt { double x,y; // Konstruktor domyślny Punkt():x(0),y(0) {} // Konstruktor kopiujący Punkt(Punkt &P):x(P.x),y(P.y) {} Punkt(double px,double py): x(px),y(py) {} }; int main() { // (x,y) Punkt A; // (0,0) Punkt B(1,9); // (1,9) Punkt C(B); // (1,9) Punkt *D=new Punkt; // (0,0) Punkt *E=new Punkt(2,8); // (2,8) Punkt *F=new Punkt(B); // (1,9) Punkt *G=new Punkt(*E); // (2,8) delete D; delete E; delete F; delete G; return(0); }

class Punkt { public: double x,y; // Konstruktor domyślny Punkt():x(0),y(0) {} // Konstruktor kopiujący Punkt(Punkt &P):x(P.x),y(P.y) {} Punkt(double px,double py): x(px),y(py) {} }; int main() { // (x,y) Punkt A; // (0,0) Punkt B(1,9); // (1,9) Punkt C(B); // (1,9) Punkt *D=new Punkt; // (0,0) Punkt *E=new Punkt(2,8); // (2,8) Punkt *F=new Punkt(B); // (1,9) Punkt *G=new Punkt(*E); // (2,8) delete D; delete E; delete F; delete G; return(0); }

5. Referencja składowa (musi być zainicjalizowana w liście inicjalizujacej)

struct Sumator { double &Suma; Sumator(double &X):Suma(X) {} void Licz(double x) { Suma+=x; } }; int main() { double Suma; Sumator S(Suma); S.Licz(1); S.Licz(2); S.Licz(3); cout<<”Suma=”<<Suma<<endl; //na wydruku Suma=6 return(0); }

class Sumator { double &Suma; public: Sumator(double &X):Suma(X) {} void Licz(double x) { Suma+=x; } }; int main() { double Suma; Sumator S(Suma); S.Licz(1); S.Licz(2); S.Licz(3); cout<<”Suma=”<<Suma<<endl; //na wydruku Suma=6 return(0); }

6. Konstruktor domyslny, konstruktor kopiujący

class Punkt { public: char *Nazwa; double x,y; Punkt(const char *Nazwa):Nazwa(strdup(Nazwa)),x(0),y(0) {} ~Punkt() { if(Nazwa) delete Nazwa; } }; int main() { //Punkt P; // Źle (brak konstruktora domyslnego) Punkt X(”Punkt X”); // Dobrze return(0); }

class Punkt { public: char *Nazwa; double x,y; Punkt():Nazwa(NULL),x(0),y(0) {} Punkt(const char *Nazwa):Nazwa(strdup(Nazwa)),x(0),y(0) {} ~Punkt() { if(Nazwa) delete Nazwa; } }; int main() { Punkt X(”Punkt X”); cout<<X.Nazwa<<endl; // Wypisze: Punkt X Punkt *P=new Punkt(X); cout<<P->Nazwa<<endl; // Wypisze: Punkt X delete P; cout<<X.Nazwa<<endl; // Upsss!!! // Nazwa została zwolniona podczas zwolnienia P // Przycina - brak konstruktora kopiującego return(0); }

class Punkt { public: char *Nazwa; double x,y; Punkt():Nazwa(NULL),x(0),y(0) {} Punkt(Punkt &P):Nazwa(strdup(P.Nazwa)),x(P.x),y(P.y) {} Punkt(const char *Nazwa):Nazwa(strdup(Nazwa)),x(0),y(0) {} ~Punkt() { if(Nazwa) delete Nazwa; } }; int main() { Punkt X(”Punkt X”); cout<<X.Nazwa<<endl; Punkt *P=new Punkt(X); cout<<P->Nazwa<<endl; delete P; cout<<X.Nazwa<<endl; return(0); }

12. Składowe statyczne

1. Zmienne statyczne

class UnikalnyID { static unsigned long SID; public: unsigned long ID; UnikalnyID():ID(SID++) {} void Drukuj(const char *Tekst); }; unsigned long UnikalnyID::SID=0; //Inicjalizacja ID będą nadawane od 0; void UnikalnyID::Drukuj(const char *Tekst) { cout<<Tekst<<”ID=”<<ID<<';'<<endl; } int main() { UnikalnyID A; A.Drukuj(”A.”); UnikalnyID B; B.Drukuj(”B.”); UnikalnyID *W=new UnikalnyID; W->Drukuj(”W->”); delete W; for(int i=0;i<5;++i) { UnikalnyID C; C.Drukuj(”C.”); } return(0); }

2. Funkcje statyczne

class Punkt { static double DomyslnyX,DomyslnyY; public: // funkcja statyczna może korzystać wyłącznie ze // zmiennych oraz funkcji statycznych static void WartosciDomyslne(double x,double y) { DomyslnyX=x; DomyslnyY=y; } double x,y; Punkt():x(DomyslnyX),y(DomyslnyY) {} void Pisz() { cout<<'('<<x<<','<<y<<')'<<endl; } int JestDomyslny(void) {// Można korzystać ze zmiennych statycznych return((x==DomyslnyX)&&(y==DomyslnyY)); } void WartosciDomyslne() {// Można korzystać z funkcji statycznych WartosciDomyslne(x,y); } }; double Punkt::DomyslnyX=0; double Punkt::DomyslnyY=0; int main() { Punkt::WartosciDomyslne(0,0); // Da się wywołać zanim powstanie obiekt Punkt A; A.Pisz(); // (0,0) Punkt::WartosciDomyslne(1,2); Punkt B; B.Pisz(); // (1,2) B.x=7; B.y=8; B.Pisz(); // (7,8) B.WartosciDomyslne(); Punkt C; C.Pisz(); // (7,8) C.WartosciDomyslne(3,4); // Wywołanie funkcji statycznej przez obiekt Punkt D; D.Pisz(); // (3,4) if(D.JestDomyslny()) cout<<"D ma wartości domyślne"<<endl; if(!C.JestDomyslny()) cout<<"C ma nie domyślne wartości"<<endl; return(0); }

13. Przeciążenie operatorów

1. Operacje proste wewnętrzne

class LiczbaZespolona { public: double N,I; LiczbaZespolona():N(0),I(0) {} LiczbaZespolona(double N,double I):N(N),I(I) {} LiczbaZespolona operator+(LiczbaZespolona &X); void Pisz() { cout<<N; if(I<0) cout<<”-i”<<-I; else if(I>0) cout<<”+i”<<I; cout<<endl; } }; LiczbaZespolona LiczbaZespolona::operator+(LiczbaZespolona &X) { return(LiczbaZespolona(N+X.N,I+X.I)); } int main() { LiczbaZespolona A(2,3),B(2,-3),C; C=A+B; C.Pisz(); return(0); }

2. Operacje proste zewnętrzne

class LiczbaZespolona { public: double N,I; LiczbaZespolona():N(0),I(0) {} LiczbaZespolona(double N,double I):N(N),I(I) {} LiczbaZespolona operator+(LiczbaZespolona &X); }; LiczbaZespolona LiczbaZespolona::operator+(LiczbaZespolona &X) { return(LiczbaZespolona(N+X.N,I+X.I)); } ostream &operator<<(ostream &s,LiczbaZespolona &L) { s<<L.N; if(L.I<0) s<<"-i"<<-L.I; else if(L.I>0) s<<"+i"<<L.I; return(s); } int main() { LiczbaZespolona A(2,3),B(2,-3),C; C=A+B; cout<<C<<endl; return(0); }

3. Operacje rzutowania oraz nawiasy kwadratowe

inline max(int a,int b) { return(a>b?a:b); } class Wektor { private: int Wymiar; double *W; public: Wektor(int Wymiar); ~Wektor() { delete[] W; } operator int() { return(Wymiar); } double &operator[](int Poz) { return(W[Poz]); } friend ostream &operator<<(ostream &s,Wektor &L); }; Wektor::Wektor(int Wymiar):Wymiar(max(2,Wymiar)) { W=new double[this->Wymiar]; } ostream &operator<<(ostream &s,LiczbaZespolona &L) { s<<'{'; for(int i=0;i<L.Wymiar;++i) { if(i) s<<','; s<<L.W[i]; } s<<'}'; return(s); } int main() { Wektor W(20); for(int i=1;i<=W;++i) W[i-1]=i*i; cout<<W<<endl; return(0); }

4. Operacje ++ --

class KodBinarny { private: static char RetTab[4]; char Tab[3]; protected: void Nastepny(void); void Poprzedni(void); public: KodBinarny(void) { memset(Tab,'0',3); } const char *operator++(void); // ++K; const char *operator++(int); // K++; const char *operator--(void); // --K; const char *operator--(int); // K--; }; char KodBinarny::RetTab[]={0,0,0,0}; void KodBinarny::Nastepny(void) { for(int i=2;i>=0;--i) { if(Tab[i]=='0') { Tab[i]='1'; break; } Tab[i]='0'; } } void KodBinarny::Poprzedni(void) { for(int i=2;i>=0;--i) { if(Tab[i]=='1') { Tab[i]='0'; break; } Tab[i]='1'; } } const char *KodBinarny::operator++(void) // ++K; { Nastepny(); memcpy(RetTab,Tab,3); return(RetTab); } const char *KodBinarny::operator++(int) // K++; { memcpy(RetTab,Tab,3); Nastepny(); return(RetTab); } const char *KodBinarny::operator--(void) // --K; { Poprzedni(); memcpy(RetTab,Tab,3); return(RetTab); } const char *KodBinarny::operator--(int) // K--; { memcpy(RetTab,Tab,3); Poprzedni(); return(RetTab); } int main() { KodBinarny K; cout<<endl; for(int i=0;i<8;++i) cout<<(++K)<<'\t'; cout<<endl; for(int i=0;i<8;++i) cout<<(K++)<<'\t'; cout<<endl; for(int i=0;i<8;++i) cout<<(--K)<<'\t'; cout<<endl; for(int i=0;i<8;++i) cout<<(K--)<<'\t'; cout<<endl; return(0); }

14. Dziedziczenie, kwalifikatory dostępu

1. Zmienne publiczne oraz prywatne

class Punkt { private: double odleglosc,kat; public: Punkt():odleglosc(0),kat(0) {} double Odleglosc() { return(odleglosc); } double Kat() { return(kat); } void Odleglosc(double Wartosc); void Kat(double Wartosc); double X() { return(odleglosc*cos(kat)); } double Y() { return(odleglosc*sin(kat)); } }; void Punkt::Odleglosc(double Wartosc) { if(Wartosc<0) { Wartosc=-Wartosc; Kat(kat+M_PI); } odleglosc=Wartosc; } void Punkt::Kat(double Wartosc) { kat=fmod(fmod(Wartosc,2*M_PI)+2*M_PI,2*M_PI); } int main() { Punkt P; //P.kat=M_PI; //Źle brak dostępu do zmiennej prywatnej P.Kat(M_PI/6); // 30 stopni P.Odleglosc(100); cout<<”Y=”<<P.Y()<<';'<<endl; // powinno wypisać Y=50; return(0); }

2. Dziedziczenie proste

class Punkt { public: double x,y; Punkt():x(0),y(0) {} Punkt(double x,double y):x(x),y(y) {} Punkt(Punkt &P):x(P.x),y(P.y) {} void Pisz() { cout<<'('<<x<<','<<y<<')'<<endl; } double OdlegloscOdSrodka() { return(sqrt(x*x+y*y)); } }; class Kolo:public Punkt { public: double promien; Kolo():promien(0) {} // zostanie tez wywołany konstruktor Punkt() Kolo(double x,double y,double promien):Punkt(x,y),promien(promien) {} Kolo(Punkt &P,double promien):Punkt(P),promien(promien) {} Kolo(Kolo &K):Punkt(K.x,K.y),promien(K.promien) {} void Pisz() { cout<<promien<<':'; Punkt::Pisz(); // wywołanie funkcji przodka } }; int main() { Punkt P(30,40); P.Pisz(); cout<<”Odleglosc punkta od (0,0)=”<<P.OdlegloscOdSrodka()<<endl; Kolo K; K.Pisz(); cout<<”Odleglosc srodka kola od (0,0)=”<<K.OdlegloscOdSrodka()<<endl; K.x=1; K.y=2; K.promien=3; K.Pisz(); cout<<”Odleglosc srodka kola od (0,0)=”<<K1.OdlegloscOdSrodka()<<endl; Kolo K1(100,100,100),K2(P,50),K3(K); K1.Pisz(); cout<<”Odleglosc srodka kola od (0,0)=”<<K1.OdlegloscOdSrodka()<<endl; K2.Pisz(); cout<<”Odleglosc srodka kola od (0,0)=”<<K2.OdlegloscOdSrodka()<<endl; K3.Pisz(); cout<<”Odleglosc srodka kola od (0,0)=”<<K3.OdlegloscOdSrodka()<<endl; return(0); }

3. Zmienne protected

class Bazowa { public: int bPub; protected: int bPro; private: int bPri; }; class PochodniaPub:public Bazowa { void Pisz() { cout<<bPub<<','<<bPro<<endl; } // brak dostępu do bPri //void Pisz2() { cout<<bPri<<endl; } }; class PochodniaPro:protected Bazowa { void Pisz() { cout<<bPub<<','<<bPro<<endl; } // brak dostępu do bPri //void Pisz2() { cout<<bPri<<endl; } }; class PochodniaPri:private Bazowa { void Pisz() { cout<<bPub<<','<<bPro<<endl; } // brak dostępu do bPri //void Pisz2() { cout<<bPri<<endl; } }; class TrzeciaPub:public PochodniaPub { void Pisz() { cout<<bPub<<','<<bPro<<endl; } // brak dostępu do bPri //void Pisz2() { cout<<bPri<<endl; } }; class TrzeciaPro:public PochodniaPro { void Pisz() { cout<<bPub<<','<<bPro<<endl; } // brak dostępu do bPri //void Pisz2() { cout<<bPri<<endl; } }; class TrzeciaPri:public PochodniaPri { // brak dostępu do bPub,bPro,bPri //void Pisz2() { cout<<bPub<<','<<bPro<<','<<bPri<<endl; } }; int main() { PochodniaPub Pub; // brak dostępu do bPro,bPri PochodniaPro Pro; // brak dostępu do bPub,bPro,bPri PochodniaPri Pri; // brak dostępu do bPub,bPro,bPri cout<<Pub.bPub<<endl; //cout<<Pub.bPro<<','<<Pub.bPri<<endl; //cout<<Pub.bPub<<','<<Pub.bPro<<','<<Pub.bPri<<endl; //cout<<Pro.bPub<<','<<Pro.bPro<<','<<Pro.bPri<<endl; //cout<<Pri.bPub<<','<<Pri.bPro<<','<<Pri.bPri<<endl; return(0); }
kwalif.\dziedzicz.	public	protected	private
public	public	protected	private
protected	protected	protected	private
private	private	private	private

4. Funkcje wirtualne

class A { public: void KimJestes(void) { cout<<”klasa A”<<endl; } virtual void KimJestesWirt(void) { cout<<”klasa A”<<endl; } }; class B:public A { public: void KimJestes(void) { cout<<”klasa B”<<endl; } virtual void KimJestesWirt(void) { cout<<”klasa B”<<endl; } }; int main() { A ka; A *wa=new A; A &ra=*(new A); B kb; B *wb=new B; B &rb=*(new B); A *w=new B; // wskaźnik na A który wskazuje na B A &r=*(new B); // referencja typu A która odwołuje się do B cout<<”A”<<endl; ka.KimJestes(); // klasa A ka.KimJestesWirt(); // klasa A wa->KimJestes(); // klasa A wa->KimJestesWirt(); // klasa A ra.KimJestes(); // klasa A ra.KimJestesWirt(); // klasa A cout<<”B”<<endl; kb.KimJestes(); // klasa B kb.KimJestesWirt(); // klasa B wb->KimJestes(); // klasa B wb->KimJestesWirt(); // klasa B rb.KimJestes(); // klasa B rb.KimJestesWirt(); // klasa B cout<<”Polimorfizm”<<endl; w->KimJestes(); // klasa A // jest to wskaźnik na A w->KimJestesWirt(); // klasa B // ale wskazuje na B r.KimJestes(); // klasa A // jest to referencja typu A r.KimJestesWirt(); // klasa B // ale odwołuje się do B delete wa; delete &ra; delete wb; delete &rb; delete w; delete &r; return(0); }

5. Zastosowanie funkcji wirtualnej

class Wlasciwosc { protected: char *Nazwa; public: Wlasciwosc(const char *Nazwa):Nazwa(strdup(Nazwa)) {} ~Wlasciwosc() { if(Nazwa) delete Nazwa; } virtual void Pisz() { cout<<Nazwa<<'='; } }; class WlasciwoscInt:protected Wlasciwosc { protected: int Wartosc; public: WlasciwoscInt(const char *Nazwa,int Wartosc): Wlasciwosc(Nazwa),Wartosc(Wartosc) {} virtual void Pisz() { Wlasciwosc::Pisz(); cout<<Wartosc<<endl; } }; class WlasciwoscDouble:protected Wlasciwosc { protected: double Wartosc; public: WlasciwoscDouble(const char *Nazwa,double Wartosc): Wlasciwosc(Nazwa),Wartosc(Wartosc) {} virtual void Pisz() { Wlasciwosc::Pisz(); cout<<Wartosc<<endl; } }; class WlasciwoscCiag:protected Wlasciwosc { protected: char *Wartosc; public: WlasciwoscCiag(const char *Nazwa,const char *Wartosc): Wlasciwosc(Nazwa),Wartosc(strdup(Wartosc)) {} ~WlasciwoscCiag() { if(Wartosc) delete Wartosc;} virtual void Pisz() { Wlasciwosc::Pisz(); cout<<Wartosc<<endl; } }; int main() { Wlasciwosc *WlasciwosciOsoby[5]; WlasciwosciOsoby[0]=new WlasciwoscCiag(”Nazwisko”,”Kowalski”); WlasciwosciOsoby[1]=new WlasciwoscCiag(”Imie”,”Jan”); WlasciwosciOsoby[2]=new WlasciwoscInt(”Wiek”,23); WlasciwosciOsoby[3]=new WlasciwoscDouble(”Wzrost”,1.85); WlasciwosciOsoby[4]=new WlasciwoscDouble(”Waga”,70.5); for(int i=0;i<5;++i) WlasciwosciOsoby[i]->Pisz(); for(int i=0;i<5;++i) delete WlasciwosciOsoby[i]; return(0); }

6. Funkcje abstrakcyjne, klasy abstrakcyjne

class Figura // klasa abstrakcyjna { public: virtual double Powerzchnia()=0; // funkcja abstrakcyjna virtual void Rysuj()=0; // funkcja abstrakcyjna }; class Punkt:public Figura // nadal klasa abstrakcyjna nie określona Powierzchnia() { protected: double x,y; public: Punkt(double x,double y):x(x),y(y) {} virtual void Rysuj() { cout<<'('<<x<<','<<y<<')'; } }; class Kolo:protected Punkt { protected: double x2,y2; public: Kolo(double x1,double y1,double x2,double y2) :Punkt(x1,y1),x2(x2),y2(y2) {} virtual double Powerzchnia() { double dx=x2-x; double dy=y2-y; double R=sqrt(dx*dx+dy*dy); return(R*R*M_PI); } virtual void Rysuj() { Punkt::Rysuj(); cout<<"-("<<x2<<','<<y2<<')'; } }; class Trojkat:protected Kolo { protected: double x3,y3; public: Trojkat(double x1,double y1,double x2,double y2,double x3,double y3) :Kolo(x1,y1,x2,y2),x3(x3),y3(y3) {} virtual double Powerzchnia() { return(fabs((x2-x)*(y3-y)-(x3-x)*(y2-y))/2); } virtual void Rysuj() { Kolo::Rysuj(); cout<<"-("<<x3<<','<<y3<<')'; } }; int main() { //Figura F; //Źle nie może istnieć implementacja klasy abstrakcyjnej //Punkt P(0,0); //Źle Figura *K=new Kolo(0,0,12,16); Figura *T=new Trojkat(0,0,0,50,50,0); cout<<"Powerzchnia Kola "; K->Rysuj(); cout<<" wynosi "<<K->Powerzchnia()<<endl; cout<<"Powerzchnia Trojkata "; T->Rysuj(); cout<<" wynosi "<<T->Powerzchnia()<<endl; delete K; delete T; return(0); }

15. Odczyt zapis plików

1. Otwarcie, zamkniecie, zapis, odczyt (w trybie tekstowym)

char NazwaPliku[]="test.txt"; void Zapis(fstream &f,double *Tab,int Rozmiar) { for(int i=0;i<Rozmiar;++i) f<<Tab[i]<<endl; // Zapis } void Zapis(double *Tab,int Rozmiar) { fstream f; f.open(NazwaPliku,ios::out); // otweranie do zapisu Zapis(f,Tab,Rozmiar); f.close(); // zamykanie } void Odczyt(fstream &f,double *Tab,int Rozmiar) { for(int i=0;i<Rozmiar;++i) f>>Tab[i]; // Odczyt } void Odczyt(double *Tab,int Rozmiar) { fstream f; f.open(NazwaPliku,ios::in); // otweranie do odczytu Odczyt(f,Tab,Rozmiar); f.close(); // zamykanie } int main() { double Tab[40]; int R=sizeof(Tab)/sizeof(double); randomize(); for(int i=0;i<R;++i) Tab[i]=100.*rand()/RAND_MAX; cout<<"========================"<<endl; for(int i=0;i<R;++i) cout<<setw(6)<<setprecision(2)<<Tab[i]<<'\t'; Zapis(Tab,R); memset(Tab,0,sizeof(Tab)); cout<<"========================"<<endl; for(int i=0;i<R;++i) cout<<setw(6)<<setprecision(2)<<Tab[i]<<'\t'; Odczyt(Tab,R); cout<<"========================"<<endl; for(int i=0;i<R;++i) cout<<setw(6)<<setprecision(2)<<Tab[i]<<'\t'; cout<<"========================"<<endl; unlink(NazwaPliku); // kasowanie return(0); }

16. Obsługa wyjątków

1. Try, catch, throw

char NazwaPliku[]="a:\\test.txt"; void Zapis(fstream &f,double *Tab,int Rozmiar) { for(int n=0;n<100;++n) { for(int i=0;i<Rozmiar;++i) { f.write((char*)(Tab+i),sizeof(double)); if(!f.good()) throw "Błąd zapisu"; } cout<<'\r'<<n<<'%'; } } void Zapis(double *Tab,int Rozmiar) { fstream f; f.open(NazwaPliku,ios::out); if(!f.good()) throw "Błąd otwarcia do zapisu"; try { Zapis(f,Tab,Rozmiar); } catch(...) { f.close(); // zamykamy plik throw; // rzucamy dalej } } void Odczyt(fstream &f,double *Tab,int Rozmiar) { for(int n=0;n<100;++n) { for(int i=0;i<Rozmiar;++i) { f.read((char*)(Tab+i),sizeof(double)); if(!f.good()) throw "Błąd odczytu"; } cout<<'\r'<<n<<'%'; } } void Odczyt(double *Tab,int Rozmiar) { fstream f; f.open(NazwaPliku,ios::in); if(!f.good()) throw "Błąd otwarcia do odczytu"; try { Odczyt(f,Tab,Rozmiar); } catch(...) { f.close(); // zamykamy plik throw; // rzucamy dalej } } int main() { randomize(); double Tab[100]; int R=sizeof(Tab)/sizeof(double); for(int i=0;i<R;++i) Tab[i]=100.*rand()/RAND_MAX; try { Zapis(Tab,R); cout<<"\rZapis poprawnie"<<endl; cout<<"Nacisnij <Enter> ..."; cin.get(); Odczyt(Tab,R); cout<<"\rOdczyt poprawnie"<<endl; } catch(char *Blad) { cout<<Blad<<endl; // obsługa wyjątku nie rzucamy dalej } unlink(NazwaPliku); return(0); }

17. Templates

1. Template dla funkcji

class Punkt { public: double x,y; Punkt(double x, double y):x(x),y(y) {} int operator<=(Punkt &P) { return((x<=P.x)&&(y<=P.y)); } }; template <class T> int W_Zakresie(T a,T x,T b) { return((a<=x)&&(x<=b)); } int main() { char *TakNie[]={”Nie”,”Tak”}; cout<<TakNie[W_Zakresie('A','p','Z')]<<endl; cout<<TakNie[W_Zakresie('A','P','Z')]<<endl; cout<<TakNie[W_Zakresie(0,150,100)]<<endl; cout<<TakNie[W_Zakresie(0,50,100)]<<endl; cout<<TakNie[W_Zakresie(0L,1500000000L,1000000000L)]<<endl; cout<<TakNie[W_Zakresie(0L,500000000L,1000000000L)]<<endl; cout<<TakNie[W_Zakresie(0.0,1.5,1.0)]<<endl; cout<<TakNie[W_Zakresie(0.0,0.5,1.0)]<<endl; cout<<TakNie[W_Zakresie(Punkt(0,0),Punkt(6,3),Punkt(5,5))]<<endl; cout<<TakNie[W_Zakresie(Punkt(0,0),Punkt(3,3),Punkt(5,5))]<<endl; return(0); }

2. Template dla klasy

template <class T> class Stos { protected: class Element { public: T Dane; Element *Nastepny; Element(T Dane,Element *Nastepny):Dane(Dane),Nastepny(Nastepny) {}; friend ostream &operator<<(ostream &S,Stos &D); }; Element *Pierwszy; void Push(T Dane); T Pop(void); T Get(void); public: void Clear(void); Stos():Pierwszy(NULL) {} ~Stos() { Clear(); } int Pusty() { return(!Pierwszy); } operator !() { return(Pusty()); } Stos &operator<<(T Dane) { Push(Dane); return(*this); } Stos &operator>>(T &Dane) { Dane=Pop(); return(*this); } friend ostream &operator<<(ostream &S,Stos &D); }; template <class T> void Stos<T>::Push(T Dane) { Pierwszy=new Element(Dane,Pierwszy); } template <class T> T Stos<T>::Pop() { if(Pusty()) throw "Błąd: POP przy pustym stosie"; Element *Gora=Pierwszy; Pierwszy=Pierwszy->Nastepny; T Dane=Gora->Dane; delete Gora; return(Dane); } template <class T> T Stos<T>::Get() { if(Pusty()) throw "Błąd: GET przy pustym stosie"; return(Pierwszy->Dane); } template <class T> void Stos<T>::Clear() { while(Pierwszy) { Element *Gora=Pierwszy; Pierwszy=Pierwszy->Nastepny; delete Gora; } } template <class T> ostream &operator<<(ostream &S,Stos<T> &D) { S<<'{'; for(Stos<T>::Element *Pom=D.Pierwszy;Pom;Pom=Pom->Nastepny) { S<<Pom->Dane; if(Pom->Nastepny) S<<';'; } S<<'}'; return(S); } int main() { randomize(); Stos<double> Sd; for(int i=0;i<8;++i) { double x=(10*(1+random(9))+(1+random(9)))/10.; double y=(10*(1+random(9))+(1+random(9)))/10.; cout<<Sd<<" <= ("<<x<<';'<<y<<')'<<endl; Sd<<x<<y; } cout<<endl<<Sd<<endl<<endl; while(!!Sd) { double x,y; Sd>>y>>x; cout<<Sd<<" => ("<<x<<';'<<y<<')'<<endl; } cout<<endl; char *Ciagi[]={"ala","ma","kota"}; Stos<char*> Sc; for(int i=0;i<3;++i) { cout<<Ciagi[i]<<' '; Sc<<Ciagi[i]; } cout<<endl; for(int i=0;i<3;++i) { Sc>>Ciagi[i]; cout<<Ciagi[i]<<' '; } cout<<endl; return(0); }

---