Struktury

Najogólniej struktury to "worki" z elementami (polami). Dzięki temu możemy, na przykład, w bardzo łatwy sposób zrobić tablice adresów (jedną, zamiast kilku dla wszystkich pól).

Strukturę deklarujemy w następujący sposób:

struct Foo //struktura o nazwie Foo
{
   int pole1;
   float pole2;
   char pole3[20];  //rozmiar musi być znany podczas kompilacji
   //... i inne ...
} Obj1, *PObj2, Tab[5]; //egzemplarz Obj1, wskaźnik na strukturę PObj2 oraz 5-elementowa tablica

Możemy również zdefiniować typ:

typedef struct //teraz nie podajemy tutaj nazwy
{
   int pole1;
   float pole2;
   char pole3[20];
   //... i inne ...
} Foo, *PFoo; //typ Foo oraz wskaźnik PFoo na obiekt typu Foo

Foo ObjA;
PFoo PObjA = &ObjA;

Struktury można kopiować między sobą stosują zwykły operator przypisania

struct
{
   int a;
   int b;
} rcA = {1,2}, rcB = {3,4};

rcA = rcB //przepisanie rcB do rcA

Struktury w C

   Struktura jest obiektem składającym się ze zbioru nazwanych składowych o różnych typach. Specyfikator struktury ma postać:

   	
struct [<nazwa_typu_strukturalnego >] {
	[<typ> <nazwa_zmiennej [,nazwa_zmiennej, ...]>] ;
	} [<nazwa_zmiennej_strukturalnej>] ;

 Przykład struktury w języku C:

 
struct rodzina{
char imie[20];
char nazwisko[20];
int wiek;
}osoba;

  Aby dostać się do elementu w strukturze stosujemy notację:

[<nazwa_zmiennej_strukturalnej>].element=zmienna;

Na przykład:

osoba.wiek=20;

Możemy także zadeklarować tablicę struktur:

struct rodzina osoby[5];

Pola struktur  możemy  inicjować w miejscu ich deklaracji. Wartości na liście inicjacyjnej  muszą być zgodne z liczbą, kolejnością i typami danych pól danej struktury:

struct rodzina{
char imie[20];
char nazwisko[20];
int wiek;
};
Ojciec={"Adam", "Kowalski",45},
Matka={"Ewa", "Kowalska",39};

 Zastanówmy się ile zajmują struktury deklarowane przez nas w pamięci.Pola struktury są umieszczane w pamięci zgodnie z kolejnością występowania w deklaracji. Każde pole struktury zajmuje osobny obszar pamięci. Łączny rozmiar struktury jest równy sumie rozmiarów jej składowych.Rozmiar struktury jest zawsze większy lub równy sumie rozmiarów jej składowych.

 
struct rodzina{
char imie[20];
char nazwisko[20];
int wiek;
}osoba;

 Rozmiar powyższej struktury będzie równy  20+20+4=44 bajtów.

 printf("rozmiar=%d",sizeof(struct rodzina));

Składowymi struktur może być oczywiście inna struktura. Aby odwołać się do pola struktury będącej składową innej struktury należy wykorzystać kropkę.

 
struct miejsce_zamieszkania{
char kraj[20];
char wojewodztwo[40];
char powiat[40];
char miasto[40];
char dzielnica[40];
char ulica[40];
};

struct rodzina{
char imie[20];
char nazwisko[20];
int wiek;
miejsce_zamieszkania adres;
}osoba;

strcpy(osoba.adres.kraj,"Polska");

 Zastanówmy czy możemy powoływać wskaźnik na strukturę ?? Oczywiście ,że tak. Podobnie jak na inne zmienne wskaźnik może wskazywać na strukturę:

  struct  node{
   int key;
  struct *left,*right;
 } *korzen;
 

Aby dostać się do elementu struktury możemy to zrobić na dwa sposoby.Zapis korzen->key=10; jest (z definicji) równoważny (*korzen).key=10;, ale bardziej przejrzysty i powszechnie stosowany.

Struktury w C++

Struktura to zwyczajnie klasa, której elementy są domyślnie w sekcji Public. Słowo kluczowe Struct zostało pozostawione w C++ dla wstecznej zgodności z C. Przy definiowaniu egzemplarza struktury nie musimy już poprzedzać go słowem kluczowym Struct jeżeli nie był on zdefiniowany typem. Poniższy przykład pokazuje, że w praktyce nie ma żadnych różnic pomiędzy klasami, a strukturami:

#include <iostream>

using namespace std;

class Base
{
public:
   static int N;
   static void printN() {cout << N << endl;}
};

int Base::N = 0;

struct Test: private Base
{
   Test() {N++;}
   Test(const Test &Obj) {N++;}
   ~Test() {N--;}
};
 
int main()
{
   Test A, B;
   //A.N;     <= błąd
   {
      Test C;
      Base::printN();
   }
   Base::printN();
   getchar();
}

Jedyną różnicą między Struct i Class jest to, że gdy zadeklarujemy "czystą" strukturę (która nie ma elementów specyficznych dla klasy), to będziemy ją mogli zainicjować jak tablicę.

struct Foo
{
   int pole1;
   float pole2;
   char pole3[20];
};
 
int main()
{
   const Foo X = {1, 3.14, "Ala ma kota."};
}

Zobacz też:

• Klasy