1 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Definicje nowych pojęć do przyswojenia:
Program (kod) źródłowy - jest to tekst programu napisany zgodnie z zasadami danego języka w edytorze tekstu.
Program wykonywalny - to jest to, co nadaje się do uruchomienia i sprzedaży, potocznie zwany „kodem exe”.
Zintegrowane środowisko pracy (programowania) - pakiet programów umożliwiających wykonanie wszelkich operacji niezbędnych do opracowania kodu źródłowego i wygenerowanie na tej podstawie programu wykonywalnego.
Preprocesor - program do przetwarzania wierszy programu, które rozpoczynają się znakiem #.
#include - dyrektywa preprocesora umożliwiająca włączanie do programu plików o podanej nazwie.
iostream.h - biblioteka standardowa zawierająca funkcje do obsługi strumieni wejścia i wyjścia
conio.h - biblioteka standardowa zawierająca funkcje do obsługi konsoli wejścia i wyjścia tj. klawiatura, ekran.
main() - funkcja (moduł) główna programu w C++ zawsze występująca, od której rozpoczyna się wykonywanie (start) programu. Tutaj w zapisie bez parametrów.
float - dane liczbowe typu rzeczywistego.
cin - strumień wejściowy, zwykle z klawiatury. Dane wstawiamy do strumienia za pomocą operatora >>.
cout - strumień wyjściowy, zwykle na ekran. Dane wstawiamy do strumienia za pomocą operatora <<.
getch() - funkcja z biblioteki conio.h odczytująca znak bezpośrednio z klawiatury.
clrscr - funkcja z biblioteki conio.h, czyści ekran i ustawia kursor w lewym górnym rogu.
endl - manipulator predefiniowany wstawiający znak końca wiersza, kursor przechodzi do następnego wiersza.
return 0 - instrukcja „zwróć wartość i powróć”. Powoduje zakończenie wykonywania funkcji i zwrócenie wartości. Tutaj zwracana jest wartość 0.
Zadanie 1
Napisz program do sumowania dwóch liczb rzeczywistych podanych z klawiatury.
Program źródłowy
#include <iostream.h> //obsługa strumieni wejścia/wyjścia
#include <conio.h> //obsługa klawiatury i ekranu
main() //funkcja główna - start programu
{ //otwarcie nawiasu logicznego
float x1,x2, suma; //deklaracja zmiennych
clrscr; //funkcja czyszczenia ekranu
cout<<"Podaj liczby x1 i x2: "<<endl; // instrukcja wyjścia -wyprowadzenie strumienia
cin>>x1;
cin>>x2; // instrukcja wejścia -wprowadzenie strumienia;
cout<<"Dodaj do liczby x1 liczbę x2"<<endl;
suma=x1+x2; // instrukcja przypisania;.
cout<<"Wynik sumowania wynosi: "<<suma<<endl;
getch(); // funkcja odczytywania znaku z klawiatury
return 0; //instrukcja zakończenia wykonywania funkcji
zwana instrukcją „zwróć wartość i powróć”
} //zamknięcie nawiasu logicznego
2 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Definicje nowych pojęć do przyswojenia:
algorytm - sposób, metoda rozwiązania jakiegoś problemu w skończonej liczbie kroków.
schemat blokowy - graficzny obraz algorytmu,
typ danych - definiuje zakres lub zbiór dopuszczalnych wartości dla stałej, zmiennej, wyrażenia, funkcji oraz zbiór dopuszczalnych operacji wykonywanych na tych wartościach. Określa też format zapisu w pamięci.
Typy całkowite - (skończone , przeliczalne podzbiory zbioru liczb całkowitych)
Niektóre typy całkowite i ich zakresy
Nazwa |
Zakres |
liczba bajtów |
char, signed char unsigned char int, signed int unsigned int long, signed long unsigned long |
-128 ... 127, jeden znak 0 ... 255, jeden znak -32768 ... 32767 0 ... 65535 -2 mld ... 2 mld 0 ... 4 mld |
1 1 2 2 4 4 |
Deklaracje zmiennych całkowitych
char a, b;
int x, y=2;
typ całkowity identyfikator [=stała typu całkowitego]
Typy rzeczywiste - (skończone , przeliczalne podzbiory zbioru liczb rzeczywistych)
Typy rzeczywiste i ich zakresy
Nazwa |
Zakres |
Liczba znaczących cyfr |
liczba bajtów |
float (pojedyńczej precyzji) double (podwójnej precyzji) long double (wysokiej precyzji) |
3.4 E-38 ... 3.4 E38 1.7 E-308 ... 1.7 E308 3.4 E-4932 ... 1.1 E4932 |
6 15 18 |
4 8 10 |
Deklaracje zmiennych rzeczywistych
float a, b=-123.16e12;
double x, y=.1245;
typ rzeczywisty identyfikator[=stała typu rzeczywistego]
operatory arytmetyczne - addytywne +, -; multiplikatywne *, /, %; ikrementacji ++; dekrementacji --,
operatory przypisania - prosty: =; złożone: +=, -=, *=, /=, %=,
math.h - biblioteka standardowa zawierająca funkcje matematyczne
Niektóre funkcje matematyczne z biblioteki math.h
FUNKCJE TRYGONOMETRYCZNE:
cos(x) double cos(double x);
long double cos(long double x);
sin(x) double sin(double x);
long double sin(long double x);
tan(x) double tan(double x);
Identyfikator |
znaczenie |
M_E |
e |
M_LOG2E |
log2(e) |
M_LOG10E |
log10(e) |
M_LN2 |
ln(2) |
M_LN10 |
ln(10) |
M_PI |
π |
M_PI_2 |
π/2 |
M_PI_4 |
π/4 |
M_1_PI |
1/π |
M_2_PI |
2/π |
M_1_SQRTPI |
1/sqrt(π) |
M_2_SQRTPI |
2/sqrt(π) |
M_SQRT2 |
sqrt(2) |
M_SQRT_2 |
1/sqrt(2) |
long double tan(long double x);
FUNKCJE WYKŁADNICZE I LOGARYTMICZNE:
exp(x) double exp(double x);
long double exp(long double x);
log(x) double log(double x); logarytm naturalny
long double log(long double x);
log10(x) double log10(double x); logarytm dziesiętny
long double log10(long double x);
POTĘGI I PIERWIASTKI:
pow(x,y) double pow(double x, double y); potęgowanie xy
long double pow(long double x, long double y);
pow10(p) double pow10(int p); potęgowanie 10p
long double pow10(int p);
sqrt(x) double sqrt(double x); pierwiastek kwadratowy
long double sqrt(long double x);
INNE FUNKCJE:
ceil(x) double ceil(double x); zaokrąglenie x w górę
long double ceil(long double x);
floor(x) double ceil(double x); zaokrąglenie x w dół
long double ceil(long double x);
fabs(x) double fabs(double x); moduł x
long double fabs(long double x);
fmod(x,y) double fmod(double x, double y); reszta z dzielenia x/y (modulo)
long double fmod(long double x, long double y);
abs(x) int abs(int x); moduł x
Zadanie 1
Napisz program do obliczania odległości między dwoma punktami na płaszczyźnie.
Program źródłowy
#include <iostream.h>
#include <conio.h>
#include <math.h> //obsługa standardowych funkcji matematycznych
main()
{
float x1,y1,x2,y2,AB;
clrscr;
cout<<"Podaj wspolrzedne punktu A(x1,y1)"<<endl;
cin>>x1;
cin>>y1;
cout<<"Podaj wspolrzedne punktu B(x2,y2)"<<endl;
cin>>x2;
cin>>y2;
AB=sqrt(pow((x1-x2),2)+pow((y1-y2),2)); // instrukcja przypisania z funkcjami matemat.
cout<<"Odleglosc miedzy punktami A i B wynosi: "<<AB<<endl;
getch();
return 0;
}
3 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
if (warunek1) //jeżeli warunek jest spełniony wykonaj instrukcję 1
{
instrukcja1; // jedna instrukcja prosta lub instrukcja złożona
}
else //a jeśli nie wykonaj instrukcję 2
{
instrukcja2; // jedna instrukcja prosta lub instrukcja złożona
}
Instrukcja prosta to pojedyncze zdanie kodu źródłowego w C++.
Instrukcja złożona (blok) to wiele instrukcji prostych ujętych w parę nawiasów klamrowych {...}.
Operatory porównania
Operator |
Działanie |
Przykład |
Zapis w C++ |
== |
równa się |
a==b |
if (a==b) |
!= |
różne od |
a!=b |
if (a!=b) |
< |
Mniejsze |
a<b |
if (a<b) |
> |
Większe |
a>b |
if (a>b) |
<= |
mniejsze lub równe |
a<=b |
if (a<=b) |
>= |
większe lub równe |
a>=b |
if (a>=b) |
Operatory logiczne
&& - and - iloczyn logiczny || - or - suma logiczna ! - not - negacja logiczna if(x==2 || x==5 || x<=-5)
Zadanie 1
Napisz program źródłowy obliczający wartość wyrażenia: 
dla x wprowadzonego z klawiatury. Wyeliminuj możliwość dzielenia przez zero i obliczania pierwiastka z liczby ujemnej.
WERSJA I (bez użycia operatorów logicznych)
#include <iostream.h>
#include <conio.c>
#include <math.h>
main()
{
clrscr();
float x,y;
cout<<"Podaj wartosc liczby x"<<endl;
cin>>x;
if (x<=0)
{
cout<<"Pierwiastek liczby ujemnej lub dzielenie przez zero"<<endl;
}
else
if (x==2)
{
cout<<"Dzielenie przez zero x=2 "<<endl;
}
else
if (x==5)
{
cout<<"Dzielenie przez zero x=5 "<<endl;
}
else
{
y=x/(sqrt(x)*(x-2)*(x-5));
cout<<" y= "<<y<<endl;
}
getch();
return(0);
}
WERSJA II (z operatorami logicznymi)
#include <iostream.h>
#include <conio.c>
#include <math.h>
main()
{
clrscr();
float x, y;
cout<<"Podaj wartosc liczby x"<<endl;
cin>>x;
if (x<=0 || x==2 || x==5)
cout<<"Pierwiastek liczby ujemnej lub dzielenie przez zero"<<endl;
else
{
y=x/(sqrt(x)*(x-2)*(x-5));
cout<<" y= "<<y<<endl;
}
getch();
return(0);
}
switch (zmienna) //zmienna sterująca (selektor)
{
case'A': instrukcja 1; // jedna instrukcja prosta lub instrukcja złożona
break; //break jako instrukcja sterująca może być pominięta
case'B': instrukcja 2; w instrukcji switch lecz tylko świadomie, gdyż
break; powoduje zmianę zakresu realizacji całej instrukcji
case'C': instrukcja 3;
break;
default: instrukcja n; // wariant domyślny -wszystkie pozostałe możliwości
}
Zmiana wielkości liter
Język C++ rozróżnia wielkość liter. Aby zamienić małe litery na duże można użyć funkcji toupper bezpośrednio po wczytaniu zmiennej. Duże litery na małe zamieniamy przy pomocy funkcji tolower. Należy pamiętać, że funkcje te znajdują się w bibliotece <ctype.h>.
char zmienna; char zmienna;
cin>>zmienna; cin>>zmienna;
zmienna=toupper(zmienna); zmienna=tolower(zmienna);
Ustawienie wydruku na ekranie
Przesunięcie napisu CWICZE o dwa znaki tabulacji i przerzucenie do kolejnej linii można zrealizować następująco:
cout<<”\t \t \n CWICZE”; lub cout<<'\t'<<'\t'<<'\n'<<”CWICZE”;
4 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Definicje nowych pojęć do przyswojenia:
Instrukcje pętli (iteracyjne, powtarzania, obliczeń cyklicznych) - są to instrukcje pozwalające wykonać daną instrukcję (zwaną instrukcją wewnętrzną pętli) prostą lub złożoną zero lub więcej razy zależnie od spełnienia warunku sterowania pętlą.
Składnia instrukcji while jest następująca:
while (wyrażenie)
instrukcja wewnętrzna
Wykonywanie instrukcji while przebiega w ten sposób, że najpierw jest obliczana wartość wyrażenia (wyrażenie) i jeżeli ma ono wartość różną od zera (prawda), to jest wykonywana instrukcja wewnętrzna, która może być instrukcją prostą lub złożoną. Instrukcja może nie być nigdy wykonana, jeśli przy pierwszym obliczeniu wyrażenia (wyrażenie) będzie miało wartość zero (fałsz).
Składnia instrukcji do while jest następująca:
do
instrukcja wewnętrzna
while (wyrażenie);
Instrukcja jest wykonywana tak długo, jak długo wartość wyrażenia (wyrażenie) jest różna od zera (prawda) W przypadku, gdy wartość ta będzie równa zeru (fałsz), to wykonywanie instrukcji do...while kończy się. Wynika stąd, że instrukcja wewnętrzna jest zawsze wykonywana co najmniej jeden raz i to jest podstawowa różnica pomiędzy instrukcjami do...while a while.
manipulatory strumieniowe - umożliwiają wykonanie formatowania strumienia danych np. ustawianie szerokości pola, precyzji liczb, znaków wypełniających pole.
Biblioteka standardowa <iomanip.h> obsługuje manipulatory strumieniowe.
setw(n) - służy do ustawienia szerokości pola. Argument n to liczba całkowita (int) określająca ilość znaków w polu możliwych do wypełnienia. Np. setw(8).
setprecision(n) - ustala ilość cyfr po kropce dziesiętnej, czyli dokładność liczb zmiennoprzecinkowych (rzeczywistych). Wywołanie tego manipulatora powoduje ustawienie dokładności dla wszystkich kolejnych operacji, aż do następnego wywołania ustalającego dokładność. Argument n to liczba całkowita (int). Np.setprecision(5).
setfill(z) - służy do określania znaku wypełniającego pole. Stosowany przy porządkowaniu pola. Argument z jest typu znakowego. Np. setfill(`*').
setbase(n) - ustala podstawę formatu konwersji. Argument n może przyjąć wartości 0, 8, 10, 16.
Np. setbase(16) oznacza konwersję na system szesnastkowy.
setbase(8) oznacza konwersję na system ósemkowy.
setbase(10) oznacza konwersję na system dziesiętny.
setbase(0) oznacza konwersję na system domyślny.
lub bezpośrednio można użyć manipulatorów
dec - włącza konwersję dziesiętną.
hex - włącza konwersję szesnastkową.
oct - włącza konwersję ósemkową.
Napisz program do zamiany dziesiętnej liczby n na system szesnastkowy i ósemkowy
#include <iostream.h>
#include <iomanip.h>
#include <conio.c>
main()
{
int n;
cout<<"wprowadz liczbe dziesietna \n";
cin>>n;
cout<<n<<" to szesnastkowo: "<<hex<<n<<endl;
cout<< " to osemkowo: "<<setbase(8)<<n<<endl;
getch();
return 0;
}
Zadanie 1
Napisz program do obliczania i wyprowadzenia na ekran w pewnym porządku, z ustaloną precyzją następujących wyrażeń: a=n-i, b=i/n, gdzie n jest podaną z klawiatury ilością iteracji a i jest kolejnym numerem iteracji. Wykorzystaj manipulatory strumienia do formatowania wydruku na ekranie dla kolejnych iteracji.
Program źródłowy
#include<iostream.h>
#include<conio.c>
#include<math.h>
#include<iomanip.h>
main()
{
clrscr();
int i=0;
float n, a, b;
cout<<”Podaj liczbe iteracji n”<<endl;
cin>>n;
while (i<n)
{
i++;
a=n-i;
b=i/n;
cout<<setw(10)<<setfill(`_')<<a;
cout<<setw(10)<<setprecision(2)<<setfill(`_')<<b;
cout<<setw(10)<<setfill(`_')<<i<<endl;
}
cout<<”KONIEC”<<endl;
getch();
return(0);
}
Zadanie 2
Napisz program do zadania 1 stosując pętle do-while
Program źródłowy
#include<iostream.h>
#include<conio.c>
#include<math.h>
#include<iomanip.h>
main()
{
clrscr();
int i=0;
float n, a, b;
cout<<”Podaj liczbe iteracji n”<<endl;
cin>>n;
do
{
i++;
a=n-i;
b=i/n;
cout<<setw(10)<<setfill('_')<<a;
cout<<setw(10)<<setprecision(2)<<setfill(`_')<<b;
cout<<setw(10)<<setfill(`_')<<i<<endl;
}
while (i<n);
cout<<”KONIEC”<<endl;
getch();
return(0);
}
5 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Definicje nowych pojęć
O obliczeniach cyklicznych mówimy wtedy gdy określony ciąg instrukcji musi być wielokrotnie powtórzona w celu wykonania danego zadania. Z pętli for korzystamy wtedy, kiedy znamy dokładną liczbę powtórzeń, które chcemy wykonać.
for (wyrażenie-inicjujące; wyrażenie-warunkowe; wyrażenie-zmieniające)
instrukcja;
// wyrażenie-inicjujące: powoduje zainicjowanie licznika pętli
// wyrażenie-warunkowe: jeśli jest niezerowe (prawda) wykonywana jest instrukcja pętli
// wyrażenie-zmieniające: powoduje zwiększenie lub zmniejszenie liczników pętli.
Operatory zwiększania.
W celu prawidłowego przebiegu pętli konieczne jest wyrażenie-zmieniające, które określa krok z jakim zmienia się zmienna sterująca np. i= i + 1.
Język C dopuszcza pewne formy skróconego zapisu dla wyrażeń zwiększających:
Inkrementacja:
i = i +1 → i + = 1 → i++
Dekrementacja:
i = i -1 → i - = 1 → i--
Krok pętli może być różny od 1 np. i+=5 oraz może być również ułamkowy np. i+=0.1
Operatory przypisania
Język C++ dopuszcza pewne skrótowe formy zapisu pewnych wyrażeń arytmetycznych np.:
OPERATOR |
ZASTOSOWANIE |
ZNACZENIE |
= |
a=b |
a=b |
+= |
A+=b |
a=a+b |
-= |
a-=b |
a=a-b |
*= |
A*=b |
a=a*b |
/= |
a/=b |
a=a/b |
Zadanie 1
Napisz program, realizujący wyświetlanie na ekranie kolejnych liczb naturalnych od jeden do wartości podanej z klawiatury.
#include <iostream.h>
#include <conio.c>
main()
{
clrscr();
int i,n;
cout<<"Podaj ile wyświetlić liczb ";
cin>>n;
for (i=1; i<=n;i=i+1)
{
cout<<"i = "<<i<<endl;
}
getch();
return(0);
}
6 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Definicje nowych pojęć
Grupa instrukcji sterująca przebiegiem programu (break, continua, goto oraz return) umożliwiają opuszczenie pętli, przeniesienie wykonywania programu w inne miejsce, zakończenie wykonywania i zwrócenie wartości funkcji. Instrukcja return będzie szerzej omówiona przy omawianiu funkcji.
Instrukcja break „przerwij” powoduje opuszczenie aktualnego poziomu pętli lub instrukcji wyboru. Dopuszczalne zastosowanie tylko w tych instrukcjach.
składnia break;
Instrukcja continue „kontynuuj” powoduje przejście do następnej iteracji. Dopuszczalne zastosowanie tylko w instrukcjach iteracyjnych.
składnia continue;
Instrukcja skoku goto „skocz” umożliwia przekazanie sterowania do określonego miejsca wewnątrz aktualnie wykonywanej funkcji (zasada) programu. Etykieta określa miejsce w programie, do którego ma nastąpić skok.
składnia goto etykieta;
goto PROG_1;
ciąg instrukcji;
PROG_1:
{
instrukcje
}
Wydruk na ekranie
Każdemu znakowi wyświetlanemu na ekranie odpowiadają dwa bajty: bajt wartości i bajt atrybutów. Bajt wartości znaku odpowiada wartości wynikającej z aktualnej tablicy znaków np. tablicy ASCII. Bajt atrybutów odpowiada za kolor i ewentualnie migotanie (blink) znaku.
Bajt atrybutów znaku
7 |
6 |
5 |
4 |
3 |
2 |
1 |
0 |
migotanie |
Kolor tła |
jasność |
Kolor znaków |
||||
Do obsługi atrybutów znaku stosuje się funkcje znajdujące się w bibliotece conio.h, conio.c.
Wybrane funkcje:
ustawienie atrybutu znaku: void textattr (int attr) np. textattr(164);
ustawienie koloru tła znaku: void textbackground (int color) np. textbackground(4);
ustawienie koloru znaku: void textcolor (int color) np. textcolor(BLUE);
Stałe kolorów
stała |
wartość c |
Kolor |
zastosowanie |
BLACK |
0 |
czarny |
tło i znak |
BLUE |
1 |
niebieski |
tło i znak |
GREEN |
2 |
zielony |
tło i znak |
CYAN |
3 |
turkusowy |
tło i znak |
RED |
4 |
czerwony |
tło i znak |
MAGENTA |
5 |
karmazynowy |
tło i znak |
BROWN |
6 |
brązowy |
tło i znak |
LIGHTGRAY |
7 |
jasnoszary |
tło i znak |
DARKGRAY |
8 |
ciemnoszary |
znak |
LIGHTBLUE |
9 |
jasnoniebieski |
znak |
LIGHTGREEN |
10 |
jasnozielony |
znak |
LIGHTCYAN |
11 |
jasnoturkusowy |
znak |
LIGHTRED |
12 |
jasnoczerwony |
znak |
LIGHTMAGENTA |
13 |
jasnokarmazynowy |
znak |
YELLOW |
14 |
żółty |
znak |
WHILE |
15 |
biały |
znak |
BLINK |
128 |
migotanie |
znak |
Inne funkcje do obsługi trybu tekstowego:
czyszczenie ekranu: void clrscr(void); np. clrscr();
pobieranie znaku z klawiatury: int getch(void); np. getch();
pobieranie znaku z klawiatury i przekazanie go na ekran: int getche(void); np. getche();
przesunięcie kursora do wybranego miejsca na ekranie: void gotoxy (int x, int y); np. gotoxy (20,30);
umieszczenie tekstu w określonym oknie na ekranie: void puttext (int left, int top, int right, int bottom, *text) np. puttext(2,4,45,20,”Tabela”);
Zadanie 1
Program wyznaczenia iloczynu ciągu liczb całkowitych o określonej długości różnych od zera.
#include <iostream.h>
main()
{
int liczba, iloczyn=1, dlugosc, i, poprawny=1;
cout<<”Podaj dlugosc ciagu liczb”<<endl;
cin>>dlugosc;
cout<<”Podaj liczby”<<endl;
for (i=1; i<=dlugosc; i++)
{
cin>>liczba;
if (liczba==0)
{
poprawny=0;
break;
}
iloczyn*=liczba;
}
if (poprawny)
cout<<”Iloczyn liczb wynosi:”<<iloczyn;
else
cout<<”Blad danych”;
return 0;
}
Zadanie 2
Napisz program do wyznaczenia iloczynu liczb rzeczywistych większych od zera znajdujących w ciągu liczb o określonej długości.
#include <iostream.h>
main()
{
float liczba, iloczyn=1, dlugosc, i;
cout<<”Podaj dlugosc ciagu liczb”<<endl;
cin>>dlugosc;
cout<<”Podaj liczby”<<endl;
for (i=1; i<=dlugosc; i++)
{
cin>>liczba;
if (liczba<=0)
{
cout<<”Przejdz do kolejnej liczby ciagu”;
continue;
}
iloczyn*=liczba;
}
cout<<”Iloczyn liczb wynosi:”<<iloczyn;
return(0);
}
Zadanie 3
Program wyznaczenia iloczynu ciągu liczb całkowitych o określonej długości różnych od zera.
#include <iostream.h>
main()
{
int liczba, iloczyn=1, dlugosc, i;
cout<<"Podaj dlugosc ciagu liczb"<<endl;
cin>>dlugosc;
cout<<"Podaj liczby"<<endl;
for (i=1; i<=dlugosc; i++)
{
cin>>liczba;
if (liczba==0)
goto E1;
iloczyn*=liczba;
}
cout<<"Iloczyn liczb wynosi:"<<iloczyn;
E1:
cout<<"Blad danych";
getch();
return 0;
}
Zadanie 4
Napisz program do wydruku na ekranie imienia ANNA MARIA w 10 różnych kolorach na białym tle.
#include<iostream.h>
#include<conio.h>
#include<conio.c>
main()
{
int i=1;
puttext(30,10,60,10,"Zadanie 4");
textbackground(15);
while(i<=10)
{
gotoxy(30,10+i);
textcolor(i);
cout<<" A N N A M A R I A"<<endl;
i++;
}
getch();
return 0;
}
START
OBLICZ
Wprowadź dane
A(x1,y1), B(x2,y2)
Wyprowadź
AB
STOP
Wyszukiwarka