Bjarne Stroustrup - (C)Wikipedia

Język C++ jest językiem programowania stworzonym przez Bjarne Stroustrupa, profesora Texas A&M University. Jest to język wysokiego poziomu (ang. HLL - High Level Language), co oznacza, iż oddala się on od struktury wewnętrznej komputera pozwalając programiście skupić się nad samym algorytmem.

Język C++ należy do grupy języków kompilowanych. Oznacza to, iż programista w edytorze tworzy tekst programu, który następnie jest przekazywany do kompilatora. Kompilator analizuje otrzymany tekst i na jego podstawie tworzy program wynikowy zawierający binarne instrukcje dla procesora.

mov eax,[b] ; pobranie do akumulatora b
add eax,[c] ; dodanie do akumulatora c
mul [d]     ; wymnożenie akumulatora przez d
mov [a],eax ; umieszczenie wyniku w a

Podane powyżej polecenia są umieszczane w programie wynikowym w postaci swoich kodów binarnych (odpowiednich ciągów bitów 0 lub 1). Z przytoczonego powyżej przykładu wynika jasno, iż języki wysokiego poziomu są bardziej czytelne dla ludzi. Jednakże procesor nie potrafi bezpośrednio wykonywać zawartych w takim programie poleceń - program musi być przetłumaczony do postaci zrozumiałej dla procesora, czyli do binarnych kodów instrukcji maszynowych.

Do programowania w języku C++ będziemy wykorzystywać dwa środowiska:

1. Code::Blocks 12.11
2. Borland C++ Builder 6.0 Personal Edition

Oba środowiska są dostępne do darmowego pobrania z sieci.

Code::Blocks jest bardzo dobrym środowiskiem programowania w języku C++. Wykorzystuje ono doskonały kompilator MingW, który pozwala tworzyć programy dla Windows i dla Linuxa. Licencja umożliwia tworzenie również programów komercyjnych

Borland C++ Builder jest środowiskiem do szybkiego tworzenia aplikacji okienkowych – RAD (ang. Rapid Application Development), lecz przy jego pomocy można również tworzyć zwykłe programy w C++. Środowisko to nie jest już rozwijane przez firmę Borland, jednakże wciąż nadaje się znakomicie do nauki programowania. Licencja pozwala tworzyć jedynie programy niekomercyjne.

Przy instalacji środowiska Borland C++ Builder potrzebujesz publicznego klucza i kodu aktywacyjnego:

Po instalacji możesz zarejestrować produkt w firmie Borland. W tym celu musisz założyć sobie konto. Nie jest to skomplikowane i można tego dokonać wprost z programu instalacyjnego. Po rejestracji, która jest darmowa, staniesz się legalnym użytkownikiem pakietu. Jeśli nie zarejestrujesz pakietu, to wciąż będziesz mógł korzystać ze wszystkich jego funkcji.

W systemach Windows 7/8 pakiet Borland C++ Builder należy uruchamiać z uprawnieniami administratora.

1. Uruchom aplikację regedit.
2. Otwórz klucz HKEY_CURRENT_USER/Software/Borland/C++Builder/6.0/Editor
3. Jeśli jest podklucz Options, to go otwórz. Inaczej utwórz klucz Options.
4. Następnie utwórz nowy ciąg o nazwie NoCtrlAltKeys i nadaj mu wartość "1".

Po uruchomieniu środowiska Borland C++ Builder problem powinien zniknąć.

Programy normalnie utworzone w środowisku Borland C++ Builder wykorzystują biblioteki DLL, które to środowisko zainstalowało w systemie. Zaletą takiego rozwiązania jest dosyć krótki kod programu - kilkadziesiąt kilobajtów. Niestety, jeśli zechcesz przesłać komuś gotowy program, a ten ktoś nie będzie miał zainstalowanego środowiska Borland C++ Builder, to program po prostu się nie uruchomi, zgłaszając przy starcie brak bibliotek DLL. Na szczęście istnieje proste rozwiązanie tego problemu:

1. Wybierz z menu opcję Project/Options.
2. Przejdź na zakładkę Packages. Wyczyść na dole okienka opcję Build with runtime packages. Włącz opcję Default.
3. Przejdź na zakładkę Linker. Wyczyść opcję Use dynamic RTL.

Zapisz i przekompiluj swój projekt. Objętość programu wzrośnie do kilkuset kilobajtów, jednakże teraz program wszystko będzie zawierał w sobie i nie wystąpi już brak bibliotek DLL przy jego uruchomieniu na innym komputerze.

Budowa programu

Pusty program w języku C++ wygląda następująco:

int main()
{
  return 0;
}

Tworzy go funkcja main(). Jest to główna funkcja, od której rozpoczyna się wykonanie programu. Funkcja jest grupą poleceń, które zostaną wykonane, gdy funkcja zostanie wywołana gdzieś w programie. Funkcję main() wywołuje system operacyjny, gdy program zostaje załadowany do pamięci komputera i jest uruchamiany. Funkcję w języku C++ tworzymy wg schematu:

Instrukcja return zwraca wynik i kończy działanie funkcji. Po tej instrukcji następuje powrót do programu, który funkcję wywołał. W przypadku funkcji main() return kończy działanie programu, w zwracana wartość może być wykorzystana przez system. Wartość 0 oznacza, że program zakończył się z sukcesem.

Każda pojedyncza instrukcja w języku C++ musi kończyć się średnikiem. Brak średnika jest błędem i kompilator odmówi tłumaczenia takiego programu.

Komentarze

Komentarze służą do dokumentowania programu oraz do wyjaśniania niektórych jego fragmentów. Komentarze są całkowicie ignorowane przez kompilator i nie pojawiają się w programie wynikowym. Programy warto opatrywać komentarzami, ponieważ nawet sam twórca programu często zapomina, jak program dokładnie działa i jakie funkcje pełnią poszczególne elementy – szczególnie dotyczy to programów dużych.

W języku C++ mamy dwa rodzaje komentarzy:

// Komentarz wierszowy, obowiązuje do końca wiersza

/* Komentarz blokowy,
   który może obejmować
   dowolną liczbę
   wierszy w programie */

Strumień cout

Zwykle chcemy w programie coś wyświetlać w oknie konsoli lub odczytywać dane, które do programu wprowadza użytkownik. Język C++ nie posiada rozkazów, które obsługują bezpośrednio operacje we/wy. W tym celu korzystamy z różnych funkcji, które udostępniają nam różne biblioteki. W C++ bardzo popularną biblioteką jest STL (ang. Standard Template Library – Biblioteka Standardowych Szablonów). STL zawiera bardzo wiele użytecznych obiektów. Między innymi tzw. strumienie wejścia/wyjścia. Strumień (ang. stream) jest obiektem, który umożliwia przesyłanie danych. Jeśli interesuje nas wyświetlanie tekstu w oknie konsoli, to będziemy korzystali ze strumienia konsoli. Aby uzyskać wygodny dostęp do tego strumienia, musimy dołączyć do naszego programu odpowiedni plik nagłówkowy, który zawiera definicję obiektu strumienia konsoli. Robimy to tak:

#include <iostream>

using namespace std;

int main()
{
  cout << "Witamy w C++" << endl;
  return 0;
}

Typy danych

Podstawowe typy danych w C++ to:

Jeśli nie będą obecne specyficzne wymagania, to standardowo będziemy stosować następujące typy danych:

int
double
bool
char

Stałe

Stała jest elementem, który posiada stałą wartość. W języku C++ mamy następujące rodzaje stałych:

• dziesiętne całkowite: 1, 5, -14, 33
• szesnastkowe: 0x1f, 0xffab
• ósemkowe: 07, 0125
• zmiennoprzecinkowe: 1.5, -33.127, 2.5e15 (2,5 x 10¹⁵)
• logiczne: false, true
• znakowe: 'A', 'c'
• łańcuchowe: "ABC" (stała łańcuchowa składa się z liter zakończonych znakiem o kodzie 0)

W programie można stosować nazwy symboliczne, które tworzymy następująco:

const typ nazwa_stałej = wartość;

const int MAXW = 15;
const double PI = 3.1415;
const char ID = 'x';

Przykład:

#include <iostream>

using namespace std;

int main()
{
  cout << 255 << '=' << 0xff << endl;
  return 0;
}

#include <iostream>

using namespace std;

const double PI = 3.14159265358979;
const double R  = 3;

int main()
{
  cout << "R   = " << R << endl
       << "Obw = " << 2 * PI * R << endl;
  return 0;
}

Zmienne

Zmienna jest obiektem, który przechowuje dane w programie. Przed pierwszym użyciem zmienna musi zostać utworzona. Robimy to w sposób następujący:

typ nazwa;

Typ określa rodzaj informacji, którą zmienna będzie przechowywała. Nazwa zmiennej umożliwia odwołanie się do niej w programie. Nazwa może składać się z małych i dużych liter, cyfr oraz znaku _. Pierwszym znakiem zmiennej nie może być cyfra.

int a;
double x;

W jednej definicji można tworzyć wiele zmiennych:

int a,b,c;
double x,y,z;

Zmiennym można nadawać wartości początkowe w trakcie definicji:

int a = 5, b = 14;

Zmienne należy definiować przed pierwszym użyciem w programie. Zasięg zmiennej, czyli jej widoczność, zależy od miejsca zdefiniowania. Zmienne definiowane na samym początku programu są zmiennymi globalnymi, które są widoczne we wszystkich funkcjach. Zmienne zdefiniowane wewnątrz funkcji są zmiennymi lokalnymi, które są widoczne tylko w funkcji, w której zostały zdefiniowane. Zmienne globalne i lokalne mogą posiadać te same nazwy. W takim przypadku zmienne lokalne "przykrywają" zmienne globalne.

#include <iostream>

using namespace std;

int a = 15; // zmienna globalna a

// Funkcja nr 1
void f1()
{
  int a = 55; // zmienna lokalna a

  cout << "W f1() zmienna a = " << a << endl;
}

// Funkcja nr 2
void f2()
{
  cout << "W f2() zmienna a = " << a << endl;
}

int main()
{
  f1();   // wywołujemy funkcję nr 1
  f2();   // wywołujemy funkcję nr 2

  return 0;
}

Jeśli w funkcji posiadającej zmienną lokalną o takiej samej nazwie jak zmienna globalna chcemy odwołać się do zmiennej globalnej, to jej nazwę musimy poprzedzić operatorem zakresu ::

#include <iostream>

using namespace std;

int a = 15;            // zmienna globalna a

int main()
{
  int a = 333;         // zmienna lokalna
  
  cout << a << endl;   // odwołanie do zmiennej lokalnej
  cout << ::a << endl; // odwołanie do zmiennej globalnej

  return 0;
}

Operator przypisania

Operator przypisania (ang. assignment operator) umożliwia zmianę zawartości zmiennej. Składnia jest następująca:

zmienna = wyrażenie;

Komputer najpierw wylicza wartość wyrażenia po prawej stronie operatora, a następnie wynik jest umieszczany w zmiennej po lewej stronie operatora. W wyrażeniu mogą występować stałe, zmienne, funkcje oraz operatory arytmetyczne i logiczne.

#include <iostream>

using namespace std;

const double PI = 3.14159265358979;

int main()
{
  double o,p,r;

  r = 3;           // promień koła
  o = 2 * PI * r;  // obwód koła
  p = PI * r * r;  // pole koła

  cout << "r = " << r << endl
       << "o = " << o << endl
       << "p = " << p << endl;

  return 0;
}

Przypisanie w języku C++ posiada wartość (równą temu, co zostało przypisane). Umożliwia to łańcuchowe inicjowanie zmiennych:

a = b = c = d = 5; // wszystkie zmienne a, b, c i d otrzymają wartość 5

Operatory arytmetyczne:

c = a + 5;

c = a - 5;

c = a * b;

c = a / 5;

c = a % 5;

#include <iostream>

using namespace std;

int main()
{
  double a;

  a = 5 / 2;   cout << a << endl;  // dzielenie całkowite
  a = 5 / 2.0; cout << a << endl;  // dzielenie zmiennoprzecinkowe
  a = 5.0 / 2; cout << a << endl;  // dzielenie zmiennoprzecinkowe

  return 0;
}

Operatory logiczne

W języku C++ każde wyrażenie arytmetyczne może zostać potraktowane jak wyrażenie logiczne. Wyrażenie o wartości zero posiada wartość logiczną false, a wyrażenie o wartości różnej od zera posiada wartość logiczną true.

Negacja – zaprzeczenie:  !a

#include <iostream>

using namespace std;

int main()
{

  cout << !5 << endl
       << !0 << endl;

  return 0;
}

Alternatywa – suma logiczna: a || b

#include <iostream>

using namespace std;

int main()
{

  cout << (0 || 0) << endl
       << (7 || 0) << endl
       << (0 || 1) << endl
       << (2 || -5) << endl;

  return 0;
}

Koniunkcja – iloczyn logiczny: a && b

#include <iostream>

using namespace std;

int main()
{

  cout << (0 && 0) << endl
       << (7 && 0) << endl
       << (0 && 1) << endl
       << (2 && -5) << endl;

  return 0;
}

Operatory porównań

a == b

a != 5

a < 3

a <= b

a > b + 1

a >= b

#include <iostream>

using namespace std;

int main()
{
  double a = 0.7;

  a = a + 0.1;
  a = a + 0.1;
  a = a + 0.1;     // a powinno być teraz równe 1

  cout << (a == 1) << endl;

  return 0;
}

#include <iostream>
#include <cmath>

using namespace std;

const double EPS = 0.000001; // dokładność obliczeń

int main()
{
  double a = 0.7;

  a = a + 0.1;
  a = a + 0.1;
  a = a + 0.1;     // a jest w przybliżeniu równe 1

  cout << (fabs(a - 1) < EPS) << endl;

  return 0;
}

Operatory bitowe

Język C++ pozwala przeprowadzać operacje na poszczególnych bitach argumentów. Operacja bitowa, w przeciwieństwie do logicznej, zmienia zawartość odpowiadających sobie bitów.

Przesuw bitów w lewo: a << n

5 << 2 = 1012 << 2 = 101002 = 2010

#include <iostream>

using namespace std;

int main()
{

  cout << (5 << 2) << endl; // w nawiasie jest przesuw bitów!

  return 0;
}

Przesuw bitów w prawo: a >> n

12 >> 2 = 11002 >> 2 = 112 = 310

#include <iostream>

using namespace std;

int main()
{

  cout << (12 >> 2) << endl; // w nawiasie jest przesuw bitów!

  return 0;
}

Alternatywa bitowa: a | b

5 | 18 = 101 | 10010

  00101
| 10010
-------
  10111 = 23


	
	

		
		

		
		
#include <iostream>

using namespace std;

int main()
{

  cout << (5 | 18) << endl;

  return 0;
} 
	
		
		
 

Koniunkcja bitowa: a & b

7 & 19 = 111 & 10011

  00111
& 10011
-------
  00011 = 3


	
	

		
		

		
		
#include <iostream>

using namespace std;

int main()
{

  cout << (7 & 19) << endl;

  return 0;
} 
	
		
		
 

Bitowa suma modulo dwa: a ^ b

5 ^ 12 = 101 & 1100

  0101
^ 1100
------
  1001 = 9


	
	

		
		

		
		
#include <iostream>

using namespace std;

int main()
{

  cout << (5 ^ 12) << endl;

  return 0;
} 
	
		
		
 

Modyfikacja zmiennej

Zawartość zmiennej możemy zwiększyć o 1 przy pomocy operatora ++ lub zmniejszyć o 1 przy pomocy operatora --. Operatory te mogą stać przed zmienną lub za zmienną:

zmienna++;
++zmienna;
zmienna--;
--zmienna;

Różnica występuje wtedy, gdy tego typu operacja jest traktowana jako wyrażenie (np. w przypisaniu lub w argumencie wywołania funkcji). W takim przypadku umieszczenie operatora ++ lub -- za zmienną powoduje, że w wyrażeniu zmienna ma swoją starą wartość. Zwiększenie lub zmniejszenie nastąpi dopiero po wyliczeniu wyrażenia. Jeśli operator ++ lub -- umieścimy przed zmienną, to zmienna najpierw zostanie zmodyfikowana, a dopiero po tej operacji jej nowa wartość będzie użyta w wyrażeniu.

#include <iostream>

using namespace std;

int main()
{

  int a = 5, b = 5;

  cout << a << " " << b << endl;     // przed modyfikacją
  cout << ++a << " " << b++ << endl; // modyfikacja
  cout << a << " " << b << endl;     // po modyfikacji

  return 0;
}

Konstrukcje typu:

zmienna = zmienna operator wyrażenie;

zastępujemy często formą uproszczoną:

zmienna operator= wyrażenie;

a += 10;  // zwiększenie a o 10
a -= 5;   // zmniejszenie a o 5
a *= 4;   // pomnożenie a przez 4, itd.

Odczyt ze strumienia cin

Strumień cin umożliwia odczyt danych wprowadzonych przez użytkownika z klawiatury. Składnia operacji jest następująca:

cin >> zmienna;

Dane można odczytywać do kilku zmiennych:

cin >> zmienna1 >> zmienna 2 >> ...

#include <iostream>

using namespace std;

const double PI = 3.14159265358979;

int main()
{
  double r,o,p;

  cout << "Obliczanie obwodu i pola kola\n"
          "-----------------------------\n\n";
  cout << "r = "; cin >> r; // odczytujemy promień koła

  o = 2 * PI * r;           // obliczamy obwód
  p = PI * r * r;           // obliczamy pole

  cout << endl
       << "obwod = " << o << endl
       << "pole  = " << p << endl;

  return 0;
}

Manipulatory

Wyprowadzając dane często musimy przedstawiać je w określonym formacie. Do tego celu służą manipulatory, czyli funkcje, które współpracują ze strumieniem. Aby uzyskać dostęp do manipulatorów, należy dołączyć plik nagłówkowy iomanip. Manipulatory używamy następująco:

 

setprecision(n)	–	na wydruku liczb zmiennoprzecinkowych będzie n cyfr po przecinku
fixed	–	liczby zmiennoprzecinkowe będą wyświetlane jako część całkowita, kropka dziesiętna, część ułamkowa. Np. 12.765
scientific	–	liczby zmiennoprzecinkowe będą wyświetlane w postaci naukowej jako mantysa, e, wykładnik. Np. 2.5e3 (2,5 x 103 = 2500)
setw(n)	–	ustawia długość pola wydruku na n znaków. Działa tylko dla następnego elementu przesyłanego do strumienia
left	–	element zostanie wydrukowany w polu z dosunięciem do lewej krawędzi
right	–	element będzie wydrukowany w polu z dosunięciem do prawej krawędzi
setfil(z)	–	określa znak, którym zostanie wypełniona ta część pola wydruku, której nie zajął drukowany w nim element.
endl	–	powoduje przejście z wydrukiem na początek nowego wiersza
dec	–	liczby całkowite są drukowane lub wprowadzane (cin) jako dziesiętne
hex	–	liczby całkowite są drukowane lub wprowadzane (cin) jako szesnastkowe
oct	–	liczby całkowite są drukowane lub wprowadzane (cin) jako ósemkowe

#include <iostream>
#include <iomanip>

using namespace std;

const double PI = 3.14159265358979;

int main()
{
  double r,o,p;

  cout << setprecision(2) << fixed;

  cout << "Obliczanie obwodu i pola kola\n"
          "-----------------------------\n\n";
  cout << "r = "; cin >> r; // odczytujemy promień koła

  o = 2 * PI * r;           // obliczamy obwód
  p = PI * r * r;           // obliczamy pole

  cout << endl
       << "obwod = " << setw(8) << o << endl
       << "pole  = " << setw(8) << p << endl;

  return 0;
}

Instrukcja warunkowa – if

Instrukcja if pozwala podejmować decyzje w zależności od spełnienia określonego warunku. Posiada ona następującą składnię:

if(wyrażenie) instrukcja1; else instrukcja2;

Jeśli wyrażenie ma wartość różną od zera (czyli jest prawdziwe), to zostaje wykonana instrukcja1, a instrukcja2 będzie zupełnie pominięta. Z kolei gdy wyrażenie ma wartość 0 (czyli jest fałszywe), to pomijana jest instrukcja1, a wykonana zostaje instrukcja2.

Czasami instrukcja2 jest zbędna. Możemy wtedy użyć wersji uproszczonej:

if(wyrażenie) instrukcja;

Uwaga: każdą pojedynczą instrukcję w języku C++ można zastąpić instrukcją blokową o postaci:

{
    dowolny ciąg instrukcji
}

Przy tej modyfikacji instrukcja if przyjmuje postać:

if(warunek)
{
  ciąg instrukcji wykonywanych, gdy warunek jest prawdziwy
}
else
{
  ciąg instrukcji wykonywanych, gdy warunek jest fałszywy
}

lub

if(warunek)
{
  ciąg instrukcji wykonywanych, gdy warunek jest prawdziwy
}

Zwróć uwagę, że po instrukcji blokowej nie umieszcza się średnika zamykającego instrukcję. Funkcję tę pełni tutaj klamerka zamykająca blok. Zmienne utworzone wewnątrz bloku są widoczne tylko w obrębie tego bloku.

#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

const double EPS = 0.000001; // dokładność obliczeń

int main()
{
  double a,b,c,delta,x1,x2;

  cout << setprecision(4) << fixed;

  cout << "Rownanie kwadratowe\n\n"
          "  2\n"
          "ax  + bx + c = 0\n\n";

  cout << "a = "; cin >> a;  // odczytujemy współczynniki
  cout << "b = "; cin >> b;
  cout << "c = "; cin >> c;
  cout << endl;

  delta = b * b - 4 * a * c; // obliczamy wyróżnik

  if(fabs(delta) < EPS)
  {
      // pierwiastek podwójny
      x1 = -b / 2 / a;
      cout << "x = " << setw(10) << x1 << endl;
  }
  else if(delta > 0)
  {
      // dwa pierwiastki
      x1 = (-b - sqrt(delta)) / 2 / a;
      x2 = (-b + sqrt(delta)) / 2 / a;
      cout << "x1 = " << setw(10) << x1 << endl
           << "x2 = " << setw(10) << x2 << endl;
  }
  else
  {
      // brak pierwiastków
      cout << "BRAK PIERWIASTKOW RZECZYWISTYCH" << endl;
  }

  return 0;
}

Pętla warunkowa

Pętle (ang. loops) umożliwiają wielokrotne wykonywanie tych samych rozkazów, co jest potrzebne np. przy przetwarzaniu ciągów danych, tablic, list, itp. Wyróżniamy dwa rodzaje pętli warunkowych w języku C++.

Pętla typu while

while(wyrażenie) instrukcja;

while(wyrażnie)
{
   dowolny ciąg instrukcji
}

#include <iostream>

using namespace std;

int main()
{
  unsigned int n = 1;

  while(n) cout << (n <<= 1) << endl;

  return 0;
}

Pętla typu do while

do instrukcja; while(wyrażenie);

do
{
  dowolny ciąg instrukcji
} while(wyrażenie);
 

#include <iostream>

using namespace std;

int main()
{
  unsigned int n = 1;

  do cout << (n <<= 1) << endl; while(n);

  return 0;
}

Pętla iteracyjna

i = wartość_początkowa;  // inicjujemy licznik
while(i <= wartość_końcowa)
{
  instrukcje wykonywane w pętli

  i++;                   // modyfikacja licznika
}


	
	

		
		

		
		
#include <iostream>

using namespace std;

int main()
{
  unsigned int i = 1;

  while(i <= 10)
  {
    cout << i << " ";
    i++;
  }

  cout << endl;

  return 0;
}
	
			
			
 

for(inicjalizacja; warunek_kontynuacji; modyfikacja) instrukcja;

for(inicjalizacja; warunek_kontynuacji; modyfikacja)
{
  instrukcje wykonywane w pętli
}

for(i = 1;...

for(i = 1; i <= 10;...

for(i = 1; i <= 10; i++)...

for(i = 1; i <= 10; i++) cout << i << endl;

#include <iostream>

using namespace std;

int main()
{
  unsigned int i;

  for(i = 1; i <= 10; i++) cout << i << " ";

  cout << endl;

  return 0;
}

Tablice

Tablica jest obiektem, który przechowuje zadaną liczbę elementów tego samego typu. Tablicę deklarujemy następująco:

typ nazwa_tablicy[liczba_elementów];

int a[10];     // tablica 10 liczb całkowitych
double x[100]; // tablica 100 liczb zmiennoprzecinkowych o podwójnej precyzji
char c[1000];  // tablica 1000 znaków ASCII

Elementy tablicy są przechowywane w jednolitym bloku pamięci. Każdy element posiada numer, który nazywamy indeksem. Numeracja rozpoczyna się od 0.

int a[5];  // elementy: a[0] a[1] a[2] a[3] a[4],  elementu a[5] w tej tablicy nie ma!!!

Dostęp do elementów tablicy uzyskujemy poprzez nazwę tablicy oraz indeks podany w nawiasach kwadratowych. Tablice idealnie nadają się do przetwarzania w pętlach iteracyjnych:

// Generacja liczb Fibonacciego
//-----------------------------
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
  int i,f[31];

  f[0] = 0;
  f[1] = 1;

  for(i = 2; i <= 30; i++) f[i] = f[i-2] + f[i-1];

  for(i = 0; i <= 30; i++) cout << setw(2) << i << setw(10) << f[i] << endl;

  return 0;
}

I Liceum Ogólnokształcące    im. Kazimierza Brodzińskiego w Tarnowie ©2024 mgr Jerzy Wałaszek

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

W artykułach serwisu są używane cookies. Jeśli nie chcesz ich otrzymywać,
zablokuj je w swojej przeglądarce.
Informacje dodatkowe