Tak - na začátek bych měl říct, že pole není pole brambor, ale množina
určitého počtu prvků určitého datového typu, ke kterým se dostáváme
indexováním. (index je pořadí prvku od začátku, v c-čku je vždy od
nuly) Hah ! Tak tahle věta byla prkenná jako přejetá parním válcem !
V C/C++ jdou definovat 2 typy polí. Ten první je pole statické - to
znamená, že velikost pole bude známá už při překladu, takové pole
nelze zvětšovat. A potom pole dynamické, to jde zvětšovat a měnit
Ještě než se pustíme do polí, ukážu vám jeden operátor :
10.0 Operátor sizeof
Operátor sizeof slouží ke zjišťování velikosti datových objektů,
vrací hodnotu typu int v Bajtech :
sizeof(char) je 1 // Char je právě 1 bajt ... sizeof(int) je 4 // Tady už se to může trochu lišit, někdy to je 2 sizeof(float) je 32 // To je už poměrně přesné číslo .. sizeof(double) je 64 // .. a tohle ještě víc ! |
int pole[10]; // toto je pole deseti prvků typu int |
pole : array[0 .. 9] of integer; |
Dim pole(0 to 9) As Integer; |
int pole[10] = {5, 8, 12, 5, 4, 6, 58, 0, 72, 1};
|
int pole[] = {5, 8, 12, 5, 4, 6, 58, 0, 72, 1};
|
pole[0] = 10;
pole[9] = 5;
pole[3] = 1;
for(i = 0; i < 10; i ++)
pole[i] = 0; // Tento cyklus vynuluje celé pole
|
pole[10] = 8; |
int pole[3][3]; // pole o devíti prvcích |
int pole[][] = {{5, 8, 4}, {7, 1, 0}, {9, 2, 6}};
// stejně, jako předtím devět prvků, kompilátor si rozměry doplní sám.
|
int pole[3][3]; pole[0][0] = 5; pole[1][0] = 8; pole[2][0] = 4; pole[0][1] = 7; pole[1][1] = 1; pole[2][1] = 0; pole[0][2] = 9; pole[1][2] = 2; pole[2][2] = 6; // stejnej zápis jako minule, jen stokrát delší ;-) |
pole[2][1] = 1;
for(i = 0; i < 3; i ++)
for(j = 0; j < 3; j ++)
pole[i][j] = 0; // vynuluje celé pole
pole[3][0] = 5; // Chyba, překročili jste hranice pole
// Ale u takové chyby (v prvním sloupci) se většinou
// přepíše jen další záznam pole, ale ...
pole[3][3] = 5; // Už sahá někam do paměti, což může
// způsobit pád programu, nebo i Windows (fúj)
|
float pole_floutu[] = {3.1415926, 1.1569847, 0.0000001};
char pole_znaku[] = {'A', 'h', 'o', 'j', ' ', '.', '.', '.' ,0};
// Ta nula je tam velice důležitá, ale o tom až dál ... ale ještě
// je tu jeden pohodlnější způsob :
char druhy_pole_znaku[] = "Ahoj ...";
// Sem už se nula dát nemusí, kompilátor si ji doplní sám.
// Obě dvě pole se tedy doplní samy.
|
pole_a = pole_b; |
int i;
for(i = 0; i < velikost_pole; i ++)
pole_a[i] = pole_b[i];
|
int i; while(pole_a[i] = pole_b[i ++]); // wau ! |
int pole[15], velikost; velikost = sizeof(pole) / sizeof(int); // velikost bude 15 |
printf(pole_znaku); // funguje jen pro pole char, ukončené tou nulou |
printf("Toto je moje prvni pole znaku : \n%s\n"
"A toto je moje druhy pole znaku : \n%s\n",
pole_znaku, druhy_pole_znaku);
|
scanf("%s", pole_znaku);
|
int *poin; |
*poin = 10; // Na adrese poin bylo zapsáno číslo 10 poin[0] = 10; // ten samý zápis, jenže jinak |
point = 0x70; // Kdo by zapomněl, 0x70 je hexadecimální číslo |
float *f, cislo; cislo = 5; // cislo je 5 f = &cislo; // do f byla uložena adresa proměnné cislo *f = 0; // cislo je 0 ! Není to skvělé ? f[0] = 0; // ten samý zápis, ale takhle ! |
#include <malloc.h> |
float *f;
f = (float*) malloc(sizeof(float));
// do f teď můžeme s klidem zapisovat, ale ...
Lepší alternativa :
if((f = (float*) malloc(sizeof(float))) == NULL){
printf("Malo pameti !");
return 0;
} // Funkce malloc totiž v případě neúspěchu vrátí
// makro NULL (NULL = 0x00000000)
|
free((void*)f); |
int *pole_intu;
if((pole_intu = (int*) malloc(10 *sizeof(int))) == NULL)
return 0;
// Teď můžete pracovat s polem, je třeba dbát na hranice polí a
// na to, že v poli jsou náhodné hodnoty, je třeba ho nulovat !
int i;
for(i = 0; i < 10; i ++)
pole_intu[i] = 0;
*pole_intu[0] = 10; // Pole na pozici 0 bude mít hodnotu 10
*(pole_intu + 0) = 20; // Pole na pozici 0 bude mít hodnotu 20
*pole_intu[1] = 100; // Pole na pozici 1 bude mít hodnotu 100
pole_intu ++; // Pole se posune o 1 prvek dopředu (ztratí se adresa 0.)
*pole_intu[1] = 200; // Pole na pozici 2 bude mít hodnotu 200
pole_intu --; // Pole se posune 0 1 prvek zpět (vše je zpátky)
*pole_intu[1] = 0; // Pole na pozici 1 bude mít hodnotu 0
// Při takovýchto hrátkách je třeba dbát na to, aby jsme z pole
// nevyjeli ... Pokud už ste si s polem dost vyhráli, musíme ho
// uvolnit pro další programy ...
free((void*)pole);
// pro free musíme mít přesně stejný pointer, jako vyplivne malloc() !
// takže pozor na hrátky s ++ a -- ! (ono to potom háže chyby)
|
char *pole_znaku;
int pocznaku = 0;
// Zde naalokujeme nějakou paměť, pěkně si pohrajeme ...
// ... a najednou už nám pole nestačí, zvětšíme ho o 10 znaků :
if((pole_znaku = (char*) realloc(pocznaku, (pocznaku + 10) * sizeof(char))) == NULL){
printf("Nedostatek pameti RAM ! Ukonci nekolik programu a zkus to znova.");
return 0;
} // I u realloc může dojít paměť ...
pocznaku += 10;
// Musíme si zapamatovat novou velikost.
|
x = (typ*) malloc(0); |
int **pole, i;
pole = (int**) malloc(10 * sizeof(int*));
// Teď máme naalokovanou první dimenzi pole ...
for(i = 0; i < 10; i ++)
pole[i] = (int*) malloc(10 * sizeof(int));
// A teď už máme naalokované i řádky ...
// Jak jsem psal o polích různých tvarů, tak to se dělá
// právě tady změnou délky řádků ...
|
pole[2][5] = 1; |
pole ++; |
for(i = 0; i < 10; i ++)
free((void*)pole[i]);
// uvolnili sme řádky
free((void*)pole);
// Uvolnili jsme sloupce
|
int *pole[10], pocet = 0;
if((pole = (int*) malloc(8 * sizeof(int))) == NULL) {
printf("Nedostatek pameti RAM !\n");
return;
}
// Teď si můžeme hrát, realokovat, už to snad ani nebudu psát ...
// A tradičně vám ještě řeknu, jak to uvolnit (Masochisti nemusí)
free((void*)pole);
|
char jmeno[] = "Pepa z depa"; |
char *jmeno = "Pepa z depa"; |
int main(int argc, char *argv[])
{
int i;
printf("Program byl spuštěn s %d parametry \n", argc);
for(i = 0; i < argc; i ++)
printf("%s \n", argv[i]);
return 1;
}
|