Języki programowania
Wykład 1
Język programowania – sztuczny język składający się ze skończonego zbioru reguł zwanych składnią. Służy do przygotowywania poleceń dla komputera
Programowanie – umiejętność pisania programów i umiejętność rozwiązywania problemów
Program komputerowy – zbiór ułożonych w odpowiedniej kolejności rozkazów, z których każdy reprezentuje elementarną operację.
Większość programów powstaje w formie kodu źródłowego utworzonego za pomocą edytora plików tekstowych. Kod źródłowy jest następnie interpretowany lub kompilowany na język maszynowy faktycznie wykonywane przez komputer.
Definiując dowolny język programowania należy podać:
Zbiór dopuszczalnych znaków
Reguły tworzenia poprawnych zdań
Reguły interpretujące znaczenie poszczególnych słów
Przykłady języków programowania:
Język maszynowy, asembler, Fortran, C, C++, C#, Pascal, Java, PHP
Poziom języka:
Języki wysokiego poziomu (BASIC, C, Pascal, C#)
Języki niskiego poziomu (asembler, język maszynowy)
Języki niskiego poziomu:
Najbardziej efektywne
Trzeba znać architekturę systemu komputerowego oraz działanie mikroprocesora
Bardzo czasochłonne
Język maszynowy:
Ciąg zer i jedynek
Można heksadecymalnie upraszczać (76 z 0111 0110)
Asembler:
Każdy procesor ma swój własny język asembler
Jeden rozkaz w asemblerze odpowiada jeden rozkaz w języku maszynowym
Mnemonik – rozkaz w asemblerze (zastąpienie binarnego)
Tłumacz (translator) to też asembler
Trudne
Pełne wykorzystanie możliwości komputera
Wykonywane bardzo szybko i zajmują mało miejsca w pamięci
Języki wysokiego poziomu:
Przypominają język naturalny (słowa i składnia)
Każdemu poleceniu w j. wysokiego poziomu odpowiada ciąg poleceń w j. maszynowym
Tłumaczenie dokonuje się podczas procesu kompilacji
Kompilacja – tłumaczenie na j. maszynowy za pomocą programu tłumaczącego (kompilatora)
Zajmują więcej miejsca i wykonuje się wolniej
Przykładowy rozkaz w asemblerze:
EB03 JHP SHORT NEXT
EB – z heksadecymalnego kod operacji
03 – przesunięcie o 3 kroki
JHP – mnemonik
SHORT NEXT – argument
Rodzaje języków programowania:
Proceduralne (C, Pascal, Fortran) – zapisuje się procedury, które wykonuje komputer
Deklaratywne (COBOL, PROLOG, LISP, SQL) – wyszukuje danych w oparciu o pytania
Obiektowe – tworzysz interfejs bardzo łatwo, gotowe obiekty
Procedura – moduł programu wykonujący określone zadanie (program mogący działać samodzielnie)
przyklad 1
#include <iostream.h> //przykład 1
#include <conio.h>
#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 <iostream.h>
#include <conio.h>
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 <iostream.h>
#include <conio.h>
#include <math.h>
#pragma hdrstop;
main()
{
float x,f;
clrscr ();
cout << "Podaj wartosć x:";
cin >> x;
if (x<=0) f=2*pow(x,2)+2; else f=log(x);
cout << "\nDla x=";
cout.width(4);
cout.precision(1);
cout << x << " funkcja f(x)=";
cout.width(5);
cout.precision(1);
cout << f;
getch();
}
przyklad 4
/*-----przyklad 2 na if ---------------------------------------------------------------*/
/* Program oblicza stopień na podstawie liczby otrzymanych */
/* punktów . Kryteria: */
/* 0.. 49 pkt. - 2 */
/* 50.. 59 pkt. - 3 */
/* 60.. 69 pkt. - 3.5 */
/* 70.. 79 pkt. - 4 */
/* 80.. 89 pkt. - 4.5 */
/* 90..100 pkt. - 5 */
/*--------------------------------------------------------------------------------*/
#include <iostream.h>
#include <conio.h>
main ()
{
int lp;
float stopien;
clrscr ();
cout << "Podaj liczbę punktów (0 <= lp <= 100): ";
cin >> lp;
if (lp <= 49) stopien = 2;
else if (lp <= 59) stopien = 3;
else if (lp <= 69) stopien = 3.5;
else if (lp <= 79) stopien = 4;
else if (lp <= 89) stopien = 4.5;
else stopien = 5;
cout << "Twoja ocena: ";
cout.width(3);
cout.precision(1);
cout << stopien << endl;
getch();
}
przyklad 5
//Testowanie instrukcji while
#include <iostream.h>
#include <conio.h>
main()
{
int a,b;
cout <<"Podaj a: "; cin>>a;
b=0;
while (a<10)
{
a=a+1;
b=b+1;
}
cout <<"a= " << a << endl;
cout << "Liczba powtorzen= "; cout << b;
getch();
}
przyklad 6
#include <iostream.h> //test instrukcji do...while
#include <conio.h>
main()
{ int a,b;
cout <<"Podaj a: "; cin>>a;
b=0;
do {
a=a+1;
b=b+1;
}
while (a<10);
cout <<"a= " << a << endl;
cout << "Liczba powtorzen= "; cout <<b;
getch();
}
przyklad 7
/*--------------------------------------------------------------------------------*/
/* Program umożliwia obliczenie silni z N (0<=N<8) */
/*--------------------------------------------------------------------------------*/
#include <iostream.h> //test pętli for
#include <conio.h>
main ()
{
int i, N, Silnia;
clrscr ();
cout << "Podaj N, (0 <= N <= 7): "; cin >> N;
Silnia = 1;
if (N >= 2)
for (i=2; i <= N; i=i + 1)
Silnia = Silnia*i;
cout << endl;
cout << "Silnia z " << N << " równa się: " << Silnia << endl;
getch();
}
przyklad 7
/*-----przykład instrukcji switch ---------------------------------*/
/* Program oblicza stopień na podstawie liczby otrzymanych */
/* punktów. Kryteria: */
/* 0.. 49 pkt. - 2 */
/* 50.. 59 pkt. - 3 */
/* 60.. 69 pkt. - 3.5 */
/* 70.. 79 pkt. - 4 */
/* 80.. 89 pkt. - 4.5 */
/* 90..100 pkt. - 5 */
/*-------------------------------------------------------------------------*/
#include <iostream.h>
#include <conio.h>
main ()
{
int lp;
float stopien;
clrscr ();
cout << "Podaj liczbę punktów (0 <= lp <= 100): "; cin >> lp;
lp = lp/10; //dzielenie bez reszty
switch (lp)
{
case 5 : { stopien = 3; break;}
case 6 : { stopien = 3.5; break;}
case 7 : { stopien = 4; break;}
case 8 : { stopien = 4.5; break;}
case 9,10 : { stopien = 5; break;}
default : { stopien = 2; break;}
}
cout << "Twoja ocena: ";
cout.width(3); cout.precision(1); //format wydruku
cout << stopien << endl;
getch();
}
przyklad 8
#include <iostream.h> //test instrukcji break
#include <conio.h>
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 <iostream.h> //przyklad instrukcji break
#include <conio.h>
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 <iostream.h> //goto
#include <conio.h>
main ()
{
cout << "Ala ma kota \n";
goto a; // brak deklaracji etykiety
cout << "Ola ma psa";
a:
cout << "Ela ma papugę";
getch();
}
przyklad 11
#include <iostream.h> //testowanie continue
#include <conio.h>
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 <iostream.h> // liczby ósemkowe i szesnastkowe
#include <conio.h>
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();
}
przyklad 13
#include <iostream.h> //znaki sterujace i specjalne
#include <conio.h>
main()
{
cout << '\\' << '\a' << '\a' << "\nTo był dzwiek";
getch();
}
przyklad 14
// Przykład: Zasłanianie nazw
#include <iostream.h>
#include <conio.h>
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 <iostream.h> // operatora zakresu ::
#include <conio.h>
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();
}
przyklad 16
#include <iostream.h> //typ wyliczeniowy enum
#include <conio.h>
main()
{
enum dni_tyg {pn, wt, sr, czw, pt, sob, nd};
dni_tyg dzien; // dni_tyg - nowy typ
dzien=pn;
dzien=wt;
dzien=sr;
getch();
}
przyklad 17
#include <iostream.h> //operatory arytmetyczne
#include <conio.h>
main()
{
int a=7, b=2;
cout << "a/b= " << a/b << endl;
cout << "a%b= " << a%b << endl;
getch();
}
przyklad 18
#include <iostream.h> //przykład oper. % - modulo
#include <conio.h>
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();
}
przyklad 19
#include <iostream.h> //++i, i++
#include <conio.h>
void main()
{ int i=10, j=10;
clrscr();
cout << "i = " << i << endl
<< "j = " << j << endl << endl;
i++; ++j;
cout << "i = " << i << endl
<< "j = " << j << endl << endl;
cout << "i = " << i++ << endl
<< "j = " << ++j << endl << endl;
cout << "i = " << i << endl
<< "j = " << j << endl;
getch();
}
przyklad 20
#include <iostream.h> //wyrażenie. warunkowe
#include <conio.h>
main ()
{
int i;
i=4;
cout << ((i>5)? 15: 20) << endl;
i=6;
cout << ((i>5)? 15: 20) << endl;
getch();
}
przyklad 21
#include <iostream.h> //sizeof()
#include <conio.h>
main ()
{
int mm;
clrscr ();
cout << "Godzina prawdy. W tym komputerze "
<< "poszczegolne typy\n"
<< "maja nastepujace rozmiary w bajtach: \n";
cout <<"typ char: \t" << sizeof(char) << endl;
cout <<"typ int: \t" << sizeof(int) << endl;
cout <<"typ short: \t " << sizeof(short) << endl;
cout <<"typ long: \t" << sizeof(long) << endl;
cout <<"typ float: \t " << sizeof(float) << endl;
cout <<"typ double: \t " << sizeof(double) << endl;
cout <<"typ long double: \t" << sizeof(long double) << endl;
cout << "Nasz obiekt lokalny mm ma rozmiar: "
<< sizeof(mm) << endl;
getch();
}
przyklad 22
#include <conio.h>
#include <iostream.h>
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 <<endl;
getch();
}
przyklad 23
#include <iostream.h>
#include <conio.h>
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 <iostream.h> //przykład - funkcje
#include <conio.h>
//*******************************************************************
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;
}
przyklad 25
#include <iostream.h> //funkcje
#include <conio.h>
#include <math.h>
float F(float x, float y);
//--------------------------------------
void main()
{
float a, b, c, p, q, r;
clrscr();
cout << "a = "; cin >> a;
cout << "b = "; cin >> b;
cout << "c = "; cin >> c;
p = F(a, b);
q = (a + b)*c + 0.34*F(a+p, a-p);
r = log(1 + F(1, p)) + a*b*c;
cout.width(10); //
cout.precision(2);
cout << "\np = " << p << "\nq = " << q;
cout << "\nr = " << r;
}
//--------------------------------------
float F(float x, float y)
{
return pow(x*x + y*y, 1./3);
}
przyklad 26
#include <iostream.h> //przesył. arg. przez
#include <conio.h> //wartosć
void Zamiana(int, int);
//--------------------------
void main()
{
int a, b;
clrscr();
cout << "a = "; cin >> a;
cout << "b = "; cin >> b;
Zamiana (a, b);
cout << "\nTeraz:\n";
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << endl;
}
//-- przesyłanie argumentów przez wartosć!!!
void Zamiana(int x, int y)
{
int z;
cout << "\nPrzed zamiana:\n";
cout << "x = " << x << endl;
cout << "y = " << y << endl;
z = x;
x = y;
y = z;
cout << "\nPo zamianie:\n";
cout << "x = " << x << endl;
cout << "y = " << y << endl;
}
przyklad 27
#include <iostream.h> //przesyłanie arg. //Przez referencje
#include <conio.h>
void Zamiana(int &, int &);
//--------------------------------
void main()
{
int a, b;
clrscr();
cout << "a = "; cin >> a;
cout << "b = "; cin >> b;
Zamiana (a, b);
cout << "\nTeraz:\n";
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << endl;
getch();
}
// przesyłanie argumentów przez referencję
void Zamiana(int &x, int &y)
{
int z;
cout << "\nPrzed zamiana:\n";
cout << "x = " << x << endl;
cout << "y = " << y << endl;
z = x;
x = y;
y = z;
cout << "\nPo zamianie:\n";
cout << "x = " << x << endl;
cout << "y = " << y << endl;
}
przyklad 28
//---------------------Program Prostokat wersja 1----------
// Program umożliwia narysowanie prostokata w trybie
// tekstowym. Znakiem rysujacym jest gwiazdka '*'.
// Dlugosc prostokata: 20
// Wysokosc prostokata: 10
//----------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
void Prostokat ();
//----------------------------------------------------------------
void main ( )
{
Prostokat ();
getch();
}
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 <iostream.h>
#include <conio.h>
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";
}
}
przyklad 30
#include <iostream.h> //tablice znakowe
#include <conio.h>
void main ()
{
char napis1[ ] = { "Nocny lot" };
char napis2[ ] = { 'N', 'o', 'c', 'n', 'y',
' ', 'l', 'o', 't' };
clrscr ();
cout << "rozmiar tablicy pierwszej: "
<< sizeof(napis1) << endl;
cout << "rozmiar tablicy drugiej: "
<< sizeof(napis2) << endl;
getch();
}
przykład 31
// 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 <iostream.h> //tablice 1D
#include <conio.h>
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 wczeniejszych 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 <iostream.h> //przykład dotyczacy tablic 2D
#include <conio.h>
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;
}
}
//--------------------------------------------------------
Poniżej przykłady dotyczšce wskaników
//=================================================================
przyklad 33
#include <iostream.h> //przyklad dotyczacy wskaznikow
#include <conio.h>
void main ()
{
int y = 8,
x = 4;
int *w; //definicja wskaŸnika do obiektów typu int
clrscr ();
w = &x; // ustawienie wskaŸnika na x
cout << "x = " << x
<< "\n a odczytana przez wskaŸnik = "
<< * w << endl;
x = 10;
cout << "x = " << x
<< "\n a odczytana przez wskaŸnik = "
<< * w << endl;
* w = 200;
cout << " x = " << x
<< "\n a odczytana przez wskaŸnik = "
<< * w << endl;
w = &y;
cout << "x = " << x
<< "\n a odczytana przez wskaŸnik = "
<< * w << endl;
getch();
}
przyklad 34
#include <conio.h> // wskaznik a referencja
#include <iostream.h>
void main ()
{
int a = 1;
int *Adr; //def. wskaŸnika
int &r_a = a; //referencja - przezwisko
Adr = &a; //ustaw wskaŸnik na obiekt a
cout << *Adr << endl; //obiekt wskazany wskaŸ.
cout << &r_a << endl; //adres obiektu r_a
cout << &a << endl; //adres obiektu a
cout << Adr << endl; //wskanik (adres) ob. a
cout << a << endl; //obiekt a
cout << r_a << endl; //obiekt r_a
r_a = 2;
Adr = &r_a; //ustaw wskanik na ob. r_a
cout << Adr << endl;// adres r_a
cout << *Adr << endl;//wartoć r_a
getch();
}
===================================================
przyklad 35a
#include <iostream.h> //p.35a dotyczyacy tablic i wskaŸników
#include <conio.h>
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
clrscr ();
Wsk_i = &T_i[0]; // inaczej Wsk_i = T_i
Wsk_f = &T_f[0]; // inaczej Wsk_f = T_f
cout << "Oto jak przy incrementacji wskaŤnik˘w\n"
<< "zmieniajĽ siŠ ukryte w nich adresy: \n";
for (int i = 0; i < 5; i++, Wsk_i++, Wsk_f++)
{
cout << "i = " << i
<< ", Wsk_i = " << (unsigned long) Wsk_i
<< ", Wsk_f = " << (unsigned long) Wsk_f << endl;
}
}
Przyklad 35b
#include <iostream.h>//p. 35b dotyczacy operacji na wskaznikach
#include <conio.h>
void main ()
{ int *Wsk_i;
float *Wsk_f;
int x,y,i; // x,y wspol. kursora, i zm. pom.
int Tab_i[10] = { 0,1,2,3,4,5,6,7,8,9 };
float Tab_f[10];
clrscr ();
Wsk_f = &Tab_f[0];
for (int i = 0; i < 10; i++) // tworzenie tablicy Tab_f
{ *(Wsk_f++) = i/10.0; //nadanie wartosci elem. tablicy
}
cout << "Zawartosc tablic na poczatku:\n";
y = wherey ();
for (i = 0, Wsk_i = Tab_i, Wsk_f = Tab_f; i< 10; i++)
{ x = 1;
cout << "Tab_i[" << i << "] = " << *Wsk_i; //doste do elementów tabl. za pomocš wskaŸnika
gotoxy (x+20, y);
cout << "Tab_f[" << i << "] = " << *Wsk_f << endl;
y = wherey ();
Wsk_i++;
Wsk_f++;
}
Wsk_i = &Tab_i[5]; // wskazanie na 6 element (o nr 5)
Wsk_f = Tab_f + 2; // wskazanie na 3 element
for (i = 0; i < 4; i++) // wpisanie do tablic kilku wartosci
{ *(Wsk_i++) = 55; // wpis elem. Tab_i[5] itd.
*(Wsk_f++) = 11; // wpis elem. Tab_f[2] itd.
}
cout << "\nTresc tablic po wstawieniu nowych wartosci:\n";
Wsk_i = Tab_i; //wskaznik na poczatek tablicy
Wsk_f = Tab_f;
y = wherey ();
for (i = 0; i < 10; i++)
{ x = 1;
cout << "Tab_i[" << i << "] = " << *(Wsk_i++);
gotoxy (x+20, y);
cout << "Tab_f[" << i << "] = " << *(Wsk_f++) << endl;
y = wherey ();
}
getch();
}
Przykład 36
#include <iostream.h> //p. 36 dotyczacy operacji na wskaznikach
#include <conio.h>
void main ()
{
int Tab[15];
int *Wsk_a, *Wsk_b, *Wsk_c;
clrscr ();
Wsk_a = &Tab[5];
Wsk_b = &Tab[10];
Wsk_c = &Tab[11];
cout << "(Wsk_b - Wsk_a) = " << (Wsk_b - Wsk_a)
<< "\n(Wsk_c - Wsk_b) = " << (Wsk_c - Wsk_b)
<< "\n(Wsk_a - Wsk_c) = " << (Wsk_a - Wsk_c)
<< "\n(Wsk_c - Wsk_a) = " << (Wsk_c - Wsk_a);
}
Przyklad 37
#include <iostream.h> //p. 37 dotyczacy relacji na wskaznikach
#include <conio.h>
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 <iostream.h> //p. 38 dotyczacy przesyłania (odbierania) tablic do (z) funkcji
#include <conio.h>
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 wskanika
Przykład 39
#include <iostream.h> //p. 39 wskazniki do obiektu const
#include <conio.h>
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 wartoci elementów tablicy
cout << "element nr " << i << " ma wartosc "
<< *Wsk << endl;
}
}
Przykład 40
#include <iostream.h> //p. 40 rezerwacja obszarów pamieci
#include <conio.h>
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 <iostream.h> //p. 41 tablice dynamiczne 1D
#include <conio.h>
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<rozm; i++)
{tab[i]=i+1; //wpis elementów do tablicy
}
for (int i=0; i<rozm; i++)
{cout<< "tab[" << i << " ]= " << tab[i] << endl;
}
delete [] tab;
getch();
}
Przykład 42
#include <iostream.h> //p. 42 tablice dynamiczne 2D
#include <conio.h>
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<w ; i++) //krok 1 ustawienie adresu wiersza
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 <iostream.h> //p. 43 praca na wskanikach do funkcji
#include <conio.h>
int Pierwsza (); //deklaracja dwóch funkcji
int Druga (); //
void main ()
{ int i;
int (*Wskaz_Fun) (); //deklaracja wskanika 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 wartoci dwóch całek oznaczonych wykorzystujšc */
/* do obliczenia całki metodę Simpsona */
//==========================================================
#include <iostream.h> //przykład nr 44; argument funkcji jest funkcjš
#include <conio.h>
#include <math.h>
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 wartoci całki oznaczonej
// w granicach <a, b> za pomocš metody Simpsona.
// f jest funkcjš podcałkowš. Przedział <a, b> 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 wartoci dwóch całek oznaczonych wykorzystujšc //
// do obliczenia całki metodę Simpsona */
/*****************************************************************************************/
#include <iostream.h> // dla cin, cout
#include <conio.h> // dla clrscr
#include <math.h> // dla sin
#include <stdlib.h> // 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 wartoci całki oznaczonej */
/* w granicach <a, b> za pomocš metody Simpsona. */
/* f jest funkcjš podcałkowš. Przedział <a, b> 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 <iostream.h> // p. 46 - struktury
#include <conio.h>
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 wartoci 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ć wartoci poszczególnym składnikom
//zmiennej strukturalnej poprzez wczytanie z klawiatury:
cout << "\nNazwisko: ";
cin.width(30);
cin >> Student.Nazwisko;
cin.width(20);
cout << "Imie: ";
cin >> Student.Imie;
cout << "Wiek: ";
cin >> Student.Wiek;
cout << Student.Nazwisko << " " << Student.Imie
<< " \t " << Student.Wiek;
while (! kbhit( )) // czekanie na naciœnięcie klawiatury
{ };
}
Przykład 47
#include <iostream.h> // p. 47 - struktury
#include <conio.h>
#include <dos.h>
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 <iostream.h> //p.48 wskaznik do struktury
#include <conio.h>
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 wskanik 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 wskanika 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 wywietlam zawartoć zmiennej Pracownik:\ n";
Wsk = &Pracownik; // ustawiam wskanik na strukturze Pracownik
cout << Wsk->Imie << " " << Wsk->Nazwisko << ", ur. "
<< Wsk->Data_Ur.Dzien << "." << Wsk->Data_Ur.Miesiac
<< "." << Wsk->Data_Ur.Rok << endl;
cout << "\nTeraz wywietlam zawartoć tablicy Dane:\n";
Wsk = Dane; //ustawiam wskanika 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 <iostream.h> //p.50 przeładowanie funkcji
#include <conio.h>
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 = "<<liczba <<endl; }
void wypisz(char znak, float a, char *text)
{cout<<"Znak ="<<znak<<"\t Float a ="<<a<<"\t String = "<< text<< endl; }
void wypisz(int liczba, char znak)
{ cout<<"liczba typu int = "<<liczba <<"\t Znak = "<< znak<<endl; }
void wypisz(char znak, int liczba)
{ cout<<"Znak = "<< znak<< "\t Liczba typu int = "<<liczba <<endl; }
Przyklad 51
#include <iostream.h> //p. 51 przeladowanie funkcji
#include <conio.h>
void pisz (int x); //podwojna deklaracja nie jest bledem
void pisz (int y);
void pisz (int, char);
void pisz (char, int, char *);
void pisz (char, float, char);
void pisz (char, int);
void main()
{
pisz (255);
pisz (9, 'a');
pisz ('B', 55, "odleglosc od punktu ");
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 <iostream.h> //p. 52 - klasy
#include <conio.h>
#include <string.h>
//------------------------ 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 <iostream.h> //p.53 - klasy przysłanianie zmiennych
#include <conio.h>
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 <iostream.h> //p.54 klasy - konstruktor
#include <conio.h>
#include <string.h>
//--------------- 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 wysokoci o 1 m ------------
Samolot.Schowaj(1201);
//---- zmiana kursu o 3 stopnie ----------
Kurs.Schowaj(Kurs.Zwracaj()+3);
//---- zmniejszenie cinienia o 2 hPa ---
Atmosfera.Schowaj(Atmosfera.Zwracaj()-2);
while (!kbhit())
{ }
}
Przykład 55
#include <iostream.h> //p. 55, klasy konstruktor, destruktor
#include <conio.h>
#include <string.h>
//------- 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 <iostream.h> // 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 <iostream.h> //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ę spodziewalimy
Przykład 58
#include <iostream.h> //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
} //Jeli użyte jest slowo virtual to funkcje składowe wybierane sš z odpowiednich obiektów
Przykład 59
#include <iostream.h> //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
main()
{
instrument jakis_instrument ; //dekl. obiektów
trabka zlota_trabka ;
fortepian steinway_fortepian ;
beben moj_beben ;
cout << "Zwykle wywolania funkcji skladowych\n"
"na rzecz obiektow - jak dotad nic szczegolnego\n" ;
jakis_instrument .wydaj_dzwiek() ; //funkcja składowa której klasy?
zlota_trabka .wydaj_dzwiek() ;
steinway_fortepian.wydaj_dzwiek() ;
moj_beben .wydaj_dzwiek() ;
cout << "Wywolanie funkcji na rzecz obiektu \n"
"pokazywanego wskaznikiem instrumentu\n" ;
instrument *wskinstr ; //wskanik typu instrument
wskinstr = & jakis_instrument ; //ustawienie wskaznika
wskinstr-> wydaj_dzwiek() ; //z jakiej klasy zostanie uzyta funkcja?
cout << "Rewelacja okazuje sie przy pokazaniu wskaznikiem\n"
"do instrumentow na obiekty klas pochodnych\n"
"od klasy instrument ! \n" ;
wskinstr = &zlota_trabka ;
wskinstr-> wydaj_dzwiek() ;
wskinstr = &steinway_fortepian;
wskinstr-> wydaj_dzwiek() ;
wskinstr = &moj_beben ;
wskinstr-> wydaj_dzwiek() ;
cout << "Podobne zachowanie jest takze \n"
"w stosunku do referencji \n" ;
muzyk(jakis_instrument); //wywołanie funkcji składowej na rzecz różnych obiektow
muzyk(zlota_trabka);
muzyk(steinway_fortepian) ;
muzyk(moj_beben) ;
}
/*******************************************************/
void muzyk(instrument & powierzony_instrument) //def. funkcji globalnej
{
powierzony_instrument.wydaj_dzwiek();
}
Przyklad 60
#include <iostream.h> //p. 60 destruktory wirtualne
#include <string.h>
class instrum {
public :
void virtual wydaj_dzwiek() { cout << "cisza" ; }
// ----wirtualny destruktor
virtual ~instrum() { cout << "Destruktor instrumentu \n" ; }
} ;
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 wskanik (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 wskanikamj
cdn.