Przekształcanie typów
Jeżeli argumentami operatora są obiekty różnych typów, to są one przekształcane do jednego wspólnego typu według kilku regół. Ogólna zasada mówi że: automatycznie wykonuje się tylko takie przekształcenia, w których argument "ciasniejszy jest zamieniany na obszerniejszy bez utraty informacji: np zamiana całkowitej na zmiennopozycyjną. Niedozwolone jest indeksowanie tablic zmiennymi float ( nie odbywa się konwersja).Wyrażenia w których może wystĄpić utrata informacji, jak np. przypisanie wartości o dłuższym typie całkowitym zmiennej krótszego typu, czy po zmianie zmiennopozycyjnej na całkowitą, mogą powodowac wypisanie ostrzeżenia, ale nie jest niedozwolone. Obiekty char są krótkimi liczbami całkowitymi, zapewniającymi znaczną elastyczność przy różnego rodzaju przekształceniach.
Przykład
int atoi(char s[])
{ int i,n;
n = 0;
for(i = 0;s[i] >='0' && s[i]<='9'; ++i)
n = 10 * n + (s[i] - '0'); // konwersja char na int;
return ;}
Wyrażenie s[i] - '0' daje numeryczną wartość cyfry zawartej w s[i]. Ogólnie konwersja wykonywana jest w następujący sposób (zasady powinny być stosowane wg kolejności wymieniania):
- jeśli jeden argument jest long double drugi przekształcany jest do long double.
- jeśli nie to jeśli jeden argument jest double drugi przekształcany jest do double.
- jeśli nie to jeśli jeden argument jest float drugi przekształcany jest do float.
- jeśli nie to jeśli jeden argument jest unsigned long drugi przekształcany jest do unsigned long
- jeśli nie to jeśli jeden argument jest signed long drugi przekształcany jest do signed long
- jeśli nie to jeśli jeden argument jest unsigned int drugi przekształcany jest do unsigned int
- w przeciwnym przypadku oba operandy są typu int
Sposoby wykonywania konwersji
- char na int: powielanie bitu znaku dla signed char lub wypełnienie zerami dla unsigned char
-short na int: ta sama wartość
- unsigned short na unsigned int : ta sama wartość
-konwersja dłuższego typu całkowitego do mniejszego: Odrzucenie bardziej znaczących bitów i w razie ich ustawienia utrata informacji
- konwersja między typami calkowitymi o tych samych długościach: bezpośrednie skopiowanie wartości jednej zmiennej do drugiej. Warto wiedzieć, że można uzyskać ciekawe wyniki np.: int -1000 po konwersji do unsigned char 64536 ( bit znaku traktowany jako bit o wadze 2 do 15)
- konwersja rzeczywiste na całkowite : odrzucenie części ułamkowej liczby rzeczywistej
- konwersja całkowite na rzeczywiste : nadanie odpowiedniej liczbie rzeczywistej wartości liczby całkowitej
- konwersje między typami rzeczywistymi o różnych rozmiarach : zaokrąglenie do najbliższej wartości docelowego typu.
Oprócz automatycznego przekształcania typów, w dowolnym wyrażeniu można jawnie wymusić przekształcenie typów za pomocą: jednoargumentowego operatora rzutowania(casting)
Operator ten może mieć dwie formy:
(nazwa_typu) zmienna //forma języka C/C++
nazwa_typu(zmienna) //forma C++
Operator ten upewnia niejako komputer, że rzeczywiscie chcemy przeprowadzić "niedozwoloną" operacje konwersji np: int do char;
Przykład
/* rand : generowanie losowej liczby całkowitej z przedziału 0...32767 */
unsigned long int next = 1
int rand (void)
{ next = next * 1103515245 + 12345;
return(unsigned int)(next/65536) % 32768;}
/* srand zarodek dla f-cji rand */
void srand(unsigned int seed)
{ next = seed; }
Operator sizeof()
Jak wspomnieliśmy przy okazji omawiania typów podstawowych, rozmiary niektórych zmiennych są uzależnione od implementacji. Często ważne jest znanie rozmiarów typów.
Do tych celów zaimplementowano w języku C bardzo wygodny operator: sizeof(), podający rozmiary:
a) typów zmiennych sizeof(nazwa_typu)
b)obiektów sizeof(nazwa_obiektu)
Przykład
#include<iostream.h>
main()
{ int tab_of_int[10];
cout <<"Podaj rozmiar typu int " << sizeof(int);
cout<<"
A terza podaj rozmiar tablicy int-ów tab_of_int " << sizeof(tab_of_int;
return 0; }
Operator przecinek
Ostatnim operatorem języka C jest przecinek. Jeśli kilka wyrażeń stoi obok siebie i są oddzielone przecinkami, to całość też jest wyrażeniem, a wartościa tego wyrażenia jest wartością prawego argumentu. (2+4, a*4, 3<6, 77+2) wart.wyrażenia: 79. Poszczególne wyrażenia obliczane są od lewej do prawej. Jest on np. stosowany w pętli for do równoległego sterowania dwoma indeksami np:
Przykład
void reverse(char s[])
{ int c,i,j;
for(i = 0, j = strlen(s)-1; i<j;i++,j--)
{c = s[i];
s[i] = s[j];
s[j] = c;} }
Funkcja ta odwraca kolejność znaków argumentu s.
Tablice
Jednowymiarowe
Jest to ciąg obiektów tego samego typu, zajmujących ciągły obszar w pamięci. Rozmiar tablicy musi być wartością stałą, znaną już na etapie kompilacji. Tablice nie mogą być ciągiem referencji. Jeśli zadeklarowaliśmy tablicę: float tablica[rozmiar];
Elementy tablicy numerowane są od 0 do rozmiar -1. f
loat tablica [3] - to zbiór trzech elementów typu float: tablica[0], tablica[1], tablica[2].
Uwaga: Instrukcja tablica[3]=90; jest błędna jeżeli odnosimy się do elementu tablicy.
Nazwa tablicy jest adresem początku tej tablicy w pamięci, nazwa jest równocześnie adresem zerowego elementu tablicy w pamięci.
tablica tablica+1 tablica+2 tablica+3
tablica[0] |
tablica[1] |
tablica[2] |
tablica[3] |
Printf (″%p″, tablica); - wyświetlenie adresu początku obszaru zarezerwowanego dla tablicy.
Inicjalizacja tablicy może odbywać:
- podczas deklaracji tablicy:
int tab[3] = {1,2,3}; lub int tab[] = {1,2,3};
int tab[3] = {1,2,3,4}; //błąd
int tab[4] = {1,2} => int tab[4] = {1,2,0,0}
Brakujące elementy uzupełniane są zerami:
- w trakcie działania programu:
int tab [10], i;
randomize();
for( i = 0; i<10; i++)
tab[i] = random(78);
Tablice to kolejna rzecz, która może uprzyjemnić programowanie. Tablica to zbiór określonej liczby obiektów powiązanych w pewien logiczny związek. Wszystkie takie obiekty muszą być tego samego rodzaju. Nie można w tablicy umieścić kilku różnych zmiennych. Zaczniemy od najprostszych tablic zawierających liczby. Oto przykład:
Kod:
int tablica_liczb[10];
To jest właśnie nasza tablica. Wystarczyło dodać tylko dwie klamerki oraz liczbę elementów, aby osiągnąć cel. Zwróć uwagę, że tablica taka, podobnie, jak zmienne nowo definiowane zawiera śmieci. Jeśli tylko chcemy to możemy dokonać inicjalizacji tablicy razem z definicją. Robi się to w taki sposób: int tablica[6] = {3,5,2,1};//równoznaczne z int tablica[6] = {3,5,2,1,0,0};
Zauważ, że tablica jest sześcioelementowa. My podaliśmy jedynie cztery. W takiej sytuacji kompilator zakłada, że pozostałe dwa elementy mają zostać wyzerowane. Zatem zapis: int tablica[6] = {3,5,2,1}; jest jednoznaczny z: int tablica[6] = {3,5,2,1,0,0};. Idąc dalej tym tropem okaże się, że w prosty sposób możemy wyczyścić całą tablicę już przy definicji. Piszemy tak: int tablica[6] = {0};
Tym sposobem mamy sześcioelementową tablicę zawierającą liczby typu int. Dodatkowo wszystkie te liczby posiadają wartość zero. Jeśli korzystamy z takiej formy inicjalizacji tablic to możemy całkowicie pominąć jej rozmiar. Konkretniej: int tablica[] = {2,4,8,16};
Spowoduje, że otrzymamy cztero elementową tablicę wypełnioną odpowiednimi wartościami. Zauważ, że jawnie nie podaliśmy rozmiaru naszej tablicy, a jedynie wartości poszczególnych jej elementów. Kompilator wówczas przyjmie, że tablica ma posiadać tyle elementów, ile chcemy zainicjalizować, czyli cztery. Dostęp do elementów uzyskujemy dzieki operatorowi [] oraz podaniu odpowiedniego indexu. Zwróć uwagę na bardzo istotną rzecz! Elementy tablicy numerowane są od zera! Dlatego pierwszy element ma index [0], drugi - [1], trzeci - [2], czwarty - [3]. To koniec, więcej elementów nie ma. Należy o tym pamiętać i nie przekraczać zakresu tablicy, bo może to zaowocować nawet załamaniem programu!
Sposób pracy na tablicach jest bardzo prosty. Zilustrujemy to prostym przykładem.
Przykład
/* Program zliczający wszystkie znaki stringu wprowadzonego z klawiatury */
#include<stdio.h>
#include<iostream.h>
#inclued<conio.h>
main()
{ char string[20];
int licznik = 0;
clrscr();
gets(string);
while(string[licznik] != NULL)
licznik ++;
cout<<"Liczba znaków w stringu: "<<licznik;
while (!kbhit());
return 0; }
kbhit() - funkcja czekająca na nacisnięcie klawisza ( testujaca klawiaturę) - obie z prototypem w zbiorze <conio.h>.
Najczęściej tablice wprowadza lub wyprowadza się przy pomocy instrukcji for:
wprowadzanie:
int tab [10], i;
for( i = 0;i<10;i++) // lub for (i=0; i<=9;i++)
cin>>tab[i];
wypisywanie:
int tab [10], i;
for( i = 0;i<10;i++) // lub for (i=0; i<=9;i++)
cout>>tab[i];
Wprowadziliśmy tu podwójny zapis pętli, różniący się stosowanym typem nierówności, lepiej jest stosować pierwszy sposób z nierównościa silną, ponieważ nie trzeba odejmować jedynki od rozmiaru tablicy ( co może doprowadzić do błędu);
Znakowe
Specjalnym rodzajem tablic są tablice znakowe. Deklaracja takiej tablicy:
char zdanie [50];
Zazwyczaj tablice te służą do przechowywania łańcuchów (stringów), czyli ciągów znaków zakończonych znakiem NULL.
Nadawanie wartości tablicy znakowej:
char zdanie [12] = "ala ma kota";
char zdanie [ ] = "ala ma kota";
Znak NULL został zapisany automatycznie, ponieważ przy inicjalizacji tablicy ciąg znaków ograniczyliśmy znakami cudzysłowia.
W przypadku gdy nie określono rozmiaru tablicy, rozmiar wynosi:
sizeof (zdanie)= ilość znaków + NULL.
W naszym przypadku adres początku łańcucha w pamięci - zdanie.
char t1[1] = "a"; //błąd
char t1[2] = "a"; //poprawnie
char t2[1] = 'a'; //poprawnie, wprowadzamy znak
(b) char zdanie[12]= {'a','l','a',' ','m','a',' ','k','o','t','a','\0'};
lub
char zdanie[12]= {'a','l','a',' ','m','a',' ','k','o','t','a',NULL};
Poprawnie inicjowana tablica. Wprowadzono znak NULL.
(c) gets (zdanie); wykorzystanie funkcji bibliotecznej do pobrania łańcucha
puts (zdanie); printf ("%s", zdanie); wyświetlanie łańcucha
(d) strcpy (tablica, "tekst");
Nadanie wartości tablicy char tablica[10] w następujący sposób:
tablica = "tekst"; jest błędne, należy użyć funkcji strcpy();
Przykłady
/* zliczanie znaków tekstu wprowadzonego z klawiatury */
char zdanie[20];
int licznik = 0;
clrscr();
gets (zdanie);
while (zdanie [licznik] != NULL) licznik ++;
cout<<"Długość łańcucha: "<<licznik;
char nazwisko[] = {'N' , 'o' , 'w' ,'a' , 'k'};
printf ("%s", nazwisko); Ekran np: Nowak#*09%^4
Błąd. Brak znaku NULL.
char nazwisko[] = {'N' , 'o' , 'w' ,'a' , 'k', `\0'};
const int ilosc=5;
char samogloski[ilosc]= {'a','e','i','o 'u'};
Służy do sprawdzania czy znak jest samogłoską. Brak znaku NULL nie musi być błędem.
Powstała specjalna biblioteka <string.h> zawierająca podstawowe funkcje obsługujące łańcuchy: kopiowanie , wycinanie, poszukiwanie znaku itd.
tablice znakowe, czyli.. stringi :)
Stringi służa do przechowywania znaków, a co za tym idzie całych słów, fraz, wyrażeń. Jednym słowem wszelkiego rodzaju textu. Tradycyjnie wyjdźmy od przykładu: char string[30]; Nasz string jest 30-elementową tablicą typu char. Obecnie zawiera on jakieś śmieci, jak wszystko, co nie zostało zainicjalizowane. Aby wstawić do stringu jakiś konkretny text należy podstawić pod każdy z jego indexów odpowiednie znaki. Spójrz:
Kod:
string[0] = 'd';
string[1] = 'o';
string[2] = 'w';
string[3] = 'o';
string[4] = 'l';
string[5] = 'n';
string[6] = 'y';
string[7] = ' ';
string[8] = 't';
string[9] = 'e';
string[10] = 'x';
string[11] = 't';
string[12] = '\0';//to jest znak kończący string
string[13] = 't';
string[14] = 'e';
string[15] = 'g';
string[16] = 'o';
string[17] = ' ';
string[18] = 'n';
string[19] = 'i';
string[20] = 'e';
string[21] = ' ';
string[22] = 'm';
string[23] = 'a';
string[24] = '\0';
Jak widzisz taka zabawa w podstawianie. Ważne jest, abyś wiedział, jak to działa. Pamiętaj, że podstawiane znaki umieszczamy w apostrofach. Nie myl z cudzysłowami! String musi także posiadać znak kończący. Zwróć uwagę, że my wstawiliśmy znak końca stringu pod indexem 12. W wyniku tego wszystko, co znajduje się za nim praktycznie nie istnieje. Mała wzmianka od inicjalizacji stringów. Definiując ciąg można od razu go zainicjalizować w taki sposób: char string[13] = "dowolny text"; //lub tak char string[] = "dowolny text"
Zauważ, że nasz string mieści 13 znaków, zaś cały text dowolny text to 12 znaków. ten 13 znak to nasz znak kończący. Nie jest on widoczny, ale musi istnieć. Pamiętaj jeszcze, że taki sposób podstawienia textu do tablicy jest możliwy jedynie podczas inicjalizacji. Później tak nie można:
Kod:
char string[13] = "dowolny text"; //ok
//char string = "inny text"; tak nie wolno!
rozmiar tablicy
Czasem zachodzi potrzeba pobrania rozmiaru tablicy bądź też ilości jej elementów. Można to zrobić korzystając z operatora sizeof
Kod:
int liczby[4];
int rozmiar_tablicy = sizeof(liczby);//rozmiar tablicy w bajtach
int ilosc_elementow_tablicy = rozmiar_tablicy / sizeof(int);//ilość elementów tablicy
Wielowymiarowe
Deklaracja tablicy dwuwymiarowej:
int tab1[3][2];
Są one reprezentowane jako tablice tablic i używanie notacji z przecinkiem takiej jaka jest stosowana w innych językach (Pascal), powoduje błędy kompilacji, ponieważ przecinek jest operatorem następstwa:
int tab[5,2]; // błąd
int zle = tab[4,1]; //błąd
int tab[5][2]; // poprawnie
int dobrze = tab[4][1]; //poprawnie
Inicjalizacja:
podczas deklaracji:
tab[3][2] = {10, 11, 20, 21, 30, 31};
tab[0][0] tab[1][0] tab[2][0]
tab[0][1] tab[1][1] tab[2][1]
Przy inicjacji tablic dwuwymiarowych konieczne jest podanie co najmniej jednego wymiaru:
jest nim ilość elementów w wierszu:
int tab[][] = {0,1, 10,11, 20,21, 30,31}; // błąd
int tab[3][] = {0,1, 10,11, 20,21, 30,31}; // błąd
int tab[][2] = {0,1, 10,11, 20,21, 30,31}; // dobrze bo potrafi policzyć ilość kolumn
int tab[][2] = {0,1, 10,11, 20,21, 30,31, 9}; // dobrze
Uzupełnianie brakujących elementów tablic odbywa się wg. zasad dla tablic jednowymiarowych
w trakcie działania programu:
for (i=0; i<3; i++)
for (i=0; i<2; i++)
tab[i][j] = 2*i + j;
Przykład zastosowania obu typów tablic przedstawia program obliczania sumy elementów wierszy macierzy 5x5.
int A[5][5], B[5];
int i, j;
clrscr();
/* sumowanie wierszy */
for(i = 0; i<5;i++) {
B[i]=0;
for(j = 0; j<5; j++)
B[i] += A[i][j];
}
for(i = 0; i<5; i++)
cout << B[i]<< "\n";
Przykład
#include<iostream.h>
#inclued<conio.h>
main()
{ int A[5][5], B[5];
int i,j;
clrscr();
/* wprowadzenie elementów tablicy A */
for(i = 0; i<5;i++)
for(j = 0; j<5;j++)
cin>>A[i][j];
/* sumowanie wierszy */
for(i = 0; i<5;i++)
for(j = 0; j<5;j++)
b[i] += A[i][j];
/* wyswietlanie wyników zapisanych w tablicy jednowymiarowej */
for(i = 0; i<5; i++)
cout << "b[" << i << "] = " << b[i];
return 0; }
1 deklaracja tablic, wprowadzanie danych tab1.cpp
2 przetwarzanie tablic w pętli FOR, suma i iloczyn elementów tablicy tab2.cpp
3 wypełnienie tablicy losowymi liczbami, minimalny i maksymalny element tab3.cpp
4 tablice dwuwymiarowe - wypełnianie i wyswietlenie tab4.cpp
5 suma i iloczyn elementów tablicy dwuwymiarowej tab5.cpp
6 suma elementów głównej przekątnej i zadanego wiersza tab6.cpp
7 suma liczb parzystych wpisanych do tablicy dwuwymiarowej tab7.cpp
8 ilość elementów parzystych większych od zadanej liczby tab8.cpp
Przykład 1
#include<iostream.h> #include<conio.h> //dolacz pliki naglowowe
// Deklaracje zmiennych
int x,y=1,tab[10]; // dwie zmienne typu integer i tablica 10 elementow
//typu integer, y ma jednoczesnie przypisana wartosc
float z=3.4,tabf[11]; //jedna zmiena typu float i tablica 11 elementow
main () {
tab[0]=y; //przypisanie 1- szemu elementowi tablicy wartosci zmiennej y czyli 1
tab[1]=5; // drugi element =5
tab[2]=10; // trzeci element=10
x=tab[0]; //x rowna sie pierwszemu elementowi czyli y czyli 1
cout<<tab[1]; //wyswietl drugi element
cout<<"\n"; //przejscie do nastepnego wiersza
cin>>tab[3]; //poberz z konsoli czwarty element
cout<<z; //wyswietl wartosc zmiennej z czyli 3.4
//tab[4]=z; //BLAD niezgodnosc typow
tabf[0]=z; //dobrze bo tablica tabf jest przeznaczona na zmiene typu float
cout<<"\n"; //przejscie do nastepnego wiersza
cout<<tabf[0]; //wyswietl pierwszy element tablicy tabf czyli 3.4
getch(); } //oczekiwanie na nacisniecie klawisza
Przykład 2 //Przetwarzanie tablic w petli FOR
#include<iostream.h> #include<conio.h>
int tab[10]; //deklaracja tablicy
main() { /* Wypełnienie tablicy jedynkami
Dla pierwszego obiegu petli i=0 i do tab[i] czyli tab[0] przypisywana jest jedynka
Dla drugiego obiegu petli i=1 i do tab[i] czyli tab[1] przypisywana jest jedynka
itd...*/
for( int i=0; i<10; i++)
{ tab[i]=1; } /* czyli wyglšda to tak [ 1 1 1 1 1 1 1 1 1 1 ] */
for ( int j=0; j<10; j++) /* Wy�wietlenie elementów tablicy */
{ cout<<tab[j]<<"\n"; } //wy�wietlenie elementu i przej�cie do następnego iersza
/*Pomnożenie każdego elementu przez zadanš liczbe*/
for(int k=0;k<10;k++)
{ tab[k]=tab[k]*2; }
/* Suma elementów tablicy */
int suma =0; //deklaracja zmiennej w której bedzie wynik sumowania
for( int m=0;m<10;m++)
{ suma=suma+tab[m];
cout<<"\nm="<<m<<"\ttab[m]="<<tab[m]<< "\tsuma ="<<suma; }
/* Iloczyn elementów tablicy*/
int iloczyn =1;
for( int n=0;n<10;n++)
{ iloczyn=iloczyn*tab[n];
cout<<"\nm="<<n<<"\ttab[m]="<<tab[n]<< "\tiloczyn ="<<iloczyn; }
getch(); }
Przykład 3
#include<iostream.h> #include<conio.h> #include<stdlib.h> #include<time.h>
int tablica[10]; //deklaracja tablicy 10 cio elementowej
int maksimum,minimum;
main() {
cout <<" Program wypelnia tablice liczbami losowymi i wyswietla te liczby";
cout <<"\n Liczy max i min tego zbioru libzb ( bez uwzglednienie powtorzen)\n";
randomize(); // uruchom generator liczb pseudolosowych
// losowanie liczb
for (int i=0;i<10;i++)
{ tablica[i]=random(20)+1; //wylosuj liczbę z zakresu 0-20 i wpisz tablicy
cout << tablica[i]<<"\n";//wy�wietl element i przejdz do nastepnego wiersza }
// Poszukiwanie maksimum
maksimum=tablica[0]; //zakładamy że najwiekszy jest I element
for (int j=0;j<10;j++)
{ if(maksimum<tablica[j]) //Jezeli max jest mniejsze od elementu tablicy, to niech się równa temu elementowi
{ maksimum=tablica[j]; } } //sprawdzamy po kolei kazdy element
cout<<"\n maksymalny element to "<<maksimum;
// Poszukiwanie najmniejszego elementu
minimum=tablica[0];
for(int k=0;k<10;k++)
{ if(minimum > tablica[k]) //jeżeli dany element jest mniejszy od min to min niech się równa temu elementowi
{ minimum=tablica[k]; } }
cout<<"\n minimalny element to "<<minimum;
getch(); }
Przykład 4
// Tablice dwuwymiarowe Wpisanie warto�ci do tablicy i wy�wietlenie
#include<iostream.h> #include<conio.h> #include<stdlib.h> #include<time.h>
int tab[4][4]; //deklaracja tablicy 4x4
main() {
for( int i=0; i<4;i++ )
{ for(int j=0;j<4;j++)
{ tab[i][j]=5; } }
// wyswietlenie wszystkich elementów program wyswietli 16 cyfr 5 jedna za drugš
for( i=0; i<4;i++ )
{ for(int j=0;j<4;j++)
{ cout<<tab[i][j]; } }
// poprawiona wersja - przejscie do nastepnego iersza i odsuniecie kolejnych elementow
cout << "\n"; //przejdz do nastepnego wiersza
for ( int k =0;k<4;k++)
{for(int m=0;m<4;m++)
{ cout<<tab[k][m];
cout<< "\t" ; } // odsun kursor o kilka znakow
cout<<"\n"; } // przejdz do nastepnego wiersza
getch(); }
Przykład 5
// program wypełnia tablicę 5x5 wylosowanymi elementami następnie liczy sumę i iloczyn oraz wy�wietla tablicę i wyniki
#include<iostream.h> #include<conio.h> #include<stdlib.h>
int t[5][5]; //deklaracja tablicy elementów całkowitych
int suma=0;
long iloczyn=1; // zmienne do przechowywania warto�ci sumy i iloczynu
int main(void){
randomize(); //uruchomienie generatora liczb pseudoloosowych
// wypełnienie tablicy
for(int i=0;i<5;i++)
{ for(int j=0;j<5;j++)
{ t[i][j]=random(3)+1; } }
// wyliczenie sumy i iloczynu
for(int m=0;m<5;m++)
{ for(int n=0;n<5;n++)
{ suma=suma+t[m][n];
iloczyn=iloczyn*t[m][n]; } }
// wy�wietlenie całej tablicy po 5 elementów w wierszu
for( int k=0;k<5;k++)
{ for(int l=0;l<5;l++)
{cout<<t[k][l]<<"\t"; }
cout<<"\n"; }
// wy�wietlenie sumy i iloczynu
cout<<"\n"<<"Suma elementow wynosi : "<<suma;
cout<<"\n"<<"Iloczyn elementow wyniosi :"<<iloczyn;
getch(); return 0; }
Przykład 6
// program wypełnia tablicę 5x5 wylosowanymi elementami następnie liczy sumę zadanego przez użytkownika wiersza , głównej przekštnej, wy�wietla tablicę oraz wyniki
#include<iostream.h> #include<conio.h> #include<stdlib.h>
int t[5][5]; //deklaracja tablicy elementów całkowitych
int sumaprzekatnej=0,sumawiersza=0;
int ktorywiersz; // zmienne do przechowywania warto�ci sumy
int main(void) {
randomize(); //uruchomienie generatora liczb pseudoloosowych
// wypełnienie tablicy
for(int i=0;i<5;i++)
{ for(int j=0;j<5;j++)
{t[i][j]=random(5); } }
// pobranie od użytkownika numeru wiersza
cout << "Podaj numer wiersza od 1 do 5\n"; // na koncu przejscie do nastepnego wiersza
cin>> ktorywiersz; //wyliczenie sumy okreslonego wiersza
cout<<"\n---------------------------------------------------------------\n";
for(int n=0;n<5;n++)
{sumawiersza=sumawiersza+t[ktorywiersz-1][n];} //plus jeden bo komputer numeruje od 0 a urzytkownik 0d1
// wy�wietlenie całej tablicy po 5 elementów w wierszu
for( int k=0;k<5;k++)
{ for(int l=0;l<5;l++)
{if(k==l)
{ sumaprzekatnej=sumaprzekatnej+t[k][l]; }
cout<<t[k][l]<<"\t"; }
cout<<"\n"; }
// wy�wietlenie suny i iloczynu
cout<<"\n"<<"Suma elementow wiersz "<<ktorywiersz<< " wynosi :"<<sumawiersza;
cout<<"\n"<<"Suma elementow glownej przekatnej wynosi :"<<sumaprzekatnej;
getch(); return 0; }
Przykład 7
// Program liczy sume i iloczyn elementow parzystych w tablicy 5x5 elementy tablicy podaje uzytkownik
#include<iostream.h> #include<conio.h>
int liczby[5][5]; //deklaracaja tablicy
int sumaparzystych=0;
long iloczynparzystych=1;
int k=1;
int main(void) { // Wczytanie liczb do tablicy
cout<<"Podaj 25 liczb \n";
for(int i=0;i<5;i++)
{ for(int j=0;j<5;j++)
{ cout<<"liczba nr : "<<k++<<" ";
cin>>liczby[i][j]; } }
// Policzenie sumy i ilkoczynu odpowiednich liczb
for( int k=0;k<5;k++)
{for(int l=0;l<5;l++)
{ if((liczby[k][l]%2)==0)
{ sumaparzystych=sumaparzystych+liczby[k][l];
iloczynparzystych=iloczynparzystych*liczby[k][l]; } } }
//Wyswietlenie tablicy i wynikow
for( int m=0;m<5;m++)
{for(int n=0;n<5;n++)
{cout<<liczby[m][n]<<"\t"; }
cout<<"\n"; }
cout<<"-------------------------------------------------------------\n";
cout<<"Suma liczb parzystych w tablicy wynoosi : "<<sumaparzystych;
cout<<"\nIloczyn liczb parzystych wynosi : " <<iloczynparzystych;
getch(); return 0; }
Przykład 8
// elementy tablicy podaje użytkownik program liczy ile jest elementow parzystych wiekszych od 5
#include<iostream.h> #include<conio.h>
int liczby[5][5]; //deklaracaja tablicy
int ile=0;
int k=1;
int main(void) { // Wczytanie liczb do tablicy
cout<<"Podaj 25 liczb \n";
for(int i=0;i<5;i++)
{ for(int j=0;j<5;j++)
{ cout<<"liczba nr : "<<k++<<" ";
cin>>liczby[i][j]; } }
// Policzenie sumy i ilkoczynu odpowiednich liczb
for( int k=0;k<5;k++)
{for(int l=0;l<5;l++)
{ if((liczby[k][l]%2)==0 && liczby[k][l]>5)
{ ile++; } } }
//Wyswietlenie tablicy i wynikow
for( int m=0;m<5;m++)
{for(int n=0;n<5;n++)
{cout<<liczby[m][n]<<"\t"; }
cout<<"\n"; }
cout<<"-------------------------------------------------------------\n";
cout<<"Liczb parzystych wiekszych od 5 jest : "<<ile;
getch(); return 0; }
9
adres początku obszaru zarezerwowanego dla tablicy
Wyszukiwarka