#include //przykład 1 #include #pragma hdrstop main () { clrscr (); // czyszczenie ekranu cout << "\n"; // nowa linia, endl; cout << "Witam na wykładzie\n"; cout << "Przedmiot: " << "Programowanie Obiektowe\n"; cout << "III rok, sem. V," << " kier. Elektrotechnika\n"; getch(); //oczekiwanie na nacisnięcie klawisza }
przyklad 2
/*------------------------------------------------------------------------------------- Program przelicza wysokosć podana w stopach na wysokosć podana w metrach. Ćwiczymy operacje wczytywania z klawiatury i wypisywania na ekranie. ----------------------------------------------------------------------------------------*/ #include #include main () { int stopy; // wysokosć podana w stopach float metry; // wysokosć w metrach float przelicznik = 0.3; // przelicznik: stopy na metry clrscr (); cout << "Podaj wysokosć w stopach: "; cin >> stopy; // wczytanie wysokosci w stopach // z klawiatury metry = przelicznik * stopy; cout << "\n"; // to samo co endl; cout << "Wysokosć " << stopy << " stóp - to jest: " << metry << " metrów\n"; getch(); }
przyklad 3
//przyklad 1 na if /* Program oblocza watosć funkcji f(x) w punkcie x. Funkcja zadana jest wzorem: f(x)=2*x^2+2 dla x<=0 f(x)=log x dla x>0 */ #include #include #include #pragma hdrstop;
#include //test instrukcji break #include main () { int i = 7; clrscr (); while (1) //pętla nieskończona { cout << "Pętla, i = " << i << "\n"; i = i - 1; if (i < 5) { cout << "Przerwanie pętli ! "; break; } } getch(); }
przyklad 9
#include //przyklad instrukcji break #include main () { int i, m; int dlugosc_linii = 3; clrscr (); for (i =0; i < 4; i = i+1) { for (m = 0; m <10; m = m+1) { cout << "*"; //druk dla m = 0,1,2,3,4 if (m > dlugosc_linii) break; } cout << "\nKontynuujemy zewnętrzna pętlę for" << " dla i =" << i << "\n"; } getch(); }
przyklad 10
#include //goto #include main () { cout << "Ala ma kota \n"; goto a; // brak deklaracji etykiety cout << "Ola ma psa"; a: cout << "Ela ma papugÄ™"; getch(); }
przyklad 11
#include //testowanie continue #include main () { int k; clrscr (); for (k = 0; k < 12; k = k+1) { cout << "A"; if (k > 1) continue; //rezygnacja z poniższej instrukcji cout << "b \n"; } cout << "\n"; getch(); }
przyklad 12
#include // liczby ósemkowe i szesnastkowe #include main () { int i; int k, n, m, j; clrscr (); i = 5; k = i + 010; //010 - ósemkowo = 8D cout << "k= " << k << endl; m = 100; n = 0x100; j = 0100; cout << "m+n+j= " << (m+n+j) << endl; cout << "wypisujemy: " << 0x22 << " " << 022 << " " << 22 << endl; getch(); }
#include #include int k =33; //zmienna globalna main () { clrscr (); cout << "Jestem w pliku głównym, k = " << k << endl; { //---------------------------------------------- int k = 10; //zmienna lokalna cout << "Po lokalnej definicji k = " << k << endl; } //---------------------------------------------- cout << "Poza blokiem k = " << k << endl; getch(); }
przyklad 15
#include // operatora zakresu :: #include int k =33; //zmienna globalna main () { clrscr (); cout << "Jestem w pliku głównym, k = " << k << endl; { //---------------------------------------------- int k = 10; //zmienna lokalna cout << "Po lokalnej definicji k = " << k << ", " << endl << "ale obiekt globalny k = " << ::k; } //---------------------------------------------- cout << "\nPoza blokiem k = " << k << endl; getch(); }
#include //przykład oper. % - modulo #include main() { int i ; for (i = 0 ; i < 64 ; i = i + 1) { if( i % 8) cout << "\t" ; //jesli r. jest niezerowa to wypis // tabulatora else cout << "\n" ; // przejscie do nowej linii cout << i ; } getch(); }
#include #include main() { int a = 85; char b; cout << "a= " << a << endl; b = (char) a; // b = 'U' cout << "b= " << b << endl; b = 'A'; a = (int) b; // a = 65 cout << "a= " << a < getch(); }
przyklad 23
#include #include
int Funk_1(int x); float Funk_2(long x); //obszar deklaracji funkcji char Funk_3(float z);
main ( ) { int a; float b; char c; //....... a = Funk_1(12 ); b = Funk_2(33333); //funkcja main() c = Funk_3 (0.3); //.... getch(); } int Funk_1(int x) { int aaa; aaa = 1111*x; return aaa; } float Funk_2(long x) //obszar definicji funkcji { float bbb; bbb = 0.00001*x; return bbb; } char Funk_3(float z) //obszar definicji funkcji { char bbb; bbb = 'a'; return bbb; }
przyklad 24
#include //przykład - funkcje #include //******************************************************************* int kukulka (int ile); main () { int m = 30; cout << "Zaczynamy" << endl; m = kukulka (2); cout << "\nNa koniec m = " << m; getch(); } //******************************************************************* int kukulka (int ile) { int i; for (i = 0; i < ile; i++) cout << "Ku-ku! "; return 66; }
void Prostokat () // definicja fun. rysujacej prostokat { int i, y; for (i = 1; i <= 20; i++) // krawędz górna cout << "*"; cout << endl;
for (i = 1; i <= 8; i++) // boki { y = wherey(); // funkcja okreslajaca wiersz na ekr. cout << "*"; gotoxy (20, y); cout << "*\n"; } for (i = 1; i <= 20; i++) // krawęz dolna cout << "*"; cout << endl; }
przyklad 29
//---------------------Program Prostokat wersja 2---------- // Program umożliwia narysowanie prostokata w trybie // tekstowym. Znakiem rysujacym jest gwiazdka '*'. // Dlugosc prostokata: 20; Wysokosc prostokata: 10 //---------------------------------------------------------------- #include #include void Prostokat (); //---------------------------------------------------------------- void main ( ) { Prostokat (); getch(); }
//Deklaracja dodatkowych funkcji używanych przez f. prostokat void Pozioma (); // deklaracja funkcj Pozioma void Boki (); // deklaracja funkcji Boki
void Prostokat () // definicja funkcji Prostokat { Pozioma (); Boki (); Pozioma (); } void Pozioma () // definicja funkcji Pozioma { int i; for (i = 1; i <= 20; i++) // rysowanie krawędzi poziomej cout << "*"; cout << endl; } void Boki () // definicja funkcji Boki { int i, y; for (i = 1; i <= 8; i++) // rysowanie funkcji prostokata { y = wherey(); cout << "*"; gotoxy (20, y); cout << "*\n"; } }
// Program umożliwia: // 1. Wczytanie aktualnego rozmiaru wektora liczb całk. // 2. Wczytanie elementów wektora liczb całkowitych; // 3. Okreslenie elementu maksymalnego oraz numeru // tego elementu; // 4. Wyswietlenie wartosci i numeru elementu maks. //--------------------------------------------------------- #include //tablice 1D #include const int n_Max = 50; // max rozmiar tablicy int X[n_Max]; // definicja tablicy int n, // aktualny rozmiar tablicy El_Max, // element maksymalny Ind_Max; // indeks elementu maks. //------poniżej podano inaczej niż we wcześniejszych przykładach od razu definicje funkcji void Czyt_Dane(int &n, int X[]) //przekazanie wart. przez ref. // Wczytanie rozmiaru i kolejnych elementów tablicy { int i; cout << "Podaj rozmiar tablicy: "; cin >> n; cout << "\nPodaj kolejne elementy tablicy:\n"; cout << endl; for (i = 0; i < n; i++) { cout << "X["; cout.width (2); cout << i << "] = "; cin >> X[i]; } } //--------------------------------------------------------- void Max_Element(int n, int X[], int &El_Max, int &Ind_Max) // Okreslenie elementu maksymalnego i jego indeksu { int i; El_Max = X[0]; Ind_Max = 0; for (i = 1; i < n; i++) { if (El_Max < X[i]) { El_Max = X[i]; Ind_Max = i; } } } void Pisz_Wynik (int El_Max, int Ind_Max) // Wyswietlenie wartosci i indeksu numeru elementu maks. { cout << "\nElement o wartosci maksymalnej: " << El_Max; cout << "\nNumer elementu maksymalnego: " << (Ind_Max +1); cout << endl; } //------------------------------------------------------ void main () { clrscr (); Czyt_Dane (n, X); Max_Element (n, X, El_Max, Ind_Max); Pisz_Wynik (El_Max, Ind_Max); getch(); }
przykład 32
//--------------------------------------------------------- // Program umożliwia: // 1. Wczytanie aktualnego rozmiaru tablicy liczb całk. // 2. Wczytanie elementów tablicy liczb całkowitych; // 3. Zamianę miejscami elementów tablicy leżacych // po przeciwnej stronie prostej pionowej dzielacej // tablicę na dwie równe częsci. // 4. Wyswietlenie wartosci i numeru elementu maks. //--------------------------------------------------------- #include //przykład dotyczacy tablic 2D #include const int n_Max = 10; // max liczba wierszy tablicy const int m_Max = 10; // max liczba kolumn tablicy int A[n_Max][m_Max]; // definicja tablicy int n, // aktualna liczba wierszy m; // aktualna liczba kolumn
void Czyt_Dane(int &n, int &m, int A[][m_Max]); //deklaracje funkcji void Przestawienie(int n, int m, int A[][m_Max]); void Pisz_Wynik (int n, int m, int A[][m_Max]); //--------------------------------------------------------- void main () { clrscr (); Czyt_Dane (n,m, A); Przestawienie(n, m, A); Pisz_Wynik (n, m, A); getch(); }
void Czyt_Dane(int &n, int &m, int A[][m_Max]) //--------------------------------------------------------- // Wczytanie rozmiaru i kolejnych elementów tablicy //--------------------------------------------------------- { int i, j, x,a, y; cout << "Podaj liczbę wierszy: "; cin >> n; cout << "Podaj liczbę kolumn: "; cin >> m; cout << "\nPodaj kolejne elementy tablicy:\n"; cout << endl; x = wherex (); y = wherey (); for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { gotoxy ( x+j*6, y); cin >> A[i][j]; } y++; } } //---------------------------------------------------------
void Przestawienie(int n, int m, int A[][m_Max]) //--------------------------------------------------------- // Zamiana miejscami elementów tablicy leżacych po // przeciwnych stronach prostej pionowej dzielacej // tablicę na dwie równe częsci //--------------------------------------------------------- { int i,j, pom;
for (i = 0; i < n; i++) for (j = 0; j < m/2; j++) { pom = A[i][j]; A[i][j] = A[i][m-j-1]; A[i][m-j-1] = pom; } }
void Pisz_Wynik (int n, int m, int A[][m_Max]) //---------------------------------------------------------- // Wyswietlenie tablicy wynikowej //---------------------------------------------------------- { int i, j, x, y;
cout << endl; cout << "Tablica wynikowa:\n"; cout << endl; x = wherex (); y = wherey (); for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { gotoxy ( x+j*6, y); cout << A[i][j]; } y++; cout << endl; } }
#include //p.35a dotyczyacy tablic i wskaźników #include void main () { int T_i[5]; // definicja tablicy typu int float T_f[5]; // definicja tablicy typu float int *Wsk_i; // definicja wska«nika na obiekty int float *Wsk_f; // definicja wska«nika na obiekty float
#include //p. 37 dotyczacy relacji na wskaznikach #include void main () { int Tab[10]; int *Wsk_a, *Wsk_b; int i; Wsk_a = &Tab[5]; cout << "Mamy 10-elementowa tablice Tab.\n" "Wskaznik Wsk_a pokazuje na element o indeksie 5.\n" "Na ktory element ma pokazywac wskaznik Wsk_b? (0-10): "; cin >> i; if (i < 0 || i > 10) cout << "\nNie ma takiego elementu w tej tablicy!"; else { Wsk_b = &Tab[i]; cout << "\nZ przeprowadzonego porownania wskaznikow" " Wsk_a i Wsk_b wynika, ¾e: \n"; if (Wsk_a > Wsk_b) cout << "Wsk_b pokazuje na element blizej poczatku tablicy\n"; else if (Wsk_a < Wsk_b) cout << "Wsk_b pokazuje na elem. o wyzszym indeksie\n"; else if (Wsk_a == Wsk_b) cout << "Wsk_a i Wsk_b pokazuja na to samo\n"; } }
Przykład 38
#include //p. 38 dotyczacy przesyłania (odbierania) tablic do (z) funkcji #include void Fun_Wska(int *Wsk, int Rozmiar); //dla tych 3 funkcji operacje wykonuje się void Fun_Tab(int Tab[ ], int Rozmiar); // na tym samym obszarze pamięci void Fun_Wsk2(int *Wsk, int Rozmiar); // ale robi się to w różny sposób void main () { int A[5] = { 5, 10, 15,20, 25 }; Fun_Tab(A, 5); // wskazujemy adres 1 elementu Fun_Wska(A, 5); Fun_Wsk2(A, 5); } void Fun_Tab(int Tab[ ], int Rozmiar) //adres odebrany jest jako tablica { cout << "\nWewnatrz funkcji Fun_Tab:\n"; for (int i = 0; i < Rozmiar; i++) cout << Tab[i] << "\t"; } //posługujemy się zapisem tablicowym //============= void Fun_Wska(int *Wsk, int Rozmiar) //przesłany adres inicjalizuje lokalny Wsk { cout << "\nWewnatrz funkcji Fun_Wska:\n"; //czyli jakby int *Wsk=A for (int i = 0; i < Rozmiar; i++) //lokalny wskaźnik wskazuje na kolejne cout << *(Wsk++) << "\t"; } //elementy //============ void Fun_Wsk2(int *Wsk, int Rozmiar) { cout << "\nWewnĄtrz funkcji Fun_Wsk2:\n"; //przesłany adres inicjalizuje lokalny Wsk for (int i = 0; i < Rozmiar; i++) //a potem używamy korzystając z notacji cout << Wsk[i] << "\t"; } //tablicowej wskaźnika
Przykład 39
#include //p. 39 wskazniki do obiektu const #include void Pokaz(const int *Wsk, int Ile); void Zmien(int *Wsk, int Ile); //========================== void main () { int Tab[5] = { 10, 20, 30, 40, 50 }; Pokaz(Tab, 5); Zmien(Tab, 5); Pokaz(Tab, 5); cout << "Dla potwierdzenia Tab[4] = " << Tab[4] << endl; } void Pokaz (const int *Wsk, int Ile) { cout << "Dziala pokazywacz:\n"; for (int i = 0; i < Ile; i++, Wsk++) { //*Wsk += 20; // Blad! Elementów tablicy nie wolno zmieniac! cout << "element nr " << i << " ma wartosc " << *Wsk << endl; //wskazujemy na kolejne drukowane elementy tablicy } } void Zmien (int *Wsk, int Ile) { cout << "Dziala zmieniacz:\n"; for (int i = 0; i < Ile; i++, Wsk++) { *Wsk += 500; // zmiana kolejnych wskazywanych wartości elementów tablicy cout << "element nr " << i << " ma wartosc " << *Wsk << endl; } }
Przykład 40
#include //p. 40 rezerwacja obszarów pamieci #include char *tworz (void); //funkcja zwraca adres do obiektu typu char void main () { char *w1, *w2, *w3, *w4; // definicje wskaznikow w1 = tworz (); // tworzenie wskaznikow na obiekt char w2 = tworz (); w3 = tworz (); w4 = tworz (); *w1 = 'A'; //nadanie wartosci zmiennej pod adresem w1 *w2 = 'B'; *w3 = 'C'; cout << "Oto 3 znaki: " << *w1 << *w2 << *w3 << "\noraz znak przypadkowy w czwartym: " << *w4 << endl; delete w1; //kasowanie obiektu delete w2;delete w3; delete w4; //*w1='x'; nie ma juz obiektu - bylby blad } char *tworz (void) //funkcja zwraca adres do obiektu typu char { char *w; cout << "Robie nowy obiekt typu char\n"; w = new char; //adres nowego obiektu return w; }
przyklad 41
#include //p. 41 tablice dynamiczne 1D #include void main () { //statycznie bylo: int tab[15]; //int *tab; //deklaracja wskaznika typu int //tab = new int [rozm]; //ustawienie wskaznika na poczatek obszaru // mozna tez krocej: int *tab = new int[rozm]; cout << "ile elementow ma miec tablica? \n"; int rozm; cin>> rozm; int *tab = new int[rozm]; //tab jest wskaz. na poczatek obszaru for (int i=0; i {tab[i]=i+1; //wpis elementów do tablicy } for (int i=0; i {cout<< "tab[" << i << " ]= " << tab[i] << endl; } delete [] tab; getch(); }
Przykład 42
#include //p. 42 tablice dynamiczne 2D #include int w,k; void utworz (int **tab); //deklaracja 3 funkcji, których argumentem jest void wyswietl (int **tab); //wskaźnik **tab do tablicy dwuwymiarowej (2D) void usun (int **tab); void main () {int **T; //** T - wskaźnik do tablicy 2D cout << "ile wierszy ma miec tablica? \n"; cin >> w; cout << "ile kolumn ma miec tablica? \n"; cin >> k; T = new int*[w]; // lub int **T = new int*[w]; for (int i=0; i T[i] = new int [k]; //krok 2 ustawienie adresu kolumn
for (int i = 0; i < w; i++) for (int j = 0; j < k; j++) T[i][j] = i + j; // inicjalizacja tab
wyswietl(T); usun(T); getch(); } void wyswietl(int **tab) { for (int i = 0; i < w; i++) { for (int j = 0; j < k; j++) cout << tab[i][j] << " "; cout << "\n" << endl; } } void usun(int **tab) { for (int i = 0; i < w; i++) delete[] tab[i]; // krok 1: usuniecie kolumn delete[] tab; // krok 2: usuniecie wierszy }
Przykład 43
#include //p. 43 praca na wskaźnikach do funkcji #include int Pierwsza (); //deklaracja dwóch funkcji int Druga (); // void main () { int i; int (*Wskaz_Fun) (); //deklaracja wskaźnika do funkcji // cout << "Na ktora funkcje ma pokazac wskaznik?\n" << "pierwsza-\t1\nczy druga -\t2\n" << "Napisz numer: "; cin >> i; switch (i) {case 1 : Wskaz_Fun = Pierwsza; //adres=adres break; case 2 : Wskaz_Fun = Druga; //adres=adres break; default : Wskaz_Fun = NULL; //nie wskazuj na żadną break; } cout << "Moj wybor:\n"; if (Wskaz_Fun) //jezli nie NULL for (i = 0; i < 3; i++) { (*Wskaz_Fun) (); } getch(); } int Pierwsza () //definicje funkcji { cout << "Funkcja pierwsza\n"; return 10; //zwraca 10 } int Druga () { cout << "Funkcja druga\n"; return 110; //zwraca 110 }
Przykład nr 44
//========================================================== /* Program oblicza wartości dwóch całek oznaczonych wykorzystując */ /* do obliczenia całki metodę Simpsona */ //========================================================== #include //przykład nr 44; argument funkcji jest funkcją #include #include
float Fun1 (float x); float Fun2 (float x); float Simpson ( float a, float b, int m, float f (float x)); //dekl. funkcji f
void main () // program główny { clrscr (); cout.width (6); cout.precision (2); cout << "Całka I1 = " << Simpson (-2.0, 3, 10, Fun1);//przekaz. f. przez adr. cout << "\nCałka I2 = " << Simpson (0, 1.0, 10, Fun2); getch(); } // koniec programu głównego; float Fun1 (float x) // Funkcja podcałkowa = 3*x*x { float wynik; wynik = 3*x*x; return ( wynik ); }
float Fun2 (float x) // Funkcja podcałkowa = sin(x*x) { float wynik; wynik = sin ( x*x); return (wynik); } float Simpson ( float a, float b, int m, float f(float x)) // Funkcja umożliwia obliczenie wartości całki oznaczonej // w granicach za pomocą metody Simpsona. // f jest funkcją podcałkową. Przedział został // podzielony na m jednakowych podprzedziałów, gdzie m // musi być liczbą parzystą. */ { float Sum_Parz, Sum_Nieparz, yk, h, wynik; int k; h = (b - a)/m; //dlugosc kroku calkowania Sum_Parz = 0; Sum_Nieparz = 0; for (k = 1; k <= m-1; k++) { yk = f(a + k*h); if (k%2 != 0) //jeśli reszta z dzielenia rozna od 0 (k nieparzyste) Sum_Nieparz = Sum_Nieparz + yk; else Sum_Parz = Sum_Parz + yk; } wynik = (f(a) + f(b) + 4*Sum_Nieparz + 2*Sum_Parz)*h/3; return (wynik); }
Przyklad nr 45
/*****************************************************************************************/ // Program oblicza wartości dwóch całek oznaczonych wykorzystując // // do obliczenia całki metodę Simpsona */ /*****************************************************************************************/ #include // dla cin, cout #include // dla clrscr #include // dla sin #include // dla exit
float Fun1 (float x); float Fun2 (float x); float Simpson ( float a, float b, int m, float f(float x));
void main () // program główny - przyklad nr 45 { float (*Tab_Wsk[2]) (float) = { Fun1, Fun2 };//dek. tabl. wskaź. do funkcji o arg. float int x, y, opcja; //zwracająca wartosc typu float cout.width (6); //polaczona ze wskazaniem na adresy cout.precision (2); //(nazwy) funkcji Fun1, Fun2 do { clrscr (); x = 30; y = 6; gotoxy (x, y); cout << "M E N U:\n"; y++; gotoxy (x,y); cout << "1. Calka z funkcji f(x) = 3*x*x\n"; y++; gotoxy (x,y); cout << "2. Calka z funkcji f(x) = sin(x*x)\n"; y++; gotoxy (x,y); cout << "3. Koniec\n"; y++; gotoxy (x+5,y++); cout << "Twoj wybor: "; y = wherey (); cin >> opcja; gotoxy (x+5, y+2); //cdn switch (opcja) { case 1 : { cout << "Calka I1 = "; cout << Simpson (-2.0, 3, 10, *Tab_Wsk[0]); break; } case 2 : { cout << "Calka I2 = "; cout << Simpson (0, 1.0, 10, *Tab_Wsk[1]); break; } case 3 : { cout << "Koniec programu"; exit;// (1); } default : break; } } while (opcja != 3); } // koniec programu glownego //cdn // koniec programu glownego //cdn float Fun1 (float x) // Funkcja podcałkowa = 3*x*x { float wynik; wynik = 3*x*x; return ( wynik ); }
float Fun2 (float x) // Funkcja podcałkowa = sin(x*x) { float wynik; wynik = sin ( x*x); return (wynik); } float Simpson ( float a, float b, int m, float f(float x)) /* Funkcja umożliwia obliczenie wartości całki oznaczonej */ /* w granicach za pomocą metody Simpsona. */ /* f jest funkcją podcałkową. Przedział został */ /* podzielony na m jednakowych podprzedziałów, gdzie m */ /* musi być liczbą parzystą. */ { float Sum_Parz, Sum_Nieparz, yk, h, wynik; int k; h = (b - a)/m; Sum_Parz = 0; Sum_Nieparz = 0; for (k = 1; k <= m-1; k++) { yk = f(a + k*h); if (k%2 != 0) Sum_Nieparz = Sum_Nieparz + yk; else Sum_Parz = Sum_Parz + yk; } wynik = (f(a) + f(b) + 4*Sum_Nieparz + 2*Sum_Parz)*h/3; return (wynik); }
Przykład 46
#include // p. 46 - struktury #include
struct Osoba //definicja typu strukturalnego Osoba { char *Nazwisko; char *Imie; int Wiek; }; Osoba Student; //dekl. obiektu Student typu Osoba void main ( ) { clrscr(); // Wartość zmiennej strukturalnej wyznaczamy poprzez // nadanie wartości poszczególnym jej składnikom. // Można to zrobić za pomocą instrukcji przypisania: Student.Nazwisko = "Kowalski"; Student.Imie = "Jan"; Student.Wiek = 20; cout << "Nazwisko: " << Student.Nazwisko << endl; cout << "Imie: " << Student.Imie << endl; cout << "Wiek: " << Student.Wiek << endl; // Można nadać wartości poszczególnym składnikom //zmiennej strukturalnej poprzez wczytanie z klawiatury:
struct Data // definicja typu strukturalnego Data { int Dzien, Miesiac, Rok; };
struct Osoba // definicja typu strukturalnego Osoba { char Nazwisko[30]; char Imie[20]; Data Data_Ur; // użycie wyżej zdef. struktury Data }; Osoba Pracownik; //dekl. obiektu Pracownik typu strukturalnego Osoba Osoba Dane[3];//dekl. tablicy Dane obiektow strukturalnych typu Osoba void main( ) { clrscr(); cout << "Wprowadzam dane do zmiennej strukturalnej " << " Pracownik: \n"; cout << "\nNazwisko: "; cin.width(sizeof(Pracownik.Nazwisko)); cin >> Pracownik.Nazwisko; cout << "Imie: "; cin.width(sizeof(Pracownik.Imie)); cin >> Pracownik.Imie; cout << "Data urodzenia: " << " \n\tDzien: "; cin >> Pracownik.Data_Ur.Dzien; cout << "\tMiesiac: "; cin >> Pracownik.Data_Ur.Miesiac; cout << "\tRok: "; cin >> Pracownik.Data_Ur.Rok; getch(); // cdn. clrscr(); cout << "Teraz wprowadzam dane do tablicy Dane dwa\n" << "elementy typu strukturalnego:\n"; int i; for (i=0; i < 2; i++) { cout << "\nNazwisko: "; cin.width(sizeof(Dane[i]. Nazwisko)); cin >> Dane[i].Nazwisko; cout << "Imie: "; cin.width(sizeof(Dane[i]. Imie)); cin >> Dane[i].Imie; cout << "Data urodzenia: " << " \n\tDzien: "; cin >> Dane[i].Data_Ur.Dzien; cout << "\tMiesiac: "; cin >> Dane[i].Data_Ur.Miesiac; cout << "\tRok: "; cin >> Dane[i].Data_Ur.Rok; } while (! kbhit()) { }; }
Przykład 49
#include //p.48 wskaznik do struktury #include struct Data { int Dzien, Miesiac, Rok; }; struct Osoba { char Nazwisko[30]; char Imie[20]; Data Data_Ur; }; Osoba Pracownik; //deklaracja obiektu strukturalnego Osoba Dane[3]; //deklaracja tablicy ob. strukt. Osoba *Wsk; //deklaracja wskaznika wskazującego na // na strukture Osoba cdn. void main() { cout << "Wprowadzam dane do zmiennej strukturalnej Pracownik:\ n"; Wsk = &Pracownik; // ustawiam wskaźnik na strukturze Pracownik cout << "\nNazwisko: "; cin.width(sizeof(Wsk->Nazwisko)); //dostęp do pola przez podanie //wskaznika, operatora -> , nazwy pola cin >> Wsk->Nazwisko; cout << "Imie: "; cin.width(sizeof(Wsk->Imie)); cin >> Wsk->Imie; cout << "Data urodzenia: " << "\n\tDzien: "; cin >> Wsk->Data_Ur. Dzien; cout << "\t Miesiac: "; cin >> Wsk->Data_Ur. Miesiac; cout << "\tRok: "; cin >> Wsk->Data_Ur. Rok; getch(); clrscr(); cout << "Teraz wprowadzam dane do tablicy Dane składającej się\ n" << "z dwóch elementów typu strukturalnego:\ n"; int i; Wsk = Dane; // ustawiam wskaźnika na początku tablicy struktur Dane for (i=0; i < 2; i++, Wsk++) //inkrem. Wsk celem wskazywania na elem. tablicy { cout << "\nNazwisko: "; cin.width(sizeof(Wsk->Nazwisko)); //dostęp do pola operatorem -> cin >> Wsk->Nazwisko; cout << "Imie: "; cin.width(sizeof(Wsk->Imie)); cin >> Wsk->Imie; cout << "Data urodzenia: " << "\n\tDzien: "; cin >> Wsk->Data_Ur.Dzien; cout << "\t Miesiac: "; cin >> Wsk->Data_Ur.Miesiac; cout << "\t Rok: "; cin >> Wsk->Data_Ur.Rok; } clrscr( ); cout << "Teraz wyświetlam zawartość zmiennej Pracownik:\ n"; Wsk = &Pracownik; // ustawiam wskaźnik na strukturze Pracownik cout << Wsk->Imie << " " << Wsk->Nazwisko << ", ur. " << Wsk->Data_Ur.Dzien << "." << Wsk->Data_Ur.Miesiac << "." << Wsk->Data_Ur.Rok << endl;
cout << "\nTeraz wyświetlam zawartość tablicy Dane:\n"; Wsk = Dane; //ustawiam wskaźnika na początku tablicy struktur Dane for (i=0; i < 2; i++,Wsk++) //inkrem. Wsk celem wskazywania na elem. tablicy { cout << Wsk->Imie << " " << Wsk->Nazwisko << ", ur. " << Wsk->Data_Ur.Dzien << "." << Wsk->Data_Ur.Miesiac << "." << Wsk->Data_Ur.Rok << endl; }
while (!kbhit()) { }; }
Przykład 50
#include //p.50 przeładowanie funkcji #include void wypisz(int liczba); void wypisz(char znak, float a, char *text); void wypisz(int liczba, char znak); void wypisz(char znak, int liczba);
main() { wypisz(2345); wypisz('A', 33.33, " Programowanko w C++ "); wypisz(111111,'B'); wypisz('X', 222222); getch(); } // definicje funkcji void wypisz(int liczba) { cout<<"liczba typu int = "<void wypisz(char znak, float a, char *text) {cout<<"Znak ="< pisz ('y', 2.34, 'x'); pisz ('a', 88); getch(); } void pisz (int L) {cout << L << " dziesietnie = " << hex << L << " szesnastkowo" << endl; } void pisz (int L, char Z) { cout << Z << "). " << dec << L << endl; } void pisz (char Z, int L, char *T) { cout << T << Z << " wynosi " << L << endl; } void pisz (char Z1, float L, char Z2) { cout << Z1 << " = " << L << Z2 << endl; } void pisz (char Z, int L) { cout << L << Z << endl; }
Przykład 52
#include //p. 52 - klasy #include #include //------------------------ definicja klasy ------------------ class Osoba { char Nazwisko [50]; int Wiek; public: void Czyt_Dane(char *Napis, int Wiek); //------------------------------------ void Pisz_Dane () { cout << "\t" << Nazwisko << " , lat - " << Wiek << endl; } }; //---------------------- koniec definicji klasy ------------ void Osoba::Czyt_Dane (char *Napis, int L) { strcpy (Nazwisko, Napis); Wiek = L; } //---------------------------------------------------------
void main () { Osoba Student1, Student2, Asystent, Profesor; clrscr (); cout << "Dla informacji podaję, że jeden obiekt klasy Osoba\n" << " ma rozmiar: " << sizeof(Osoba) << " bajty. To samo inaczej: " << sizeof(Student1) << endl; Student1.Czyt_Dane("Kowalski Jan", 20); Student2.Czyt_Dane("Sikorski Piotr", 23); Asystent.Czyt_Dane("Michalski Tomasz", 28); Profesor.Czyt_Dane("Nowak Andrzej", 42); cout << "\nSprawdzamy wpisaną informację do obiektów.\n";
cout << "\ndane z obiektu Profesor: \n"; Profesor.Pisz_Dane();
cout << "\ndane z obiektu Asystent: \n"; Asystent.Pisz_Dane();
cout << "\ndane z obiektu Student1: \n"; Student1.Pisz_Dane();
cout << "\ndane z obiektu Student2: \n"; Student2.Pisz_Dane();
cout << "\nPodaj nazwisko trzeciego studenta: "; char Student[50]; cin >> Student;
cout << "Podaj wiek studenta: "; int Ile_Lat; cin >> Ile_Lat;
Student1.Czyt_Dane(Student, Ile_Lat);
cout << "\nOto dane, które teraz są zapamiętane w obiektach" << "\nStudent1 i Student2:\n";
Student1.Pisz_Dane(); Student2.Pisz_Dane(); while (!kbhit()) { } }
Przyklad 53
#include //p.53 - klasy przysłanianie zmiennych #include int Balkon = 50; void Spiew (); //------------------------- definicja klasy Opera --------------- class Opera { public: int n; float Balkon; void Funkcja(); void Spiew() { cout << "funkcja Spiew (z Opery): tra-la-la!\n"; } }; //--------------------- koniec definicji klasy Opera ------------ void Opera::Funkcja() { cout << "Balkon (skladnik klasy Opera) = " << Balkon << endl; cout << "Balkon (zmienna globalna) = " << ::Balkon << endl; //----- definicja zmiennej lokalnej dla danej funkcji -------- char Balkon = 'A'; cout << "\nPo definicji zmiennej lokalnej:\n"; cout << "Balkon (zmienna lokalna) = " << Balkon << endl; cout << "Balkon (skladnik klasy Opera) = " << Opera::Balkon << endl; cout << "Balkon (zmienna globalna) = " << ::Balkon << endl; //----- wywołanie funkcji Spiew ----------------------------- Spiew (); int Spiew; Spiew = 10; // Spiew (); // błąd w trakcie kompilacji // bo nazwa funkcji Spiew jest zasłonięta cout << "Po zaslonieciu funkcje Spiew mozna wywolac " << "tylko w taki sposob - Opera::Spiew\n"; Opera::Spiew(); } //**************************************************************
void main () { Opera Halka; clrscr(); Halka.Balkon = 2; Halka.Funkcja(); Spiew(); while (!kbhit()) { } } //************************************************************* void Spiew() { cout << "zwykła funkcja Spiew (nie ma nic wspolnego " << "z klasa Opera)\n"; }
Przykład nr 54
#include //p.54 klasy - konstruktor #include #include //--------------- definicja klasy Numer ------------------------ class Numer { int Liczba; char Nazwa[40]; public: //----- funkcje składowe ------ Numer (int L, char *Opis); // deklaracja konstruktora void Schowaj(int L) { Liczba = L; Melduj(); } int Zwracaj() { return Liczba; } void Melduj() { cout << Nazwa << Liczba << endl; } }; //-------------- koniec definicji klasy Numer -----------------
Numer::Numer(int L, char *Opis) { Liczba = L; strcpy(Nazwa, Opis); } //************************************************************* void main () { Numer Samolot (1200, "Biezaca wysokosc: "); Numer Atmosfera(920, "Cisnienie atmosferyczne: "), Kurs(63, "Kierunek lotu: "); //---- wstępny raport ------------------- clrscr(); Samolot.Melduj(); Kurs.Melduj(); Atmosfera.Melduj(); cout << "\nKorekta lotu:\n"; //---- wzrost wysokości o 1 m ------------ Samolot.Schowaj(1201); //---- zmiana kursu o 3 stopnie ---------- Kurs.Schowaj(Kurs.Zwracaj()+3); //---- zmniejszenie ciśnienia o 2 hPa --- Atmosfera.Schowaj(Atmosfera.Zwracaj()-2); while (!kbhit()) { } }
Przykład 55
#include //p. 55, klasy konstruktor, destruktor #include #include //------- definicja klasy Gadula ------------------------------- class Gadula { int Licz; char Tekst[40]; public:
// konstruktor: Gadula(int k, char *Opis);
// destruktor: ~Gadula(void);
// inne funkcje składowe: int Zwracaj() { return Licz; } void Schowaj(int x) { Licz = x; } void CoTo() { cout << Tekst << " ma wartosc: " << Licz << endl; } }; //------- koniec definicji klasy Gadula ----------------------- Gadula::Gadula(int k, char *Opis) // konstruktor { strcpy(Tekst, Opis); Licz = k; cout << "Konstruuje " << Tekst << endl; } Gadula::~Gadula() // destruktor { cout << "Pracuje destruktor (sprzata) " << Tekst << endl; } //************************************************************ Gadula a(1, "obiekt a (GLOBALNY)" ); //globalna def. obiektow a,b //połączona z wyw. konstrukta Gadula b(2, "obiekt b (GLOBALNY)" ); //************************************************************
void main() { clrscr(); a.CoTo(); //obiekty a,b istnieją; wywołanie f. składowej na rzecz ob. a, b b.CoTo(); { cout << "Poczatek lokalnego zakresu:\n";//klamry początek zasięgu lokalnego Gadula c(30, "obiekt c (lokalny)" ); // dekl. ob. c,a + konstruktor Gadula a(40, "obiekt a (lokalny)" ); // zasłania globalny cout << "\nCo teraz mamy: \n"; a.CoTo(); b.CoTo(); c.CoTo(); cout << "Do zaslonietego obiektu globalnego mozna sie jednak dostac\n"; ::a.CoTo(); cout << "Konczy się lokalny zakres\n"; } // klamry koniec zasięgu lokalnego; automatycznie wyw. jest destruktor ob. c,a cout << "Juz jestem poza blokiem\n"; a.CoTo(); b.CoTo(); cout << "Uruchamiam destruktor obiektu a\n"; a.Gadula::~Gadula(); // jawne wywołanie destruktora cout << "K o n i e c p r o g r a m u\n"; while (!kbhit()) { } } // automatyczne wywołanie destruktora do obiektow a,b
Przykład 56
#include // p.56, Dziedziczenie class ryba { // klasa podstawowa private : int a ; protected: int prots ; public: int pubs ; void wstaw(int m ) { a = m ; } int czytaj() { return a ; } }; class rekin : public ryba { // klasa pochodna float x ; public : void funk(); } ; void rekin::funk() { x = 15.6 ; // x - składnik prywatny klasy rekin //a = 6 ; // a - składnik niedostępny wstaw(6) ; //funkcja puliczna wstaw(6) nada wartość zmiennej a cout << "\n wyjety funkcja 'czytaj' skladnik a=" << czytaj() ; //wywołanie funkcji publicznej czytaj klasy ryba druk a prots = 77 ; //do składników protected mamy dostęp pubs = 100 ; cout << "\n bezposr. odczytany skladnik protected = "<< prots << "\n bezposr. odczytany skladnik public = " << pubs ; } main() { rekin wacek ; wacek.funk() ; }
Przykład 57
#include //p. 57 Dziedziczenie - bez funkcji wirtualnych class ryba { // klasa podstawowa (bazowej) private : int a ; public: void wstaw(int m ) { a = m ; } }; // koniec klasy podstawowej class rekin : public ryba { // klasa pochodna od klasy ryba int x ; public : void wstaw(int m ) { x = m+5 ; } } ; // koniec klasy pochodnej main() { ryba karp; //dekl, obiektu kl. typu ryba (typ bazowy) rekin ludojad ; //dekl. obiektu kl. typu rekin (typ pocodny)
karp.wstaw(6); // pracuje funkcja z kl. ryba ludojad.wstaw(6); // pracuje funkcja z kl. rekin // ponizej składnia poprawna przy dziedziczeniu ryba *wsk1=&ludojad; //wskaznik na kl. ryby wskazujący na ob.kl rekin wsk1->wstaw(6) ; //zle: pracuje funkcja z kl. ryby
rekin *wsk2=&ludojad; //wskaznik na kl. ryby wskazujÄ…cy na ob.kl rekin wsk2->wstaw(6) ; //pracuje funkcja z kl. rekin
ryba *wsk3=&karp; //wskaznik na kl. ryby wskazujący na ob.kl ryby wsk3->wstaw(6) ; //pracuje funkcja z kl. ryby } //wniosek funkcje nie przesłaniają się tak jak się spodziewaliśmy
Przykład 58
#include //p. 58 Dziedziczenie - funkcje wirtualne l class ryba { // klasa podstawowa (bazowej) private : int a ; public: void virtual wstaw(int m ) { a = m ; } }; // koniec klasy podstawowej class rekin : public ryba { // klasa pochodna od klasy ryba int x ; public : void wstaw(int m ) { x = m+5 ; } } ; // koniec klasy pochodnej main() { ryba karp; //dekl, obiektu kl. typu ryba (typ bazowy) rekin ludojad ; //dekl. obiektu kl. typu rekin (typ pocodny) karp.wstaw(6); // pracuje funkcja z kl. ryba ludojad.wstaw(6); // pracuje funkcja z kl. rekin // ponizej składnia poprawna przy dziedziczeniu ryba *wsk1=&ludojad; //wskaznik na ob. typu ryba i ob. pochodne (+inicjajcja) wsk1->wstaw(6) ; //wsk1 jest typu ryba gdyby nie było slowa virual, to uzyta //zostalaby funkcja z ryby; a tak kompilator wybierze funkcje z kl. rekin (bo ludojad jest //typu rekin rekin *wsk2=&ludojad; //wskaznik na kl. ryby wskazujący na ob.kl rekin wsk2->wstaw(6) ; //pracuje funkcja z kl. rekin
ryba *wsk3=&karp; //wskaznik na kl. ryby wskazujący na ob.kl ryby wsk3->wstaw(6) ; //pracuje funkcja z kl. ryby } //Jeśli użyte jest slowo virtual to funkcje składowe wybierane są z odpowiednich obiektów
Przykład 59
#include //p. 59 - funkcje wirtualne - polimorfizm class instrument { //klasa bazowa int cena ; public: void virtual wydaj_dzwiek() { cout << " Nieokreslony brzdek !\n" ; } //... }; class trabka : public instrument { //klasa pochodna public: void wydaj_dzwiek() { cout << " Tra-ta-ta !\n" ; } // ... }; class beben : public instrument { //klasa pochodna public: void wydaj_dzwiek() { cout << " Bum-bum-bum !\n" ; } // ... }; class fortepian : public instrument { //klasa pochodna public: void wydaj_dzwiek() { cout << " Pilm-plim-plim !\n" ; } // ... };
/*******************************************************/ void muzyk(instrument & powierzony_instrument) ; //deklaracja funkcji globalnej
class skrzypce : public instrum { // char *nazwa ; public : skrzypce(char *firma) // - konstruktor------------------------ { nazwa = new char[strlen(firma) + 1] ; // - operatorem new inic lancuch strcpy(nazwa, firma) ; }
~skrzypce() //- destruktor (wirtualny) ----------------- { cout << "Destruktor skrzypiec + " ; delete nazwa ; } // - operatorem deleteusuwany jest łańcuch void wydaj_dzwiek() { cout << "tirli-tirli (" << nazwa << ")\n" ; } } ; class gwizdek : public instrum { // public : void wydaj_dzwiek() { cout << "fiu-fiu \n" ; } } ;
class gitara : public instrum { char *nazwa ; public : gitara(char *firma) // - konstruktor------------------- { nazwa = new char[strlen(firma) + 1] ; // strcpy(nazwa, firma) ; } ~gitara() //- destruktor (wirtualny) --------------- { cout << "Destruktor gitary + " ; delete nazwa ; //usunięcie łańcucha nazwa } // -------------------------- void wydaj_dzwiek() { cout << "brzdek-brzdek (" << nazwa << ")\n" ; } } ;
main() { cout << "Definiujemy w zapasie pamieci\n" "trzy instrumenty orkiestry\n " ; // obiekt pierwszy wskaźnik (3 tego samego typu); konstruktor new + inicjacja instrum *pierwszy = new skrzypce("Stradivarius") ; instrum *drugi = new gitara("Ramirez") ; instrum *trzeci = new gwizdek ; //
cout << "Gramy polimorficznie ! \n" ;
pierwszy->wydaj_dzwiek() ; // drugi ->wydaj_dzwiek() ; trzeci ->wydaj_dzwiek() ;
cout << "\nKoncert sie skonczyl, likwidujemy instrumenty\n\n" ;
delete pierwszy ; // cout << "******************\n" ; delete drugi ; cout << "******************\n" ; delete trzeci ; }//Wniosek przez zdef. wirtualnych destruktorów, niszczone sa obiekty // wskazywane wskaźnikamj