1. statikus tömbök

int t1[5]; //5 hosszú statikus tömb, t[0]..t[4]

int t2[] = {-1,0,1}; //3 hosszú lesz, kezdeti értékeket is kapnak a tömbelemek

int t3[5] {0,1}; //első két elem értéket kap, a tömb vége 0-val lesz feltöltve

int n;
cin>>n;
int t4[n]; //Nem a C++ szabvány szerinti, de lefordul, a tömb mérete futási időben derül ki

int m1 [3][10]; //statikus mátrix

int n;
cin>>n;
int m2 [n][100]; //Nem szabvány, de használható

int n,m;
cin>>n>>m;
int m3[n][m]; //Lefordul, de paraméterként nem tudjuk átadni

//a tömb átadása paraméterként - paraméterátadáskor a méretét is át kell adni!

void alprogram(int [],int); //a függvény szignatúrájában elég csak a paraméterek típusát, és átadási módját jelölni

void alprogram(int x[], int meret) { ....} //a függvény definíciójakor nevet kapnak a paraméterek

alprogram(t1,5); //így hívjuk meg a t1 tömbbel az alprogramot

alprogram (m1[0],10)) //meghívhatjuk a mátrix egy sorával is

//mátrix paraméterként

void alprogram1(int x[3][10]){ ..} //megadjuk a sorok és oszlopok számát

void alprogram2(int [][10], int); //ez a fgv. szignatúrája, csak az első dimenzió lehet ismeretlen méretű

void alprogram2(int x[][10],int size) {...} //itt jönne a definíció, size - paraméter adja meg a sorok számát

alprogram2(m1,3); //meghívás m1 mátrixra

2. STL vector

#include <vector>

vector<int> t4(5); //öt elemű egész típusú tömb

vector< vector<float> > m2(3,vector<float>(10)); //3 x 10 -es valós típusú mátrix

//Ezzel már megoldható, hogy az alprogram hozza létre a tömböt

void beolvas(vector<int>&); //Ha az alprogram hozza létre a tömböt fontos a cím szerinti paraméter átadás!
void beolvas(vector< vector<double> >&); 

int main(){
...
vector<int> t; 
beolvas(t);
int n=t.size(); //beolvas függvény foglalta le a megfelelő méretű tömböt, itt csak lekérdezzük a méretét
...
vector< vector<double> > m;
beolvas_matrix(m);
int dim1=m.size(); //sorok száma
int dim2=m[0].size() //0. sor hossza (oszlopok száma, ha minden sor egyforma hosszú)
...
}

3. Dinamikus tömb

int* t1=new int[5]; //5 elemű dinamikusan létrehozott tömb
...
cout<<t1[4]<<endl; //a tömböt a szokott módon indexelhetjük
cout<<t1<<endl; //ez a tömb címét írja ki
cout<<*t1<<endl; //ez a tömb első elemének értékét írja ki
cout<<*t1+1<<endl; //ez a töm belső elemének értékét 1-gyel megnövelve írja ki
cout<<*(t1+1)<<endl; //ez a tömb második elemét írja ki
//Egy érdekes ciklus a tömb elemeinek kiírására:
for(int* mut=t1; mut<t1+5;++mut) cout<<*mut<<" ";
cout<<endl;

delete [] t1; //a tömböt "kézzel" kell felszabadítani, ha már nem kell!
cout<<t1[0]<<endl; //bizonytalan az érték, mert a tömb helyét már felszabadítottuk

//alprogrammal létrehozott dinamikus tömb - első megoldás void függvénnyel

void letrehoz_tomb(int* &, int&); //Első paraméter lesz a tömb címe, második a mérete.
//FONTOS, hogy mindkét paraméter cím szerinti! A méretet is vissza kell adni! 

int main(){
...
int* t2;
int meret;
letrehoz_tomb(t2,meret);
...
}

void letrehoz_tomb(int* & tomb, int& meret){
   cout<<"Elemszam:"; cin>>meret;
   if(meret<1) {cerr<<"hibas tombmeret"; exit(1);}
   tomb=new int[meret];
   return;
}

//alprogrammal létrehozott dinamikus tömb - második megoldás a függvény a tömb címével tér vissza

int* letrehoz_tomb2(int&); //most csak a méret lesz paraméter 

int main(){
...
int* t3;
int meret;
t3=letrehoz_tomb2(meret);
...
}

int* letrehoz_tomb2(int& meret){
   cout<<"Elemszam:"; cin>>meret;
   if(meret<1) {cerr<<"hibas tombmeret"; exit(1);}
   int* tomb=new int[meret];
   return tomb;
}

int** matrix; // mátrix mutatója
int dim1, dim2; //sorok és oszlopok száma 
cout<<"sorok szama:";
cin>>dim1;
cout<<"oszlopok szama:";
cin>>dim2;
matrix = new int*[dim1]; // minden sora egy pointert tartalmaz
for (int i = 0; i < dim1;  ++i)
    matrix[i] = new int[dim2]; // a pointerek mutatnak a sort tartalmazó tömbre
...

matrix[i][j]=... //hivatkozás a szokott módon

//mátrix felszabadítása:
for (int i = 0; i < dim1;  ++i)
    delete[] matrix[i]; // egyes tömbök törlése
delete[] matrix; // mutatótömb törlése