Deklaracja tablic Deklarując tablicę i podając jej wartości początkowe, możemy podać tylko część wartości (mniej niż rozmiar tablicy), pozostałe zainicjowane zostaną zerami. Ponadto, możemy użyć indeksów aby przekazać, które wartości tablicy inicjujemy. Może to się wydać dziwne, ale po ostatnim elemencie tablicy może występować przecinek. int tablica1 = {1,}; int tablica2 = {0,1,4,=7,8,9,}; /* {0,1,0,0,4,0,0,7,8,9,0,0,0,0,0,0,0,0,0,0) */

Możemy to stosować również przy deklaracji tablicach bez podanego rozmiaru: int tablica[] = {0, 3, 4}; // tablica 5-elementowa

Jak i przy deklaracji tablic wielowymiarowych: float macierz = { { 1.6, 2.4, 5.6 }, /* pierwszy wiersz */ { 7.5, =8.6 }, /* trzeci wiersz */ {}, /* czwarty wiersz */ { 8.8, 7.5, } /* piąty wiersz */

Definiowanie rozmiaru tablicy Przyjrzyjmy się nadaniu rozmiaru tablicy przez użycie stałej definiowanej

#define ROZMIAR 3 int main() { int tab[ROZMIAR] = {3,6,8}; }

Innym sposobem jest użycie operatora sizeof do poznania wielkości tablicy. Poniższy kod robi to samo co przedstawiony: #include int main() { int tab = {3,6,8}; int i; printf ("Druk tablicy tab:\n");

for (i=0; i<(sizeof tab / sizeof *tab); ++i) { printf ("Element numer %d = %d\n", i, tab[i]);

return 0;

Powyżej sizeof tab zwraca cały rozmiar pamięciowy tablicy, natomiast sizeof *tab poda nam jaki jest rozmiar typu int (ponieważ takiego typu jest element tablicy, *tab). Dzieląc rozmiar pamięciowy tablicy przez rozmiar pojedynczego elementu uzyskujemy ilość elementów. (Np. przy rozmiarze 44B oraz rozmiarze sizeof(int) równym 4 otrzymujemy, że tablica zawiera 11 elementów.)

Należy pamiętać, że sposób działa tylko dla tablic, a nie wskaźników (mimo że wskaźniki traktujemy w pewnym stopniu podobnie jak tablice).

Pobieranie wartości Przy odwoływaniu się do konkretnej komórki tablicy, używanym indeksem powinna być liczba, choć istnieje możliwość indeksowania za pomocą np. pojedynczych znaków ('a','b', itp.), jednak w języku C dokonuje się wewnętrzna konwersja takich znaków na liczby im odpowiadające, zatem tablica indeksowana znakami byłaby niepraktyczna i musiałaby mieć odpowiednio większy rozmiar (numerem ASCII dla 'a' jest 97). tablice znaków

// https://stackoverflow.com/questions/8824057/pointer-to-string-array-in-c

#include #include #include

#define ROW 5 #define COL 10

int main(void) { int i, j; char a[ROW][COL] = {"string1", "string2", "string3", "string4", "string5"}; char *b[ROW];

/*

a[][]

0 1 2 3 4 5 6 7 8 9 +---+---+---+---+---+---+---+------+---+---+ | s | t | r | i | n | g | 1 | '\0' | | | +---+---+---+---+---+---+---+------+---+---+ | s | t | r | i | n | g | 2 | '\0' | | | +---+---+---+---+---+---+---+------+---+---+ | s | t | r | i | n | g | 3 | '\0' | | | +---+---+---+---+---+---+---+------+---+---+ | s | t | r | i | n | g | 4 | '\0' | | | +---+---+---+---+---+---+---+------+---+---+ | s | t | r | i | n | g | 5 | '\0' | | | +---+---+---+---+---+---+---+------+---+---+

*/

/* Now, lets work on b */ for (i=0 ; i<5; i++) { if ((b[i] = malloc(sizeof(char) * COL)) == NULL) { printf("unable to allocate memory \n"); return -1;

strcpy(b, "string1"); strcpy(b, "string2"); strcpy(b, "string3"); strcpy(b, "string4"); strcpy(b, "string5");

/*

b[] 0 1 2 3 4 5 6 7 8 9 +--------+ +---+---+---+---+---+---+---+------+---+---+ | --|------->| s | t | r | i | n | g | 1 | '\0' | | | +--------+ +---+---+---+---+---+---+---+------+---+---+ | --|------->| s | t | r | i | n | g | 2 | '\0' | | | +--------+ +---+---+---+---+---+---+---+------+---+---+ | --|------->| s | t | r | i | n | g | 3 | '\0' | | | +--------+ +---+---+---+---+---+---+---+------+---+---+ | --|------->| s | t | r | i | n | g | 4 | '\0' | | | +--------+ +---+---+---+---+---+---+---+------+---+---+ | --|------->| s | t | r | i | n | g | 5 | '\0' | | | +--------+ +---+---+---+---+---+---+---+------+---+---+

*/

char (*ptr1)[COL] = a; printf("Contents of first array \n"); for (i=0; i<ROW; i++) printf("%s \n", *ptr1++);

char **ptr2 = b; printf("Contents of second array \n"); for (i=0; i<ROW; i++) printf("%s \n", ptr2[i]);

/* b should be free'd */ for (i=0 ; i<5; i++) free(b[i]);

return 0; }

Ciekawostki W pierwszej edycji konkursu IOCCC zwyciężył program napisany w C, który wyglądał dość nietypowo: short main[] = { 277, 04735, -4129, 25, 0, 477, 1019, 0xbef, 0, 12800, -113, 21119, 0x52d7, -1006, -7151, 0, 0x4bc, 020004, 14880, 10541, 2056, 04010, 4548, 3044, -6716, 0x9, 4407, 6, 5568, 1, -30460, 0, 0x9, 5570, 512, -30419, 0x7e82, 0760, 6, 0, 4, 02400, 15, 0, 4, 1280, 4, 0, 4, 0, 0, 0, 0x8, 0, 4, 0, ',', 0, 12, 0, 4, 0, '#', 0, 020, 0, 4, 0, 30, 0, 026, 0, 0x6176, 120, 25712, 'p', 072163, 'r', 29303, 29801, 'e'

Co ciekawe - program ten bez przeszkód wykonywał się na komputerach VAX-11 oraz PDP-11. Cały program to po prostu tablica z zawartym wewnątrz kodem maszynowym! Tak naprawdę jest to wykorzystanie pewnych właściwości programu, który ostatecznie produkuje kod maszynowy. Linker (to o nim mowa) nie rozróżnia na dobrą sprawę nazw funkcji od nazw zmiennych, więc bez problemu ustawił punkt wejścia programu na tablicę wartości, w których zapisany był kod maszynowy. Tak przygotowany program został bez problemu wykonany przez komputer.

Zapisywanie tablic do pliku tekstowego binarnego

binarnego

Ten sposób pozwalan na: szybki dostęþ do duzych plikówFast Reading and Writing of Binary Data in C by David S. Smith,

Funkcje fwritecplusplus fwrite freadcplusplus fread

#include #include

int main () { FILE * pbFile;

char * fName = "a1.dat";

// input static array double a[] = { 1.333333333333333 , 1.44444444444444444 , 1.5555555555555555, 1.66666666666666666666666}; long ALength; // number of array's elements = ENumber size_t ASize; // size of array in bytes size_t ESize; // size of array's element in bytes int i;

// for output array (dynamic arrray read from binary file ) double * b; // size_t result; size_t FSize;

// test input ASize = sizeof(a); // ESize = sizeof(a); ALength = ASize/ESize; // number of elements = Length of array

printf("array has %ld elements of %zu bytes so the array size = %zu bytes\n", ALength, ESize, ASize ); for (i=0; i< ALength; i++) printf("i = %d \t a[i] = %f\n",i, a[i]);

// write to the binary file pbFile = fopen (fName, "wb"); fwrite (a , ESize, ALength, pbFile); fclose (pbFile); printf("array have been saved to the %s file\n", fName);

// open binary file pbFile = fopen( fName , "rb" ); if (pbFile==NULL) {fputs ("File open error",stderr); return 1;}

// obtain file size: fseek (pbFile , 0 , SEEK_END); FSize = ftell (pbFile); rewind (pbFile); printf("file size = %zu\n", FSize);

// allocate memory to contain the whole file: b = (double *) malloc (ESize*ALength); if (b == NULL) {fputs ("Memory error",stderr); return 2;}

// copy the file into the buffer: result = fread (b,ESize,ALength,pbFile); if (result != ALength) {printf("Reading error: result = %zu != %ld \n",result, ALength); return 3;}

/* the whole file is now loaded in the memory buffer. */

// print the array printf("array has %ld elements of %zu bytes so the array size = %zu bytes\n", ALength, ESize, ASize ); for (i=0; i< ALength; i++) printf("i = %d \t b[i] = %f\n",i, b[i]);

// terminate fclose (pbFile); free (b);

return 0;

Wynik :

gcc a.c -Wall ./a.out array has 3 elements of 8 bytes so the array size = 24 bytes i = 0 a[i] = 1.330000 i = 1 a[i] = 1.340000 i = 2 a[i] = 1.350000 array have been saved to the a.dat file file size = 24 array has 3 elements of 8 bytes so the array size = 24 bytes i = 0 b[i] = 1.330000 i = 1 b[i] = 1.340000 i = 2 b[i] = 1.350000

W przypadku pliku utworzonego na innym komputerze/programi trzeba sprawdzić kolejność bajtów ( ang. endianess)Reading binary files from PCs on "other endian" machines Written by Paul Bourke March 1991

biblioteki tutoriale - Foad Sojoodi Farimani gsl ARB growable-buf: Growable Memory Buffers for C99 by Christopher Wellons