• Szerző: Sallai András
• Copyright © Sallai András, 2011, 2014
• Licenc: CC Attribution-Share Alike 4.0 International
• Web: https://szit.hu

A forráskód elkészítéséhez a CodeBlocks fejlesztő eszközt használjuk, amely a következő oldalon érhető el:

• http://codeblocks.org

Ha a gépeden nincs MingW telepítve akkor ez a változat szükséges: codeblocks-10.05mingw-setup.exe

Ha CodeBlocksot telepítesz, a használható fejlécállományokat itt találod:

c:\Program Files\CodeBlocks\MinGW\lib\gcc\mingw32\4.7.1\include\c++\

A forráskód lefordításához a GCC fordítót használjuk, amelynek Windowsos megvalósítása a MingW32. A MinGW32 fordító feltelepíthető külön is a következő oldalról:

• http://mingw.org

Egyéb fordítók

• Intel C++ Compiler http://en.wikipedia.org/wiki/Intel_C%2B%2B_Compiler
• Visual C++ http://en.wikipedia.org/wiki/Visual_C%2B%2B
• Borland C++ Compiler http://en.wikipedia.org/wiki/Borland_C%2B%2B
• Watcom C++ Compiler http://en.wikipedia.org/wiki/Watcom_C_compiler
• Még több C++ fordító: http://en.wikipedia.org/wiki/C%2B%2B_compiler#C.2FC.2B.2B_compilers

• http://www.iso.org/iso/catalogue_detail.htm?csnumber=38110

A fordítók csak részben ismerik (2011)

• http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372
• http://en.wikipedia.org/wiki/C++0x

A C++ nyelv kifejlesztője: Bjarne Stroustrup (Dánia)

• http://hu.wikipedia.org/wiki/Bjarne_Stroustrup

2003-as szabvány:

• http://www.iso.org/iso/catalogue_detail.htm?csnumber=38110

hello.cpp

#include <iostream>
using namespace std;
int main()
{
  cout << "Helló Világ" << endl;
  return 0;
}

Egy hesmárk (#) azt jelenti preprocessor direktíva következik. Ezek nem általános kódsorok, de a fordító számára megmondják, hogy ezeket a sorokat előre dolgozza fel.

A #include <iostream> sor azt mondja, hogy a lefordítandó programba fordítsuk bele az iostream állományt is.

Az std névtér használata. A C++ függvényei névterekbe vannak csoportosítva. A using namespace std; utasítással azt mondjuk, hogy szeretnénk az std névtérben lévő utasításokat használni.

A főfüggvény definíciójának kezdete. Az elején az int, azt jelenti, hogy a program végrehajtás után egy egész számmal tér vissza.

A cout egy utasítás, amely a folyamként átadott adatokat a képernyőre visszhangozza. A „«” karakterek mondják meg, hogy az utána következő adatot a cout vegye át folyamként. Az endl is kiíratásra kerül, amely egy sortörést reprezentál.

A főfüggvény vége. A programot arra utasítja, hogy 0 értékkel térjen vissza.

A forrásállományok kiterjesztése platformonként változhat. A szokásos kiterjesztések:

.C, .cc, .cpp, .cxx

Fejlécállományok a következők lehetnek:

.h, .hpp, hxx vagy kiterjesztés nélküli

A szabványos C++ könyvtárak kiterjesztés nélküliek. CodeBlocksal telepített MinGW esetén a helyük:

c:\Program Files\CodeBlocks\MinGW\lib\gcc\mingw32\4.7.1\include\c++\

A fenti program a sorait az átláthatóság miatt írtuk több sorba. Egy ilyen program függvény része, leírható akár egyetlen sorként is:

int main() { cout << "Helló Világ" << endl; return 0; }

A C++ nyelven mindent utasítást pontosvesszővel (;) zárunk. Ez jelöli az utasítás végét, így biztosítva, hogy egy sorba több utasítás is írható.

#include <iostream>

Az iostream állományban lévő függvényeket szeretném használni.

cout << "karaktersorozat" << endl;

A cout a képernyőre írja a paraméterként megadott adatokat. Idézőjelek közzé írjuk a kiírni kívánt karaktersorozatot. Az endl sortörést helyez el a képernyőn.

Az endl egy sortörést jelöl. Ha két képernyőre írató utasításom van, és az egyik végén nincs endl akkor ott nem lesz sortörés. Próbáljuk ki a következő programot:

egysor.cpp

#include <iostream>
using namespace std;
int main()
{
  cout << "Helló Világ";
  cout << "Egy C++ program vagyok" << endl;
  return 0;
}

A C++11 szabvány bevezet két új típust:

• char16_t - UTF-16 karakter
• char32_t - UTF-32 karakter

Módosítják a típust. Sorrendjük mindegy. Egy típusdefinícióban csak egyszer szerepelhetnek.

• signed - előjeles értelmezés (ez az alapértelmezett)
• unsigned - előjel nélküli értelmezés

• short - Célja a jó helykihasználás, amely legkevesebb 16 bites szám lesz.
• long - Cél, hogy legkevesebb 30 bites legyen
• long long - Cél, hogy legkevesebb 64 bites legyen (Csak C++11 szabvány)

unsigned short int szam;

A számváltozó 16 bites előjel nélküli szám lesz.

long long int szam;

A szam változó 8 bájtos lesz.

long double szam;

A szam változó 12 bájtos lesz.

A climits állományban a típusok maximális és minimális értéke lekérdezhető. Az int egész típus maximális értéke például így kérdezhető le:

maxint.cpp

#include <iostream>
#include <climits>
using namespace std;
 
int main()
{
	cout << INT_MAX << endl;	
	return 0;
}

További állandók az alábbi táblázatban találhatók:

casting [UK: ˈkɑːstɪŋ] [US: ˈkæstɪŋ]

esés, hajítás, horgászás, kimustrálás, öntés, öntvény, szereposztás, vetemedés

Az implicit konverzióhoz nem szükséges operátor. Ez automatikusan teljesül, amikor egy értéket adunk.

Például:

short a=2000;
int b;
b=a;

class A {};
class B { public: B (A a) {} };
 
A a;
B b=a;

A C++ erősen típusos nyelv. Néhány típuson explicit konverziót alkalmazhatunk.

short a=2000;
int b;
b = (int) a;    // c-stílusú kasztolás
b = int (a);    // függvényszerű jelölés

// class type-casting
#include <iostream>
using namespace std;
 
class CDummy {
    float i,j;
};
 
class CAddition {
	int x,y;
  public:
	CAddition (int a, int b) { x=a; y=b; }
	int result() { return x+y;}
};
 
int main () {
  CDummy d;
  CAddition * padd;
  padd = (CAddition*) &d;
  cout << padd->result();
  return 0;
}

• http://cplusplus.com/doc/tutorial/typecasting/

int a = 3;
double b = 4.5;
char c = 'a';
char d = '\n';
string e = "szilva";

Az egyenlőség jel jobb oldalán lévő értékek állandók. Állandók mert a futási időben ezeket nem változtatjuk meg. Mégpedig literális állandók.

#include <iostream>
using namespace std;
int main()
{
	int a = 0xff; //Hexadecimális szám megadása
	cout << a << endl;	
	return 0;
}

#include <iostream>
using namespace std;
int main()
{
	const int max = 5;
	cout << max << endl;
	return 0;
}

#include <iostream>
#define MAX 25
 using namespace std;
 int main()
{	
	cout << MAX << endl;
	return 0;
}

Formázott kivitelhez a iomanip fejállományt kell beillesztenünk.

mezo.cpp

#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
    int szam = 28;
 
    cout << setw(10) << szam << endl;
 
    return 0;
}

kitoltes.cpp

#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
    double szam = 28.12345;
 
 
    cout << setw(10) << setfill('0') << szam << endl;
 
    return 0;
}

A tizedesek száma lebegőpontos szám esetén:

prec.cpp

#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
 
    double szam = 2800.1234;
 
 
    //cout << setiosflags(ios::fixed) << setprecision(2) << szam << endl;
    cout << setprecision(2) << szam << endl;
 
    return 0;
}

Ha fixpontos ábrázolással szeretnénk ábrázolni:

prec.cpp

#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
 
    double szam = 2800.1234;
 
    cout << setiosflags(ios::fixed) << setprecision(2) << szam << endl;
 
    return 0;
}

vezetonulla.cpp

#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
    int szam = 58;
 
    cout << setfill('0') << setw(10) << szam << endl;
 
    return 0;
}

Dátum kiíratása:

datum.cpp

#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
	int ev = 1995;
	int ho = 1;
	int nap = 1;
 
	cout << setfill('0');
	cout <<  ev << '.' << setw(2) << ho << '.' << setw(2) << nap << endl;
 
	return 0;
}

Váltás 10-től eltérő számrendszerbe:

valtas.cpp

#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
	int szam = 15;
 
	cout << "Oktális szám: " << oct << szam << endl;
	cout << "Hexadecimális szám: " << hex << szam << endl;
 
	return 0;
}

• http://www.cplusplus.com/reference/iostream/manipulators/
• http://www.cprogramming.com/tutorial/iomanip.html

Valós számok esetén a tizedes jegyek számának meghatározása (két tizedesjegy beállítása):

#include <iostream>
#include <iomanip>
 
int main()
{
    double a;
    a = 328.2843824;
 
    cout.precision(2);
    cout << fixed << a << endl;
 
    return 0;
}

#include <iostream>
#include <iomanip>
 
int main()
{
    double a;
    a = 328.2843824;
 
 
    cout << setprecision(2) << fixed << a << endl;
 
    return 0;
}

A fixed beállítja, hogy fixpontos számábrázolást használjunk.

Abszolút érték számítása.

p01.cxx

#include <iostream>
#include <cmath>
using namespace std;
int main() {
	cout << abs(-9) << endl;	
	return 0;
}

Meghatározzuk egy változó értékét.

a = 5;

a = b;

a = 2 + (b = 5);

a = 11 % 3;

Az „a” értéke 2 lesz.

A ++ operátor növeli egy változó értékét, a – pedig csökkenti eggyel.

c++;
c+=1;
c=c+1;

A fenti három utasítások ugyanazt csinálja. Mindegyik növeli a c változó értékét 1-gyel.

Az inkrementáló és dekrementáló utasításokat írhatjuk a változó neve elé és után is. Egy értékadó kifejezés jobboldalán a viselkedésük eltér.

A táblázatban leírt példából láthatjuk, hogy ha a ++ operátor a B előtt van (++B), akkor előbb növeljük a B változó értékét, és csak az után tesszük azt egyenlővé az A változóval. Ha a ++ operátor a B változó után áll, akkor előbb eltároljuk az A változóban a B aktuális értékét, majd utána növelem a B változó értékét 1-gyel.

(8 == 5)     // az értékelés eredmény hamis (false)
(5 > 4)      // az értékelés eredmény igaz (true)
(3 != 2)     // az értékelés eredmény igaz (true)
(6 >= 6)     // az értékelés eredmény igaz (true)
(3 < 3)      // az értékelés eredmény hamis (false)

!(5 == 5)    // értéke false, mert a (5 == 5), és ennek ellenkezőjét kell venni.
!(6 <= 4)    // értéke true, mert (6 <= 4) kifejezés értéke false
!true        // értéke false
!false       // értéke true.

( (8 == 8) && (2 > 4) )  // értéke false ( true && false )
( (8 == 8) || (2 > 4) )  // értéke true ( true || false )

feltétel ? visszatérési_érték1 : visszatérési_érték2

8==3 ? 4 : 3     // visszatérési érték 3, mert 8 nem egyenlő 3-mal
7==5+2 ? 4 : 3   // visszatérési érték: 4, since 7 is equal to 5+2.
6>3 ? a : b      // visszatér a értékével, mivel 6 nagyobb mint 3
a>b ? a : b      // visszatér a nagyobbal, a vagy b-vel

A vesszőoperátor kettő vagy több kifejezés elválasztására való, ott ahol csak egy kifejezés írható.

A példa kedvéért egy kód:

a = (b=3, b+2);

Először a 3 rendelődik a b változóhoz, majd a b-hez 2-őt adunk, amely a végén a váltózóba kerül. A végén így a változó értéke 5 lesz.

Kasztolás néven ismert típusátalakítás.

int i;
float f = 3.14;
i = (int) f;

Az f változóban valós szám van, de az (int) kasztoló operátorral, egész típusúvá alakítjuk.

Ez az operátor egy paramétert fogad, amely egy típus vagy egy változó. Visszatér annak méretével bájtokban megadva.

Például:

a = sizeof (char);

A stringstream a <sstream> fájlban található és szövegalapú objektumok folyamként való kezelését teszi lehetővé. Ezzel könnyen átalakíthatunk karaktersorozatot számmá és vissza.

convert1.cpp

#include <iostream>
#include <sstream>
using namespace std;
 
int main()
{
	cout << "Hi" << endl;
	string str("384");
	int a;
	stringstream(str) >> a;
	cout << a << endl;
	return 0;
}

convert2.cpp

#include <iostream>
#include <sstream>
using namespace std;
 
int main()
{
 
	string str;
	float ar;
 
	cout << "Ar: ";
	getline(cin, str);
	stringstream(str) >> ar;
	cout << ar << endl;
 
	return 0;
}

aru.cpp

#include <iostream>
#include <sstream>
using namespace std;
 
int main()
{
 
	string str;
	float ar;
	int mennyiseg;
 
	cout << "Ar: ";
	getline(cin, str);
	stringstream(str) >> ar;
 
	cout << "Mennyiseg: " ;
	getline(cin, str);
	stringstream(str) >> mennyiseg;
 
	cout << "Fizetendo: " << ar * mennyiseg << endl;
 
	return 0;
}

#include <iostream>
#include <cmath>
 
using namespace std;
 
int main()
{
	char *str = "123";
 
	int a = atoi(str);
 
	cout << a * 2 << endl;
 
	return 0;
}

int a;
cin >> a;

A cin segítségével egy karaktert vagy egy karaktersorozatot kérhetünk be a billentyűzetről.

karakterbe.cpp

#include <iostream>
using namespace std;
int main()
{
    char cha, chb;
 
    cout << "Karakter: ";
    cin >> cha;
    cin.ignore();
    cout << "Karakter2: ";
    cin >> chb;
 
 
    cout << endl << "Első: " << cha << endl;
    cout << "Második: " << chb << endl;
 
 
    return 0;
}

Karaktersorozat esetén whitespace karakter után a karakterek tárolása megszakad. Írhatunk még karaktersorozatokat, de csak a whitespace előtti rész kerül a változóba. Így ezzel az utasítással csak egy szót kérhetünk be. Mi azonban nem mindig ezt szeretnénk. Ha szeretnénk egy egész mondatot bekérni akkor a getline() függvényt használhatjuk. A getline() több módon használható.

mondatbe.cpp

#include <iostream>
 
using namespace std;
 
int main()
{
	cout << "Mondat: ";
	string str;
	getline(cin, str);	
	cout << str << endl;
	return 0;
}

cin.get();

Egy billentyűnyomást vár. A lenyomott billentyűt el is tárolhatjuk:

char a = cin.get();

vagy

int a = cin.get();

A lenyomott billentyű egész számként is eltárolható. Ilyenkor az ASCII kódtáblában a billentyűnek megfelelő ASCII kód kerül tárolásra.

Egy programkód nem feltétlenül egymás után hajtódik végre. Vannak, amelyek végrehajtását bizonyos feltételhez kötjük. Vannak, amelyeket többször egymás után szeretnék végrehajtani. Vannak olyan utasítások, amelyeket szeretnénk együtt kezelni.

Az együtt kezelendő utasításokat blokkokba szervezzük. A blokkokat kapcsos zárójelekkel adjuk meg:

{ utasítás1; utasítás2; utasítás3;  }

Általánosságban a legegyszerűbb if feltételes utasítás a következő módon épül fel:

if (feltétel) utasítások

Az if után zárójelek között megadjuk a feltételt. A zárójel után megadunk egy utasítást vagy egy utasításblokkot.

if (x == 100)
  cout << "x tartalma 100" ;

int a;
cin << a;
 
if(a < 10)
  cout << "Kisebb mint 10" << endl;
else
  cout << "Nagyobb vagy egyenlő mint 10" << endl;

int a;
cin << a;
 
if(a < 10)
{
  cout << "Kisebb mint 10";
  cout << endl;
}
else
{
  cout << "Nagyobb vagy egyenlő mint 10";
  cout << endl;
}

int a;
cin >> a;
 
switch(a)
{
  case 3 : cout << "Három" << endl; break;
  case 5 : cout << "Öt" << endl; break;
  case 7 : cout << "Hét" << endl; break;
}

program01.cxx

#include <iostream>
using namespace std;
int main(int argc, char **argv) {
	char b;
	cin >> b; 
	switch(b) {
		case 'a': 
			cout << "A betű" << endl;
			break;
		case 'b': 
			cout << "B betű" << endl;
			break;
		default:
			cout << "Egyéb" <<endl;
	}
	return 0;
}

int a;
a = 0;
while(a < 10)
{
  cout << "alma" << endl;
  a++;
}

int a;
cin >> a;
for(a=0; a < 10; a++)
{
  cout << "alma" << endl;
}

Ha számokat visszafele szeretnénk megkapni, akkor: n--

#include <iostream>
using namespace std;
int main ()
{
  for (int n=10; n>0; n--) {
    cout << n << ", ";
  }
  cout << "TUZ!\n";
  return 0;
}

Az előkészítős részben és a növekményes részben megadható több utasítás a vessző operátor segítségével.

for ( n=0, i=100 ; n!=i ; n++, i-- )
{
   // amit tenni szeretnénk...
}

int i = 1;
 
do
{
    cout << "alma" << endl;
    i++;
}while (i <= 10);

#include <iostream>
using namespace std;
 
int main ()
{
  int n;
  for (n=10; n>0; n--)
  {
    cout << n << ", ";
    if (n==3)
    {
      cout << "számlálás leállítása!";
      break;
    }
  }
  return 0;
}

10, 9, 8, 7, 6, 5, 4, 3, számlálás leállítása!

// continue példa
#include <iostream>
using namespace std;
 
int main ()
{
  for (int n=10; n>0; n--) {
    if (n==5) continue;
    cout << n << ", ";
  }
  cout << "TUZ!\n";
  return 0;
}

10, 9, 8, 7, 6, 4, 3, 2, 1, TUZ!

goto

// goto példa
 
#include <iostream>
using namespace std;
 
int main ()
{
  int n=10;
  ciklus:
  cout << n << ", ";
  n--;
  if (n>0) goto ciklus;
  cout << "TUZ!\n";
  return 0;
}

10, 9, 8, 7, 6, 5, 4, 3, 2, 1, TUZ!

Az exit() függvény a cstdlib könyvtárban van definiálva.

Az exit() függvény megszakítja a program futását és visszaad az operációs rendszernek egy visszatérési értéket.

Az exit() fejrésze:

void exit (int exitcode);

Azonos típusok tárolására használt adatszerkezet.

Egydimenziós tömbök, vagyis kiterjedésük egyirányú.

Pl:

A tömbünk egész számokat tartalmaz. De lehet ugyanez valós számokkal

Vagy tartalmazhat karaktereket:

int egeszSzamok[5];
 
egeszSzamok[0] = 35;
egeszSzamok[1] = 42;
egeszSzamok[2] = 98;
egeszSzamok[3] = 22;
egeszSzamok[4] = 76;

Kezdőérték:

int egeszSzamok[5] = {35, 42, 98, 22, 76};

int matrix[4][7];

#include <iostream>
#include <fstream>
using namespace std;
int main()
{
    string s;
    ifstream in("test.dat"); //Megnyitás olvasásra
    ofstream out("test2.dat"); //Megnyitás írásra
    while(getline(in, s))		//Olvassunk be egy sort
    cout << s << "\n";			//Írjuk egy másik fájlba
 
    return 0;
}

#include <iostream>
#include <fstream>
using namespace std;
main()
{
    ofstream f
 
    f.open("test.txt");
 
    if(!f.is_open()) 
    {
      cerr << "A fájlt nem sikerült megnyitni" << endl;
      return;
    }
 
    f << "Kiírnivaló" << endl;
 
    f.close()
 
}

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
main()
{
 
    ifstream f
 
    f.open("test.txt");
 
    if(!f.is_open()) 
    {
        cerr << "A fájlt nem sikerült megnyitni" << endl;
        return;
    }
 
    string s;
    while(!f.eof())
    {
        f >> s;
        cout << s << endl;
    }
 
 
    f.close()
 
}

#include <iostream>
#include <fstream>
using namespace std;
 
 
int main() 
{
    long begin,end;
 
    ifstream f ("input.txt");
 
    // GET pointer lekérése
    begin = f.tellg();
 
    // file végére pozícionálunk
    f.seekg (0, ios::end);
    end = f.tellg();
    myfile.close();
 
    // különbség (fajlméret) kiírása
    cout << "Méret: " << (end-begin) << " byte.\n";
 
    return 0;
}

olvas.cpp

/* Olvasás szóközökkel tagotl fájlból */
#include <iostream>
#include <fstream>
 
using namespace std;
 
int main()
{
	ifstream befolyam("adat.txt");
	string str;
	int ar;
 
	befolyam >> str;
	befolyam >> ar;	
	while(befolyam.good()) 
	{
		cout << str << " ";
		cout << ar << endl;
		befolyam >> str;
		befolyam >> ar;
	}
	return 0;
}

Ha egy változót mutatóként hoztunk létre és már nincs rá szükségünk, lehetőségünk van a memóriafoglalást megszüntetni, azaz felszabadítani. Ezt a delete utasítással tehetjük meg:

#include <iostream>
using namesapce std;
 
main()
{
    int *a;
 
    a = new int;
 
    *a = 3;
 
    cout << *a << endl;
 
    delete(a);
}

Tömbök felszabadításakor a delete operátor után mindig használjuk az üres szögletes zárójelpárt ('[]'). Ezáltal a tömb minden elemére lefut a destruktor, felszabadítva a dinamikusan lefoglalt memóriaterületeket is. A szögletes zárójelpár nélkül csak az objektumhoz statikusan tartozó memóriaterület szabadul fel. Ha a zárójelbe a tömb méretétől eltérő szám kerül, akkor vagy nem szabadul fel az összes memória, vagy a destruktor olyan objektumra is meghívódik, ami nem is létezett. Az üres zárójelpár használatával ezek elkerülhetőek.

class a
{
    (...)
    friend globalisfuggvenyneve(parm. lista);
 
};
 
 
 
class b
{
    (...)
    friend class osztalynev;
 
};

  #include <ctime>    // time()
  #include <cstdlib>  // srand() és rand()
 
  srand(time(0));
  int r = (rand() % 10) + 1;  // 1 és 10 közötti szám

#include <iostream>
#include <string>
#include <sstream>
 
using namespace std;
 
main()
{
    string szoveg = "szilva:körte:barack";
 
    istringstream szovegfolyam(szoveg);
 
    string resz;
 
    while(getline(szovegfolyam, resz, ':'))
	cout << resz << endl;
}

#include <iostream>
#include <string>
using namespace std;
 
int main ()
{
	string line = "rovid vonal a teszteleshez";
 
 
	// with no arguments
	string s1;
	s1 = "András";
	cout << "s1: " << s1 << endl;
 
	// copy constructor
	string s2 (s1);
	cout << "s2: " << s2 << endl;
 
	// one argumen
	string s3 (line);
	cout << "s3: " << s3 << endl;
 
	// first argumen C string
	// second number of characters
	string s4 (line,10);
	cout << "s4: " << s4 << endl;
 
	// 1 - C++ string
	// 2 - start position
	// 3 - number of characters
	string s5 (s3,7,5); // copy word 'line' from s3
	cout << "s5: " << s5 << endl;
 
	// 1 - number characters
	// 2 - character itself
	string s6 (15,'*');
	cout << "s6: " << s6 << endl;
 
	// 1 - start iterator
	// 2 - end iterator
	string s7 (s3.begin(),s3.end()-5);
	cout << "s7: " << s7 << endl;
 
	// you can instantiate string with assignment
	string s8 = "Andras";
	cout << "s8: " << s8 << endl;
 
	return 0;
}

Darabolás újra:

darbolas3.cpp

#include <iostream>
#include <string>
#include <sstream>
 
main()
{
	std::string gyumolcs("alma:szilva:körte:barack");
	std::istringstream iss(gyumolcs);
	std::string token;
	while(getline(iss, token, ':')) {
		std::cout << token << std::endl;
	}
}

Egy kódrészlet, amelynek nevet adunk. Amikor használjuk a nevet a makró kódja behelyettesítődik. Kétféle makró van. Leginkább abban különböznek, ahogy használatkor kinéznek.

• Objektumszerű makró, mint amikor egy objektumot használunk
• Függvényszerű makró, mint amikor egy függvényt használunk

Definiálása:

#define BUFFER_SIZE 1024

Használata:

foo = (char *) malloc (BUFFER_SIZE);

Egy tömb megadása:

#define NUMBERS 1, \
                2, \
                3
    int x[] = { NUMBERS };

Olyan mintha ezt írtuk volna:

int x[] = { 1, 2, 3 };

#define lang_init()  c_init()

Ezek után, ha meghívjuk a következő függvényt:

lang_init()

akkor valójában ez a függvény hajtódik végre:

c_init()