Instrukcje programowe

| przypisania | break | continue | do-while | for | if | pusta | return | switch | while | złożona |

Instrukcja przypisania

Jest to najprostszą i najczęściej używana instrukcja. Przypisuje wartość wyrażenia znajdującego się po prawej stronie znaku równości (=) do zmiennej znajdującej się po lewej stronie.

Przykłady:

x = 100;
y = x * 100 + z;
z = x + sqrt(y);

Instrukcja break

Instrukcja break może wystąpić tylko wewnątrz pętli do-while, while i for lub w instrukcji switch. Powoduje wyjście z najbardziej zagnieżdżonej pętli lub przerwanie wykonywania instrukcji switch.

Składnia:

break;

Przykłady:
Wykorzystanie instrukcji break do przerwania instrukcji switch do wyświetlenia ilości dni w miesiącu: 

char miesiac;
...
switch (miesiac) {
  case 4  :
  case 6  :
  case 9  :
  case 11 : printf("Miesiąc ma 30 dni\n"); break;
  case 2  : printf("Miesiąc ma 28 lub 29 dni\n"); break;
  default : printf("Miesiąc ma 31 dni\n");
}
Przerwanie pętli do-while, gdy użytkownik wprowadzi wartość -1 lub >20: 
int i;
do {
  scanf("%d", &i);
  if (i == 0 || i > 20) break;
  printf("%d! = %d\n", i, silnia(i));
} while (1);

Instrukcja continue

Instrukcja continue, podobnie jak break, używana jest tylko wewnątrz pętli do-while, while i for. Pomija ona resztę ciała pętli, powodując natychmiastowe rozpoczęcie kolejnego cyklu pętli. Zwróć uwagę na różnicę w stosunku do break, które całkowicie wyskakuje z pętli.

Składnia:

continue;

Przykład:
Pętla oblicza pierwiastki wprowadzonych liczb. Jeżeli użytkownik poda liczbę ujemną, to jest ona ignorowana: 

int i;
float j;
for (i = 0; i < 10; i ++) {
   scanf("%f", &j);
   if (j < 0) continue;
   printf("Pierwiastek z %f = %f\n", l, sqrt(j));
}

Instrukcja do - while

Pętla do-while jest bardzo podobna do while. Różnica polega na tym, że pętla while może w ogóle się nie wykonać, jeśli warunek nie będzie spełniony, natomiast pętla do-while wykona się przynajmniej raz, bo warunek sprawdzany jest dopiero na jej końcu.
Składnia wygląda następująco: 

do
{
     instrukcje do wykonania
} while(warunek);

Pętla ta działa na podstawie następującego algorytmu:
  1. Wykonywane są instrukcje do wykonania.
  2. Sprawdzany jest warunek - jeśli jest fałszywy to następuje skok do kroku 4.
  3. Następuje skok do kroku 1.
  4. Pętla kończy się - wykonuje się następna instrukcja za pętlą.

Przykład: 

#include <stdio.h>
void main(void)
{ int i = 0;
  printf("Początek pętli\n");
  do
  { printf("Licznik pętli = %d\n", i);
    i++;
  } while(i < 10);
  printf("Koniec pętli\n");
}

Porównaj ten przykład z przykładem zamieszczonym przy pętli while.

Instrukcja for

Najbardziej rozbudowaną instrukcją języka C++ jest pętla for. Składnia wygląda następująco:

for(inicjalizacja; warunek; inkrementacja)
{
   instrukcje do wykonania
}

Pętla ta działa na podstawie następującego algorytmu:

  1. Wykonywane są instrukcje zawarte w części inicjalizacja. Jest to wykonywane tylko jeden raz, na samym początku pętli.
  2. Sprawdzany jest warunek - jeśli jest fałszywy to następuje skok do kroku 6.
  3. Wykonywane są instrukcje do wykonania.
  4. Wykonywane są instrukcje zawarte w części inkrementacja.
  5. Następuje skok do kroku 2.
  6. Pętla kończy się - wykonuje się następna instrukcja za pętlą.
Żaden z podanych parametrów nie jest wymagany, więc najprostszą pętlą przy użyciu for jest: 
for(;;)
{
     instrukcje do wykonania
}

Taka konstrukcja jest pętlą nieskończona - będzie wykonywała się aż do momentu, gdy użytkownik zresetuje komputer (bądź zakończy program przy pomocy odpowiedniego polecenia systemu operacyjnego) lub gdy program napotka instrukcję break.

Przykład: 

#include <stdio.h>
void main(void)
{ int i;
  printf("Początek pętli\n");
  for(i = 0; i < 10; i++)
  { printf("Licznik pętli = %d\n", i);
  }
  printf("Koniec pętli\n");
}
W części inicjalizacyjnej dokonujemy ustawienia zmiennej i na 10. Mogliśmy to zrobić wcześniej (np. przy deklaracji) i część tą zostawić pustą. Następnie jest warunek wyjścia z pętli. Zmniejszenia licznika nie dokonujemy wewnątrz pętli, lecz w części inkrementacja. Możemy to robić wewnątrz pętli, a tą cześć pozostawić pustą, ale zostało to zapisane w ten sposób, aby zaprezentować sposób użycia.

Części inicjalizacja i inkrementacja mogą zawierać po kilka instrukcji: oddzielamy je wtedy przecinkami. Żeby to zobaczyć zmodyfikujemy poprzedni program dodając jeszcze jedną zmienna, która jest podwajana przy każdym przejściem pętli: 

#include <stdio.h>
void main(void) 
{ int i, n;
  printf("Początek pętli\n");
  for(i=0, n=1; i < 10; i++, n*=2)
  { printf("Licznik pętli = %d\n", i);
    printf("Zmienna n       = %d\n", n);
  }
  printf("Koniec pętli\n");
}

Instrukcja if

Instrukcja if służy do warunkowego wykonania innej instrukcji.
Składnia:

if (wyrażenie) instrukcja1;
lub
if (wyrażenie) instrukcja1; else instrukcja2;
W obu przypadkach wykonanie instrukcji if rozpoczyna się od obliczenia wartości wyrażenia. Jeżeli obliczona wartość jest równa 0, to program uznaje to za fałsz. Każda wartość różna od 0 traktowana jest jako prawda.
Jeżeli w pierwszej składni wartością wyrażenia jest prawda, to wykonywana jest instrukcja1, a w przeciwnym razie wykonywana jest następna instrukcja po instrukcji if.
Jeżeli w drugiej składni wartością wyrażenia jest prawda, to wykonywana jest instrukcja1, a jeśli fałsz to wykonywana jest instrukcja2.
Uwaga: ponieważ instrukcje if można zagnieżdżać, to powinieneś pamiętać, że klauzula else należy zawsze do ostatniej instrukcji if, która nie miała swojego else.

Przykłady: 

#include <stdio.h>
void main(void)
{ unsigned int i=7;
  if (i) printf("Warunek jest prawdziwy");
  ...
  if (i % 2 == 0) printf("Liczba %d jest parzyste", i);
  else printf("Liczba %d jest nieparzyste", i);
  ...
  if (i >= 100) printf("Liczba %d jest co najmniej trzycyfrowa", i);
  else if (i >= 10) printf("Liczba %d jest dwucyfrowa", i);
  else printf("Liczba %d jest jednocyfrowa", i);
}
Pierwsza instrukcja if wyświetli napis Warunek jest prawdziwy, ponieważ 7 jest różne od 0, co oznacza prawdę..
W drugim użyciu instrukcji if wyświetlony zostanie napis Liczba 7 jest nieparzyste, ponieważ reszta z dzielenia 7 przez 2 nie jest równa 0.
Trzecia instrukcja if wyświetli napis Liczba 7 jest jednocyfrowa, ponieważ warunki w pierwszej i drugiej instrukcji if są fałszem, to zadziała instrukcja podana za ostatnim else.

Instrukcja pusta

Instrukcja pusta jest pustym ciągiem znaków zakończonym średnikiem (;). Korzystamy z niej w instrukcjach pętli lub warunkowych, gdy wymagane jest użycie chociaż jednej instrukcji, a my nie chcemy niczego robić.

Instrukcja return

Instrukcja return kończy wykonanie funkcji i powoduje powrót do miejsca jej wywołania. Użycie instrukcji return w funkcji main powoduje zakończenie programu.
Składnia:

return wyrażenie;
Jeśli funkcja nie deklaruje wartości powrotnej, to po słowie return nie podaje się żadnego wyrażenia. W przeciwnym przypadku w instrukcji powinno wystąpić wyrażenie o typie zgodnym pod względem przypisania z typem wyniku deklarowanym przez funkcję.

Przykład: 

#include <stdio.h>
float kwadrat(float x)
{ return (x * x); }

void main(void)
{ float i;
  i = kwadrat( 1.25);
  printf("Kwadrat 1.25  = %f\n", i);
  return;
}
Pierwsza instrukcja return (użyta w funkcji kwadrat) zwraca iloczyn liczb typu float, co jest zgodne z typem zadeklarowanej funkcji. W funkcji main instrukcja return niczego nie zwraca, gdyż funkcję zadeklarowaliśmy jako void.

Instrukcja switch

Kombinacja instrukcji if...else, w przypadku głębokiego zagnieżdżenia są mało efektywne w wykonaniu i nieczytelne w kodzie programu. Alternatywnym rozwiązaniem jest użycie instrukcji switch, która pozwala na wyszczególnienie dowolnej liczby wartości.
Tak wygląda składnia instrukcji:

switch(wyrażenie) {
case wartość1: instrukcje1; break;
case wartość2: instrukcje2; break;
....
case wartośćN: instrukcjeN; break;
default: instrukcje;
}
wyrażenie to dowolne poprawne wyrażenie, a instrukcje to dowolne instrukcje (również instrukcja złożona). Instrukcja switch oblicza wartość podanego wyrażenia i porównuje z wartościami podanymi przy case. W instrukcji switch sprawdzana jest tylko relacja równości, nie ma możliwości wykorzystania innych relacji. Jeśli któraś z wartości przy case jest równa wartości wyrażenia, to program przechodzi do podanych dalej instrukcjiX i wykonuje wszystko do końca bloku switch lub do napotkania pierwszej instrukcję break. Jeśli żadna z wartości nie jest równa wartości wyrażenia to wykonywane są instrukcje przy słowie kluczowym default. Jeśli nie określimy instrukcji default i program nie odnajdzie pasującej wartości, to instrukcja switch nie zrobi nic, zostanie pominięta. Dobrym zwyczajem jest wykorzystywanie instrukcji default. Nawet jeśli nie musisz jej używać, to wykorzystaj ją do ewentualnego wypisania niepoprawnej, nie występującej przy żadnym case wartości i poinformowania o błędzie. Takie postępowanie pozwoli na łatwiejsze wyszukiwanie błędów w programach. Jeżeli nie ma instrukcji break na końcu każdego case, to program wykona wszystkie instrukcje od pasującego case aż do końca switch (jeżeli gdzieś niżej napotka break, to oczywiście przerwie wykonywanie).
Etykiety case mogą być grupowane, np: 
switch(liczba) {
  case  1 :
  case  2 :
  case  3 :
  case  4 : printf("Liczba jest między 1 a 4"); break;
  default : printf("Liczba spoza zakresu");
}
Spowoduje to wyświetlenie komunikatu Liczba jest mniejsza od 5, jeżeli liczba będzie równa 1, 2, 3 lub 4.

Przykład: 

#include <stdio.h>
void main(void)
{ int X;
  ...
  switch(X) {
    case 4 : printf("Zmienna X jest równa cztery.\n"); break;
    case 5 :
    case 6 : printf("Zmienna X jest równa pięć lub sześć.\n"); break;
    default: printf("Zmienna X jest nie jest równa ani cztery, ani pięć, ani sześć.\n");
  }
}

Instrukcja while

Składnia wygląda następująco:

while(warunek)
{
   instrukcje do wykonania
}
Pętla ta działa na podstawie następującego algorytmu:
  1. Sprawdzany jest warunek - jeśli jest fałszywy to następuje skok do kroku 4.
  2. Wykonywane są instrukcje do wykonania.
  3. Następuje skok do kroku 1.
  4. Pętla kończy się - wykonuje się następna instrukcja za pętlą.

Przykład: 

#include <stdio.h>
void main(void)
{ int i = 0;
  printf("Początek pętli\n");
  while(i < 10)
  { printf("Licznik pętli = %d\n", i);
    i++;
  }
  printf("Koniec pętli\n");
}
Algorytm działania tego programu wygląda następująco:
  1. Wpisz wartość 0 do zmiennej i.
  2. Wyświetl tekst informujący o rozpoczęciu działania pętli.
  3. Instrukcja while - sprawdza czy wartość zmiennej i jest mniejsza od 10 (na początku jest, bo wpisaliśmy do niej 0) i jeśli tak to przechodzi do wiersza z wywołaniem funkcji printf, wewnątrz bloku. Gdybyśmy zainicjalizowali zmienna i wartością 20, to od razu skoczylibyśmy do kroku 7 i na ekranie pojawiłby się napis o zakończeniu pętli. Warunek przy instrukcji while byłby od razu fałszywy, w związku z czym program przeszedłby do pierwszej instrukcji za pętlą.
  4. Wewnątrz bloku instrukcja printf wyświetla informację o stanie licznika.
  5. Zwiększamy wartość zmiennej i o 1.
  6. Wracamy do kroku 3 - sprawdzenie warunku i w zależności od tego, czy zmienna i osiągnęła już 10, czy nie, program będzie kontynuował działanie od kroku 4, albo 7.
  7. Wyświetlamy informację o zakończeniu działania pętli.

Instrukcja złożona

Instrukcja złożona składa się z nawiasu klamrowego otwierającego, dowolnych instrukcji (mogą być również kolejne zagnieżdżone instrukcje złożone) i nawiasu klamrowego zamykającego. Instrukcja złożona jest jedyną instrukcją w języku C++ która nie kończy się średnikiem. Konstrukcje taką stosuje się wszędzie tam, gdzie składnia języka przewiduje jedną instrukcję, a chcemy wykonać więcej niż jedną instrukcję.

Przykład: 

{
  siuma = 0;
  for ( x=0 ; x!=10 ; x++ )
  { if (x % 2 ==0) { printf ("%d jest liczba parzystą\n", x);    }
    else           { printf ("%d jest liczba nieparzystą\n", x); }
  }
}