Dyrektywy preprocesora
Preprocesor jest to program wywoływany bezpośrednio przed uruchomieniem kompilatora. Przetwarza on tak zwane dyrektywy. Ten problem jest związany bezpośrednio z plikami nagłówkowymi. Posiadają one rozszerzenie "*.h". Pliki nagłówkowe stają się częścią tekstu kodu programu w chwili wystąpienia dyrektywy include. W plikach nagłówkowych umieszcza się deklarację funkcji i definicje struktur, klas i wyliczeń.

Istnieją następujące dyrektywy:
#include
Jest to dyrektywa która dołącza tekst z jakiegoś pliku w miejsce wystąpienia tej dyrektywy. Dyrektywa ta wymaga jednego parametru. Jest nim nazwa pliku który dołączmy plus ewentualnie katalog. Dołącza się przeważnie pliki nagłówkowe, ale nie tylko. Nazwa pliku może być podana w dwojaki sposób. W nawiasach kątowych < > lub w cudzysłowach " ". Dwa rodzaje zapisu ma dwojakie znaczenie. Jeżeli nazwa pliku wystąpi w nawiasach kątowych to preprocesor wie że plik znajduje się w domyślym katalogu kompilatora z plikami nagłówkowymi, i tam szuka takiego pliku. Przeważnie jest to katalog który nazywa się INCLUDE w katalogu gdzie mamy zainstalowany kompilator. Jeżeli wystąpią cudzysłowa to preprocesor szuka pliku w katalogu gdzie robiony jest projekt. np.
#include "iostream.h";
#include "mojplik.h";
#define
Dyrektywa ta służy do definiowania zmiennych globalnych. Taka zmienna może ale nie musi posiadać wartości. Jest to wykorzystywane przy nazywaniu pewnych części plików nagłówkowych, lub nadawaniu jakiś wartości zmiennym żeby nie było trzeba było szukać ich w programie. np.
#define __PLIK_H__
#define DWA 2
#ifdef
Jest to dyrektywa warunkowa. Sprawdza czy jest zdefiniowana zmienna o określonej nazwie. Jeżeli tak to wykonuje kod aż do wystąpienia dyrektywy #endif. Służy ona do sprawdzania dla jakiego systemu jest program kompilowany, oraz dla zabezpieczenia przed podwójnym zadeklarowaniem klas, zmiennych, funkcji. np.
#ifdef DEFINICJA
//jakiś kod
#endif
#ifndef
Ta dyrektywa działa podobnie jak powyższa z tym że wykonywany jest kod jeżeli zmienna nie została zdefiniowana.
#endif
Dyrektywa ta kończy obie powyższe instrukcje warunkowe.
#else
Ta dyrektywa ma takie samo znaczenie jak instrukcja else przy if. Musi ona występować po którejś dyrektywie warunkowej. Wykonywana jest jeżeli warunek dyrektywy warunkowej nie jest spełniony. np:
#ifdef DEFINICJA
//jakiś kod
#else #define DEFINICJA #endif

Zmienne
Zmienne są to takie komórki gdzie program trzyma swoje informacje. Programista je definiuje, nadaje im nazwę, a w kodzie źródłowym operuje nimi. Istnieje kilka rodzajów zmiennych.
Cztery typy podstawowe:
int - zmienna przechowująca liczby całkowite (-32768 : 32767)
char - zmienna przechowująca znaki (litery, itp.) (-128 : 127)
float - zmienna przechowująca liczby rzeczywiste (1,2E-38 ÷ 3,4E+38)
double - zmienna przechowująca liczby rzeczywiste (2,2E-308 ÷ 1,8E+308)

Można je jeszcze rozszerzać poprzez kwalifikatory:
unsigned - zmienna przechowuje tylko wartości dodatnie
signed - zmienna przechowuje wartości dodatniej ujemne
short - zmienna ma długość przynajmniej 2 bajtów
long - zmienna ma długość przynajmniej 4 bajtów
const - wartości zmiennej nie można modyfikować, jest to stała

Definiując zmienną musimy podać jej typ i jej nazwę. Ewentualnie wartość początkową. Przy nadawaniu nazwy trzeba pamiętać że kompilator ma swoje nazwy zastrzeżone i nie wolno w ten sposób nazywać zmiennych! Kompilator rozróżnia małe i duże litery, i trzeba uważać bo zmienna Abc jest inną zmienną niż abc.

Przykład definicji:
int liczba=1; //zadeklarowano zmienną o nawie liczba i przypisano jej wartość 1

Jeżeli zdefiniujemy zmienną i nadamy jej charakter const to wtedy nie możemy modyfikować jej wartości podczas wykonywania programu, i podczas definicji tej stałej musi być nadana wartość. Nadając takiej zmiennej często można się uchronić przed przypadkową zmianą wartości. Wartość stała potrzebna jest też do przy definiowaniu tablic. Wartość zmiennej możemy przypisać na kilka sposobów. Albo podając jej wartość liczbową albo podając jej wartość innej zmiennej.
Każda zmienna ma określony zasięg, czyli nie wszędzie jest ona dostępna. Największy zasięg ma zmienna która jest zdefiniowana na samym początku pliku przed definicją funkcji.
Signed i unsigned - tymi kwantyfikatorami ustalamy czy nasza zmienna będzie przybierała wartości ujemne czy też nie. Jeżeli nie wystąpi żaden z tych kwantyfikatorów to kompilator zakłada domyślnie że zmienna jest typu signed, czyli posiada wartości ujemne.

Instrukcje warunkowe
Instrukcja warunkowa if
Instrukcja if sprawdza nam konkretny warunek zamknięty w nawiasie okrągłym. Warunek może być złożony, stosując do tego operatory logiczne. Jeżeli warunek jest spełniony (wyrażenie logiczne ma wartość 0) to jest wykonywana instrukcja która występuje zaraz po nawiasie warunku, lub cały blok. Jeżeli natomiast warunek nie jest spełniony, to jeżeli zdefiniujemy else jest wykonywana instrukcja lub blok zaraz po else. Składnia:

if(warunek)
{
instrukcja1; // Wykonana gdy warunek jest spełniony
}
else
{
instrukcja2; // Wykonana gdy warunek okazał się być nieprawdą
}
Instrukcja warunkowa switch
Instrukcja warunkowa switch jest zbiorem warunków które mogą być spełnione. Program sprawdza po kolei warunki i jeżeli któryś jest spełniony to realizuje instrukcje które są mu przypisane. Składnia:

switch(warunek)
{
case wartość1: // jeżeli warunek == wartość1 to wykonuje instrukcje1
instrukcja1;
break;

case wartość2:
instrukcja2;
break;

default: // jeżeli nie jest spełniony żaden warunek to wykonaj instrukcja3
instrukcja3;
break;
};
Pętle
Pętla jest to instrukcja która powtarza pewien blok instrukcji, dopóki jest spełniony odpowiedni warunek.

pętla while
W wolnym tłumaczeniu: wykonuj dopóki jest spełniony warunek. Pętla while jest to pętla która działa w następujący sposób: Sprawdza czy warunek jest spełniony, jeżeli tak to wykonuje blok i ponownie sprawdza warunek. Jeżeli nie to ignoruje blok i kontynuuje działanie programu Składnia:

while (warunek)
{
instrukcje;
}
pętla for
Pętla for jest bardziej skomplikowana. Jest ona podobna do pętli while z tym że oprócz warunku ma jeszcze instrukcję inicjującą pętle (wykonywaną przed pierwszym sprawdzeniem warunku), oraz instrukcję wykonywaną po wykonaniu pętli. Składnia:

for (instrukcja1 ; warunek ; instrukcja2)
{
instrukcja3;
}
Jeżeli program natrafi na pętlę for to wykonuje instrukcja1, następnie sprawdzany jest warunek. Jeżeli jest on spełniony to wykonywana jest instrukcja3. Po jej wykonaniu wykonuje się instrukcje2, i sprawdza warunek. Jeżeli gdzieś warunek nie jest spełniony to program przerywa działanie pętli, lub wcale jej nie wykonuje. W odróżnieniu do pętli while ta pętla nie musi posiadać warunku, ani instrukcji 1 i 2. Można w ten sposób stworzyć pętlę nieskończoną. Trzeba tylko pamiętać żeby w nawiasach przy deklaracji pętli były dwa średniki.

pętla do - while
Ta pętla różni się tylko tym od pętli while że przed pierwszym sprawdzeniem warunku, wykonane są instrukcje w pętli. Dopiero po pierwszym wykonaniu pętli sprawdzany jest warunek. Reszta jest jak w pętli while. Składnia:

do{ instrukcje;}while (warunek);

 Instrukcje skoku bezwarunkowego
Istnieją trzy instrukcje skoków bezwarunkowych. Jeżeli program natknie się na tą instrukcję to wykona skok we wskazane (lub domyślne) miejsce. Oto one:
break - jeżeli sobie zażyczymy podczas wykonywania pętli przerwać jej działanie to możemy w każdej chwili to zrobić instrukcją break;
continue - jeżeli gdzieś w pętli wystąpi instrukcja continue to program pomija instrukcje występujące po niej i przystępuje do ponownego sprawdzenia warunku.
goto - skok pod wskazane miejsce w programie

Tablice
Tablice są to komórki tego samego rodzaju przyporządkowane tej samej nazwie. Definiuje się ją w następujący sposób:
int tablica[rozmiar];
W tym przykładzie tablica przechowuje wartości typu int. Oczywiście mogą w tablicy być przechowywane wszystkie rodzaje zmiennych. W tym przykładzie zdefiniowana jest tablica jedno wymiarowa. Jednak w razie potrzeby można zdefiniować tablicę kilkuwymiarową. Wtedy dopisujemy przy definicji kolejną parę nawiasów kwadratowych i wpisujemy w nie kolejny rozmiar. Do poszczególnych elementów tablicy odwołujemy się podając w nawiasach kwadratowych numer komórki w których znajduje się interesująca nas wartość. Istnieje możliwość przydzielenia dynamicznie pamięci dla tablicy. Czyli jeżeli nie wiemy jaka duża ma być tablica możemy przydzielić jej pamięć podczas wykonywania programu. Służy do tego operator new. Najpierw trzeba zdefiniować wskaźnik który będzie nam wskazywał na nowo utworzoną tablicę. Musi być on tego typu co elementy nowej tablicy. Następnie musimy mieć jakiś rozmiar. Potem zostaje nam tylko definicja nowej tablicy. np
int *tablica = new int[rozmiar];
Zdefiniowana tu została tablica z elementami typu int. Ilość tych elementów określa zmienna rozmiar.

Łańcuch
String -jest to jakiś ciąg znaków np. wyraz zapisany jako tablice typu char. Posiada ona tyle elementów ile zdanie ma liter plus \n a na samym końcu znak pusty '\0' oznaczający jego koniec. Definiuje się go w ten sposób:
char string[rozmiar];
lub
char string[]="tekst";
W tym drugim przypadku kompilator automatycznie przydziela wielkość tablicy dla stringa. Można tez tworzyć dynamicznie:
char *string;
string=new char[rozmiar];
Operatory
Operatory arytmetyczne
Operatory arytmetyczne działają na ogólnych wartościach wyrażenia, nie na poszczególnych bitach.
Mnożenie - mnoży przez siebie dwie liczby.
Ma on następującą składnię: 2 * 2
Dzielenie - dzieli przez siebie dwie liczby. Dzielnik nie może być zerem. Jeżeli nastąpi taka sytuacja to program przerwie działanie z komunikatem błędu dzielenia przez 0.
Składnia: argument / dzielnik
Dzielenie modulo zwraca resztę z dzielenia.
Składnia: liczba1 % liczba2
Istnieje jeszcze dodawania Składnia: 2 + 2 i odejmowania
Skladnia 2 - 2

Operatory bitowe
Operatory bitowe działają osobno na poszczególnych bitach zmiennych
Przesuwanie bitów w lewo.
Składnia: zmienna << 2 - przesuwa bity zniennej o 2 w lewo
Przesuwanie bitów w prawo.
Składnia: zmienna >> liczba bitów
Negacja bitowa zamienia w zmiennej wszystkie zera na jedynki i jedynki na zera.
Składnia: ~zmienna
Koniunkcja bitowa jest to mnożenie pojedynczych bitów. Koniunkcja daje wynik jeden na danej pozycji, gdy w we wszystkich zmiennych na tej pozycji jest jedynka. Jeżeli tylko na jednym miejscu jest 0 to wynikiem jest 0. Przykład:
01101011 - zmienna1
11001101 - zmienna2
01001001 - wynik
Składnia: zmienna1 & zmienna2
Różnica symetryczna - wynikiem jest na danej pozycji jedynka tylko w tedy gdy tylko w jednej zmiennej na danej pozycji jest jedynka. W przeciwnym wypadku jest 0.
01101011 - zmienna1
11001101 - zmienna2
10100110 - wynik
Składnia: zmienna1 ^ zmienna2
Alternatywa bitowa - wynikiem jest na danej pozycji jedynka w tedy gdy przynajmniej w jednej zmiennej na danej pozycji jest jedynka. W przeciwnym wypadku jest 0.
01101011 - zmienna1
11001101 - zmienna2
11101111 - wynik
Składnia: zmienna1 | zmienna2

Operatory porównania, relacji oraz operatory logiczne
Operatory te służą do obliczania wartości "prawda" lub "fałsz". Warunek prawdziwy daje wartość 1 natomiast fałszywy 0.
Negacja logiczna zamienia prawdę w fałsz, a fałsz w prawdę.Np. jeżeli wyrażenie: a==b jest prawdziwe i do niego zastosujemy wyrażenie !(a==b) to w wyniku otrzymamy fałsz.
Składnia: !argument
Iloczyn logiczny - wynikiem jest prawda tylko wtedy gdy oba argumenty też są prawdziwe. Jeżeli tylko jeden jest fałszywy to wynikiem jest fałsz.
Składnia: argument1 && argument2
Suma logiczna - wynikiem jest prawda wtedy jeżeli przynajmniej jeden argument jest prawdziwy. Tylko jeżeli oba są fałszywe to wynikiem jest fałsz. Np:
01001010 - zmienna1
00101001 - zmienna2
01101011 - wynik
Składnia: argument1 || argument2
Równość - wynikiem jest prawda w tedy gdy wartości obu argumentów są takie same.
Składnia: argument1 == argument2
Nierówność - wynikiem jest prawda w tedy gdy wartości obu argumentów są różne.
Składnia: argument1 != argument2

Operatory relacji
Wynikiem jest prawda w tedy gdy jest spełniony warunek że coś jest większe, mniejsze, lub równe od siebie. Zależy on od operatora. Składnia:
argument1 < argument2
argument1 <= argument2
argument1 > argument2
argument1 >= argument2
Operator przypisania
Przypisuje zmiennej daną wartość lub wartość innej zmiennej.
Składnia: a = b;

Operatory zwiększania i zmniejszania
Operator zwiększania - dodaje on liczbę 1 do zmiennej przy której ten operator występuje.
Jest to skrót od wyrażenia: a = a + 1; lub a += 1;
Składnia: ++zmienna lub zmienna++
Operator zmniejszania - odejmuje on liczbę 1 do zmiennej przy której ten operator występuje.
Jest to skrót ot wyrażenia: a = a - 1; lub a -= 1;
Składnia: --zmienna lub zmienna--

Program
Na początek trzeba dołączyć pliki nagłówkowe. np.
#include "iostream.h"
Następnie trzeba zdefiniować funkcję główną programu (main).
void main()
{
 Tutaj wpisujemy kod który zostanie wykonany zaraz po uruchomieniu programu, gdyż zawsze na początku jest uruchamiana funkcja main(). na początek mozemy zadeklarować zmienne. np
int a, b, c;
 Przykładowo można przypisać im wartości i obliczyć ich sumę:
a=5;
b=10;
c=a+b;
 Na sam koniec można wyświetlić wynik na ekran (metodą strumieniową):
cout << "Wartość zmiennej c=" << c;
}