Jednorozměrná pole

Deklarujeme pole deseti celých čísel

    int a [10];

Překladač pro proměnnou a vyhradí místo stejně dlouhé jako deset celočíselných proměnných.
K jednotlivým položkám přistupujeme pomocí a[0], a[1], … , a[9].
První položka má index 0.

Pokud chceme naplnit pole hodnotami 10, 20, … , 100

     a[0]   a[1]   a[2]   a[3]   a[4]   a[5]   a[6]   a[7]   a[8]   a[9]
   -----------------------------------------------------------------------
   |  10  |  20  |  30  |  40  |  50  |  60  |  70  |  80  |  90  | 100  |
   -----------------------------------------------------------------------

Můžeme to udělat následujícím programem

#include <iostream>
using namespace std;
 
int a [10]; 
 
int main ()
{
    for (int i = 0; i < 10; i ++)
    {
       a[i] = 10*(i+1);
    }
 
    for (int i = 0; i < 10; i ++)
    {
        cout << "a " << i << " ... " << a[i] << endl;
    }
}

#include <iostream>
using namespace std;
 
int a [10];
 
int main ()
{
    for (int i = 0; i < 10; i ++)
    {
       a[i] = 10*(i+1);
    }
 
    int sum = 0;
    for (int i = 0; i < 10; i ++)
    {
        sum = sum + a[i];
    }
    cout << "soucet " << sum << endl;
}

Velikost pole můžeme zadat také konstantou (nebo konstantním výrazem, tj, výrazem složeným jen z konstant)

Pole je možné inicializovat seznamem hodnot ve složených závorkách. ( Pokud zadáme příliš málo hodnot, zbývající položky pole mají nedefinovanou hodnotu. )

const int N = 10;
int b [N] = { 7, 3, 12, 5, 20, 2, 8, 1, 22, 7 };

Nemusíme zadávat délku pole.
Za poslední hodnotou může být čárka navíc.

#include <iostream>
using namespace std;
 
int c [] = { 7, 3, 12, 5, 20, };
 
int main ()
{
    cout <<  "delka pole c je " << sizeof (c) / sizeof (c[0]) << endl; // nelze pouzit pro parametry funkce
}

delka pole c je 5

#include <iostream>
using namespace std;
 
const int N = 10;
 
int b [N] = { 7, 3, 12, 5, 20, 2, 8, 1, 22, 7 };
 
int main ()
{
    int top = b[0];
    for (int i = 1; i < 10; i ++)
    {
        if (b[i] > top)
        {
           top = b[i];
        }
    }
    cout << "maximum " << top << endl;
}

#include <iostream>
using namespace std;
 
const int N = 10;
 
int b [N] = { 7, 3, 12, 5, 20, 2, 8, 1, 22, 7 };
 
int main ()
{
    for (int k = 0; k < N; k ++)
    {
        for (int i = 0; i < 10-k-1; i ++)
        {
            if (b[i] > b[i+1])
            {
                // prohodime b[i] , b[i+1]
                int t = b[i];
                b[i] = b[i+1];
                b[i+1] = t;
            }
        }
    }
 
    for (int i = 0; i < N; i ++)
    {
        cout << b[i] << " ";
    }
    cout << endl;
}

Použijeme file output stream podobným způsobem jako cout.

#include <fstream>
using namespace std;
 
    ofstream f ("data.txt");
    f << " ... " << endl;

#include <iostream>
#include <fstream> // ofstream ... output file stream
using namespace std;
 
const int N = 20;
int a[N];
 
int main ()
{
    a[0] = 0;
    a[1] = 1;
 
    for (int i = 2; i < N; i++)
    {
        a[i] = a[i-1] + a [i-2];
    }
 
    cout << "( ";
    for (int i = 0; i < N; i++)
    {
        cout << a[i];
        if (i < N - 1)
        {
            cout << ", ";
        }
    }
    cout << " )" << endl;
 
    ofstream f ("data.txt");
    f << "( ";
    for (int i = 0; i < N; i++)
    {
        f << a[i];
        if (i < N - 1)
        {
            f << ", ";
        }
    }
    f << " )" << endl;
    f.close();
 
    if (f.good ())
    {
        cout << "soubor je v poradku" << endl;
    }
    else
    {
        cout << "soubor je v chybovem stavu" << endl;
    }
}

Typ parametru obsahuje i počet prvků pole.
Pole se předává jako ukazatel (adresa začátku pole).
Pokud změním hodnoty uložené v parametru, změní se původní pole.

#include <iostream>
using namespace std;
 
const int N = 10;
 
void print (int p[N])
{
    cout << "( ";
    for (int i = 0; i < N; i ++)
    {
        cout << p[i];
        if (i+1 < N)
        {
            cout << ", ";
        }
    }
    cout << " )" << endl;
}
 
void sort (int p[N])
{
    for (int k = 0; k < N; k ++)
    {
        for (int i = 0; i < N-k-1; i ++)
        {
            if (p[i] > p[i+1])
            {
                // prohodime p[i] , p[i+1]
                int tmp = p[i];
                p[i] = p[i+1];
                p[i+1] = tmp;
                /* pokud predavane pole jako paramater, meni se obsah puvodniho pole, ve skutecnosti se predava ukazatel na zacatek pole */
            }
        }
    }
}
 
int b [N] = { 7, 3, 12, 5, 20, 2, 8, 1, 22, 7 };
 
int c [] = { 7, 3, 12, 5, 20, };
 
int main ()
{
    print (b);
    sort (b);
    print (b);
 
    cout <<  "delka pole c je " << sizeof (c) / sizeof (c[0]) << endl; // nelze pouzit pro parametry funkce
}

( 7, 3, 12, 5, 20, 2, 8, 1, 22, 7 )
( 1, 2, 3, 5, 7, 7, 8, 12, 20, 22 )
delka pole c je 5

pokud Vás zajímá příklad s objektem, předefinovanými [] a šablonami, tak je schovaný zde

#include <iostream>
using namespace std;
 
const int N = 3;
 
void add (double v[N], double a[N], double b[N]) // v = a + b
{
    for (int i = 0; i < N; i ++)
    {
        v[i] = a[i] + b[i];
    }
}
 
void mul (double v[N], double c, double a[N]) // v = c * a
{
    for (int i = 0; i < N; i ++)
    {
        v[i] = c * a[i];
    }
}
 
void print (double p[N])
{
    cout << "( ";
    for (int i = 0; i < N; i ++)
    {
        cout << p[i];
        if (i+1 < N)
        {
            cout << ", ";
        }
    }
    cout << " )" << endl;
}
 
int main ()
{
    double a [N] = { 1 , 0, 0 };
    double b [N] = { 1 , 2, 3 };
    double z [N];
 
    print (a);
    print (b);
 
    // z = 0.5 a + b
    mul (z, 0.5, a);
    add (z, z, b);
 
    print (z);
}

#include <iostream>
using namespace std;
 
void conv (int n, int zaklad = 2)
{
    const int MAX = 10;
    char cislice [MAX];
 
    int i = 0;
    while (n > 0 && i < MAX)
    {
        int k = n % zaklad; // ziskame nejnizsi cislici jako cislo od 0 do zaklad-1
        if (k <= 9)
        {
            cislice [i] = '0' + k; // prevedeme cislo na znak
        }
        else
        {
            cislice [i] = 'A' + k - 10; // 10 prevedeme na A, 11 na B, ...
        }
        n = n / zaklad; // odstranime nejnizsi cislici
        i ++;
    }
 
    while (i > 0)
    {
        i --;
        cout << cislice [i];
    }
    cout << endl;
}
 
int main()
{
    conv (12);
    conv (256);
    conv (512);
    conv (1024); // pole cislic je prilis kratke
}