Artykuł jest wprowadzeniem do dwóch klas zmiennych, nieco bardziej skomplikowanych. Zmienne typu strukturalnego są zbiorem innych zmiennych na ogół różnych typów. Natomiast wskaźniki to zmienne, które odnoszą się do adresów w pamięci innych zmiennych.
W mojej pracy zajmę się operacjami na typie strukturalnym, natomiast mój przyjaciel z zespołu – mieczyk – już przygotowuje artykuł o wskaźnikach.

1.Definiowanie struktury.

Pierwszy krokiem, aby utworzyć zbiór powiązanych ze sobą zmiennych, jest określenie struktury. Przez definiowanie określamy własny typ danych. Nadajemy jej nazwę i wskazujemy naszemu kompilatorowi nazwę i typ każdego rodzaju danych, jakie będzie zawierać definiowana struktura.
Poniżej przykładowy schemat:

    struct nazwa_struktury   /* słowo kluczowe struct oraz nazwa struktury nazwa_struktury */
    {
        type nazwa_zmiennej1;        /* deklaracja składowych struktury */
        type nazwa_zmiennej2;
        /*...*/
    };

Definicja struktury musi się rozpoczynać od słowa kluczowego struct, po którym występuje nazwa struktury. Elementy danych tworzących strukturę nazywa się składowymi struktury, które umieszcza się w grupie między otwierającym i zamykającym nawiasem klamrowym.
Przy deklaracji składowych struktury korzystamy z tej samej składni, co przy deklarowaniu zmiennych. Określamy typ każdej składowej oraz wielkość dowolnego łańcucha/tablicy. Składowe struktury tworzą tzw. wzorzec tej struktury, który definiuje składniki i wskazuje kompilatorowi, ile pamięci trzeba przeznaczyć na każdą zmienną typu strukturalnego. Należy pamiętać, że składowe struktury są składnikami jednej/wielu zmiennych i zostaną zadeklarowane jako należące do określonego typu strukturalnego.
Załóżmy, że chcemy zdefiniować swój zbiór płyt CD/DVD za pomocą struktury:

    struct CD
    {
        char nazwa[40];
        char opis[40];
        char kategoria[12];
        float cena;
        int numer;
    };

W ten sposób stworzyliśmy nowy typ danych o nazwie CD. Jak widać, struktura wymaga zarezerwowania 98 adresów w pamięci.

2.Przypisywanie zmiennej typu strukturowego.

Zdefiniowanie struktury nie daje nam jeszcze dostępu do konkretnych miejsc w pamięci. Pamiętajmy, że zanim zastosujemy dowolny typ danych, musimy zadeklarować zmienną tego typu.
Przykładowo możemy utworzyć nasz zbiór płyt, definiując zmienną w następujący sposób:

    struct CD dysk;

Od teraz zmienna dysk będzie się składać z pięciu elementów i reprezentować przestrzeń w pamięci odpowiadającą 98 adresom.

Możemy także w jednym kroku utworzyć strukturę i zadeklarować zmienną:

    struct CD
    {
        char nazwa[40];
        char opis[40];
        char kategoria[12];
        float cena;
        int numer;
    } dysk;

3.Przypisywanie wartości początkowych.

    struct CD
    {
        char nazwa[40];
        char opis[40];
        char kategoria[12];
        float cena;
        int numer;
    } dysk = {”Super Hity”,”Cool Muza”,”RNB”,20.59,12};

    ,lub

    struct CD dysk = {”Super Hity”,”Cool Muza”,”RNB”,20.59,12};

4.Stosowanie struktury.

Aby odnieść się do składowej, musimy uściślić odwołane, dodając nazwę zmiennej typu strukturalnego:

    zmienna_struktury.nazwa_zmiennej_składowej

,czyli:

    gets(dysk.nazwa);
    gets(dysk.opis);
    gets(dysk.kategoria);
    dysk.cena = 19.99;
    dysk.numer = 5;

Listing 4.1.

#include<stdio.h>

struct CD
    {
    char nazwa[40];
    char opis[40];
    char kategoria[12];
    float cena;
    int numer;
    } dysk;

main()
{
    puts(”Podaj dane płyty\n\n”);
    printf(”Podaj nazwę:”);
    gets(dysk.nazwa);
    printf(”Podaj opis:”);
    gets(dysk.opis);
    printf(”Podaj kategorię:”);
    gets(dysk.kategoria);
    printf(”Podaj cenę:”);
    scanf(”%f”, &dysk.cena);
    printf(”Podaj położenie:”);
    scanf(”%d”, &dysk.numer);
    puts(”Dane płyty, które podałeś są następujące:\n”);
    printf(”Nazwa:        %s\n”, dysk.nazwa);
    printf(”Opis:            %s\n”, dysk.opis);
    printf(”Kategoria:        %s\n”, dysk.kategoria);
    printf(”Cena:            %6.2f\n”, dysk.cena);
    printf(”Położenie:        %d\n”, dysk.numer);
}

5.Tablice struktur.

Deklarujemy tablicę dopisując zakres zmiennej typu strukturalnego:

    struct CD dysk[10];

Następuje przydzielenie 10 obszarów pamięci, z których każdy jest w stanie pomieścić całą strukturę.

Odwołanie się do elementów tablicy wygląda następująco:

    gets( dysk[0].nazwa );
    gets( dysk[1].nazwa );

Listing 5.1.

#include<stdio.h>

struct CD
    {
    char nazwa[40];
    char opis[40];
    char kategoria[12];
    float cena;
    int numer;
    } dysk[10];

main()
{
int index, i;
char wybierz;
wybierz = 'Y';
index = 0;
do
    {
        printf(”Podaj numer płyty %d\n”, index);
        printf(”Podaj nazwę:”);
        gets(dysk[index].nazwa);
        printf(”Podaj opis:”);
        gets(dysk[index].opis);
        printf(”Podaj kategorię:”);
        gets(dysk[index].kategoria);
        printf(”Podaj cenę:”);
        scanf(”%f”, &dysk[index].cena);
        printf(”Podaj położenie:”);
        scanf(”%d”, &dysk[index].numer);
        index++;
        if (index<10)
            {
            printf(”Czy chcesz jeszcze raz wprowadzić dane? Y or N”);
            wybierz = getchar();
            putchar('\n');
            }
    }
while (index < 10 && (wybierz == 'Y' || wybierz == 'y'));
puts(”Nazwa                Położenie\n\n”);
for (i=0; i<index; i++)
    printf(”%s            %d\n”, dysk[i].nazwa, dysk[i].numer);
}

6.Praca ze strukturami.

Strukturę możemy zapisać na dysku za pomocą funkcji fwrite() i odczytać z dysku funkcją fread().
Składnia funkcji fwrite() jest następująca:

fwrite(&structure_variable, structure_size, number_of_structures, file_pointer);

Implementacja jest bardzo prosta:

&structure_variable jest zmienną typu strukturalnego z operatorem pobrania adresu; adres początkory informacji, którą chcemy zapisać na dysku.
structure_size jest liczbą znaków w strukturze. Zamiast zliczać znaki samemu, lepiej jest skorzystać z funkcji bibliotecznej sizeof();
number_of_structure wskazuje, ile struktur na raz chcemy zapisać. Zawsze podajemy 1.
file_pointer wskaźnik wskazujący plik.

Załóżmy na przykład, że chcemy zapisać na dysku dane dotyczące naszej kolekcji płyt przy wykorzystaniu struktury CD:

fwrite(&dysk, sizeof(dysk), 1, fp);

Listing 6.1. Zapisywanie struktury CD

#include<stdio.h>
main()
{
    FILE *fp;
    struct CD
    {
    char nazwa[40];
    char opis[40];
    char kategoria[12];
    float cena;
    int numer;
    } dysk;
    char plik[25];
    
    printf(”Podaj nazwę pliku, który chcesz utworzyć: ”);
    gets(plik);
    if ((fp = fopen(plik, ”w”)) == NULL)
    {
        printf(”Can not open the file %s\n”, plik);
        exit();
    }
    puts(”Podaj dane płyty\n”);
    printf(”Podaj nazwę:”);
    gets(dysk.nazwa);
    while (strlen(dysk.nazwa) > 0 )
    {
    printf(”Podaj opis:”);
    gets(dysk.opis);
    printf(”Podaj kategorię:”);
    gets(dysk.kategoria);
    printf(”Podaj cenę:”);
    scanf(”%f”, &dysk.cena);
    printf(”Podaj położenie:”);
    scanf(”%d”, &dysk.numer);
    fwrite(&dysk, sizeof(dysk), 1, fp);
    printf(”Podaj nazwę:”);
    gets(dysk.nazwa);
    }
    fclose(fp);
}

7.Wczytywanie struktur.

Aby wczytać całą strukturę na raz, stosuje się funkcje fread():

fread(&structure_variable, structure_size, number_of_structures, file_pointer);

Listing 7.1. Odczytywanie z dysku struktury CD

#include<stdio.h>
main()
{
    FILE *fp;
    struct CD
    {
    char nazwa[40];
    char opis[40];
    char kategoria[12];
    float cena;
    int numer;
    } dysk;
    char plik[25];
    
    printf(”Podaj nazwę pliku, z którego chcesz czytać: ”);
    gets(plik);
    if ((fp = fopen(plik, ”r”)) == NULL)
    {
        printf(”Can not open the file %s\n”, plik);
        exit();
    }
    while (fread(&dysk, sizeof(dysk), 1, fp) == 1)
    {
        puts(dysk.nazwa);
        putchar('\n');
        puts(dysk.opis);
        putchar('\n');
        puts(dysk.kategoria);
        putchar('\n');
        printf(”%f\n”, dysk.cena);
        printf(”%d\n”, dysk.numer);
    }
    fclose(fp);
}

To tyle, co chciałem wam przedstawić. W weekend zamieszczę aplikację, która wykorzystuje wszystkie informacje na temat struktur. Mam nadzieję, że ten artykuł komuś pomoże. Pozdrawiam.