• Efektem jej działania są efekty uboczne wyliczania wartości wyrażenia (sama wartość po jej wyliczeniu jest ignorowana).

• Zwykle instrukcjami wyrażeniowymi są przypisania i wywołania funkcji, np.:

  i = 23*k +1;
wypisz_dane(Pracownik);
  

• Szczególnym przypadkiem jest instrukcja pusta:
  ;
  użyteczna np. do zapisania pustej treści instrukcji pętli.

Jest to jedna z najważniejszych instrukcji w C++. Spełnia rolę trzech różnych instrukcji z Pascala (pustej, przypisania i wywołania procedury)! A jednocześnie łatwo ją zapisać omyłkowo (aczkolwiek w pełni poprawnie składniowo) tak, by nic nie robiła. Przyjrzyjmy się jej więc dokładniej.

Najprostsza jej postać to sam średnik (przy pominiętym wyrażeniu). W tej postaci pełni rolę instrukcji pustej. Wbrew pozorom czasem instrukcja pusta bywa przydatna, na przykład przy zapisywaniu prostych pętli (pętle omówimy wkrótce).

 // Wyszukanie pierwszego zera w tablicy t
 int i;
 for(i=0; i<n && t[i]!=0; i++)
 ;

Typowe zastosowanie instrukcji wyrażeniowej polega na zapisaniu w niej wyrażenia przypisania i zakończeniu go znakiem średnika. Wyliczenie takiej instrukcji polega na wyliczeniu wartości wyrażenia i … zignorowaniu tej wartości. Kiedy to ma sens? Wtedy, gdy wyliczenie wyrażenia ma efekty uboczne. Podstawowym wyrażeniem, którego wyliczenie ma efekt uboczny jest wyrażenie przypisujące. Na przykład i=0 jest takim wyrażeniem. Zrobienie z niego instrukcji wyrażeniowej jest bardzo proste - wystarczy dodać średnik.

 i = 0;

 i = j = k = 0;

 while((c = getc()) != ' '); // Instrukcja pusta jako treść pętli

Trzecia ważna forma instrukcji wyrażeniowej służy wywołaniu funkcji, które chcemy traktować jako procedury. W C++ są tylko funkcje, nie ma procedur, ale nie ma też obowiązku odczytywania wartości wyniku funkcji, można więc wywołać funkcję jako procedurę. Co więcej można zadeklarować funkcję, która nie daje wyniku - czyli funkcję pełniącą rolę procedury. Załóżmy, że mamy taką bezparametrową funkcję-procedurę o nazwie wypisz. Jej wywołanie można zapisać następująco:

 wypisz();

Oczywiście nie każde wyrażenie warto zamieniać na instrukcję wyrażeniową. Oto całkowicie poprawny i całkowicie bezużyteczny przykład instrukcji wyrażeniowej - wyliczenie podanego tu wyrażenia nie ma żadnych efektów ubocznych, więc równie dobrze można by tu wstawić instrukcję pustą lub po prostu usunąć tę instrukcję.

 13;

 wypisz; // powinno być wypisz();

Powiedziawszy o zaletach traktowania przypisania jako wyrażenia koniecznie musimy jednocześnie ostrzec o niebezpieczeństwach związanych ze stosowaniem efektów ubocznych. Choć sam język tego nie zabrania pamiętajmy, żeby nigdy nie nadużywać efektów ubocznych. Zilustrujemy to ostrzeżenie przykładami:

  i = 1;
  t[i] = i = 0;  // przypisanie 0 do t[1] czy t[0]?
  f(i=1,i=2);    // jaką wartość ma i po wywołaniu funkcji f?

• Pierwszy rodzaj instrukcji etykietowanej dotyczy instrukcji goto i nie będzie tu omawiany.

• Instrukcje etykietowane case i default mogą wystąpić jedynie wewnątrz instrukcji wyboru.

• Wyrażenie stałe stojące po etykiecie case musi być typu całkowitego.

Instrukcja etykietowana to po prostu dowolna instrukcja poprzedzona etykietą. Charakterystyczne dla C++ jest to, że owa etykieta może przyjąć jedną z kilku form.

Po pierwsze może być po prostu identyfikatorem. W tej postaci instrukcja etykietowana służy jako wskazanie miejsca, do którego należy skoczyć w instrukcji goto (instrukcji skoku). Ponieważ instrukcja skoku jest powszechnie uważana za szkodliwą i od dawna nie występuje w nowych językach programowania pomijamy ją (i tę postać instrukcji etykietowanej) w naszym wykładzie.

Druga i trzecia postać instrukcji etykietowanej dotyczy instrukcji wyboru (instrukcji oznaczonej w C++ słowem kluczowym switch). Dlatego omówienie tych instrukcji znajduje się w omówieniu instrukcji wyboru. Tu zaznaczmy tylko, że obie te formy instrukcji etykietowanej mogą występować wyłącznie wewnątrz instrukcji wyboru, a wyrażenie stałe występujące po słowie kluczowym case

.	blok:
.	.

• Służy do zgrupowania wielu instrukcji w jedną.

• Nie ma żadnych separatorów oddzielających poszczególne instrukcje.

• Deklaracja też jest instrukcją.

• Instrukcja złożona wyznacza zasięg widoczności.

Instrukcja złożona (zwana czasem blokiem) służy do grupowania wielu instrukcji w jedną oraz do wyznaczania zasięgu deklaracji zmiennych. Grupowanie instrukcji jest często potrzebne ze względu na składnię języka, która w wielu miejscach (np. jako treść pętli) wymaga pojedynczej instrukcji. Jeśli chcemy w takim miejscu umieścić kilka (lub więcej) instrukcji, to musimy użyć instrukcji złożonej. Ta instrukcja jest pomocna także wówczas, gdy chcemy zadeklarować zmienną, która ma być widoczna tylko w najbliższym otoczeniu deklaracji.

Warto zwrócić uwagę, że składnia C++ nie wymaga żadnych separatorów pomiędzy poszczególnymi instrukcjami - każda instrukcja C++ kończy się średnikiem lub prawym nawiasem klamrowym, nie ma więc potrzeby stosowania dodatkowych separatorów. W instrukcji złożonej może występować dowolna liczba instrukcji składowych (w szczególności może ich być 0, ale nie jest to użyteczny przypadek).

Wykonanie instrukcji złożonej polega na wykonaniu po kolei instrukcji składowych (zostaną wykonane wszystkie, o ile w czasie ich wykonywania nie pojawi się instrukcja zmieniająca przepływ sterowania w programie - taka jak np. return;).

Ważne jest zauważenie, że w C++ deklaracja zmiennej (można również deklarować klasy, struktury, wyliczenia lub nazywać typy za pomocą typedef ale te deklaracje zwykle są globalne) też jest instrukcją. Czyli można zadeklarować zmienną lokalnie - wewnątrz bloku. Taka zmienna jest widoczna od miejsca deklaracji do końca bloku. Jeśli przy deklaracji podano inicjalizator, to przy zmiennych automatycznych będzie on wykonywany za każdym razem, gdy sterowanie dojdzie do tej deklaracji, zaś dla zmiennych statycznych deklaracja zostanie wykonana tylko raz, przed wejściem do bloku. Lokalnie zadeklarowana zmienna automatyczna jest niszczona, gdy sterowanie opuszcza blok. Z powyższych rozważań wynika, że zmienne lokalne w bloku mogą być deklarowane w dowolnym jego miejscu (nie koniecznie na początku, choć zwykle tak się dzieje).

Oczywiście nie można deklarować w jednym bloku dwu zmiennych o tej samej nazwie. Jeśli na zewnątrz bloku jest zadeklarowany identyfikator użyty w deklaracji lokalnej, to jest on przesłonięty od miejsca deklaracji do końca bloku. Oto przykład:

 struct ff{int k;} f;
 //...
 f.k++;     // poprawne
 int f=f.k; // niedozwolone
 f++;       // poprawne

• Wyrażenie musi być typu logicznego, arytmetycznego lub wskaźnikowego.

• Wartość warunku jest niejawnie przekształcana na typ bool.

• Jeśli wartość wyrażenia jest liczbą lub wskaźnikiem, to wartość różna od zera jest interpretowana jak true, wpp. za false.

• else dotyczy ostatnio spotkanego if bez else.

• Warunek może być także deklaracją (z pewnymi ograniczeniami) mającą część inicjującą, jej zasięgiem jest cała instrukcja warunkowa.

• Instrukcja składowa może być deklaracją (jej zasięgiem zawsze jest tylko ta instrukcja składowa).

Instrukcja warunkowa służy warunkowemu wykonaniu instrukcji. Wykonanie instrukcji warunkowej zaczyna się od obliczenia wartości wyrażenia i niejawnego przekształcenia jej do typu bool. Jeśli tak otrzymana wartością jest true, to wykonywana jest pierwsza podinstrukcja, jeśli zaś tą wartością jest false to, o ile jest część else, wykonywana jest druga podinstrukcja.

 if (i>=0)
  cout << "nieujemne";
 else
  cout << ujemne";

Ciekawostką (odziedziczoną po C) jest to, że typem wyrażenia pełniącego rolę warunku może być typ liczbowy lub nawet wskaźnikowy. Jeśli wartość takiego wyrażenia jest różna od zera (dla wskaźników oznacza to wskaźnik o wartości różnej od NULL), to jest ono traktowane jako warunek prawdziwy (a w przeciwnym przypadku jako fałszywy).

 if (i)
  i = 0;

 if (p)
  i = *p;
 else
  i = 0;

Jeśli jedna instrukcja warunkowa jest zagnieżdżona w drugiej i nie każda z nich ma część else, to powstaje problem składniowy, z którą instrukcją warunkową powiązać tę część else.

 if (i>=0)
  if (i>0)
    cout << "dodatnie";
  else // do której instrukcji if?
   cout << "??";

 if (i>=0)
  if (i>0)
    cout << "dodatnie";
  else // (i>=0) && !(i>0)
   cout << "równe zero";

 if (i>=0)
  {if (i>0)
    cout << "dodatnie";}
 else // !(i>=0)
  cout << "ujemne";

Subtelności związane z deklarowaniem zmiennych w warunku lub w przypadku zapisania instrukcji deklaracji jako podinstrukcji instrukcji warunkowej pomijamy.

• Powoduje przekazanie sterowania do jednej z podinstrukcji występujących w instrukcji, o etykiecie wyznaczonej przez wartość wyrażenia.

• Wyrażenie musi być typu całkowitego.

• Podinstrukcje (wewnątrz instrukcji) mogą być etykietowane jedną (kilkoma) etykietami przypadków: case wyrażenie_stałe :

• Wszystkie stałe przypadków muszą mieć różne wartości.

• Może wystąpić (co najwyżej jedna) etykieta: default : Nie musi być ostatnią etykietą, bo i tak zawsze najpierw są analizowane etykiety case.

• Podczas wykonywania instrukcji switch oblicza się wartość wyrażenia, a następnie porównuje się ją ze wszystkimi stałymi występującymi po case. Jeśli któraś z nich równa się wartości warunku, to sterowanie jest przekazywane do instrukcji poprzedzonej etykietą z tą wartością, wpp. jeśli jest etykieta default, do instr. poprzedzonej tą etykietą, wpp. sterowanie przechodzi bezpośrednio za instr. switch. Ponieważ sterowanie przekracza etykiety case i default, prawie zawsze trzeba jawnie kończyć wykonywanie obsługi przypadku instrukcją break!.

• Wyrażenie może być także deklaracją (z pewnymi ograniczeniami), której zasięgiem jest dana instrukcja.

• Ta deklaracja musi zawierać część inicjalizującą.

• Instrukcja może być deklaracją, (jej zasięgiem zawsze jest tylko ta instrukcja).

• Wartość wyrażenia jest niejawnie przekształcana na typ całkowity lub wyliczeniowy.

Czasem wybór jednej z dwu operacji nie wystarcza, wtedy często można zastosować instrukcję wyboru switch. Nie jest ona niestety tak wygodna jak np. w Pascalu. Jej wykonanie polega na wyliczeniu wartości wyrażenia (musi ono być typu całkowitego lub wyliczeniowego), a następnie na wyszukaniu w instrukcji składowej (która praktycznie zawsze jest instrukcją złożoną) instrukcji z etykietą case i wyrażeniem o szukanej wartości. Jeśli taka instrukcja się znajdzie (może być co najwyżej jedna taka instrukcja), to sterowanie przechodzi bezpośrednio za tę etykietę. Jeśli takiej etykiety nie ma, a jest instrukcja z etykietą default, to sterowanie przechodzi do niej, w przeciwnym przypadku sterowanie przechodzi za instrukcję switch.

Przy wyborze podinstrukcji pasującej do wyrażenia kolejność instrukcji składowych nie ma znaczenia. W szczególności instrukcja z etykietą default nie musi być ostatnia (choć zwykle, dla czytelności, umieszcza się ją na końcu).

Jeśli dla kilku wartości wyrażenia ma być wykonany ten sam zestaw czynności, to te instrukcje poprzedzamy ciągiem etykiet case. Na przykład chcąc wykonać tę samą akcję dla wartości zmiennej i tak -1 jak i 1 można zapisać stosowną instrukcję wyboru następująco:

  switch (i){
    case -1: case 1:  i =- i;
  }

Nie ma niestety możliwości ani pominięcia powtarzających się słów kluczowych case, ani podania przedziału wartości, dla których ma się wykonać operacja. To ostatnie powoduje, że jeśli chcemy wybrać wykonywane operacje dla przedziałów wartości np. 0..99, 100..199, 200..299, to instrukcja wyboru staje się bezużyteczna (trzeba wtedy wybrać instrukcję warunkową). Jest to dość rozczarowujące w porównaniu np. z Pascalem.

Tym co zapewne powoduje najwięcej kłopotów przy używaniu instrukcji switch jest jej nieintuicyjna semantyka (oparta na semantyce instrukcji skoku). Otóż po wybraniu odpowiedniej etykiety i wykonaniu instrukcji nią opatrzonej sterowanie nie przechodzi za instrukcję switch, lecz przechodzi do kolejnych instrukcji znajdujących się po niej w instrukcji switch!. W kolejnym przykładzie dla znaku ch mającego wartość 'C' wykonają się oba przypisania, czyli wynik końcowy będzie taki sam, jak dla ch == 'b'.

  switch (ch){
    case 'C': cout << "stopnie Celsjusza";
    case 'K': cout << "stopnie Kelvina";
  }

  switch (ch){
    case 'a': i = 1; break;
    case 'b': i = 2; break;
  }