Prezentacja programu PowerPoint

Język ANSI C-struktury
Struktury ( zwane w innych językach programowania rekordami)
stanowią typ służący do przetwarzania informacji powiązanych ze sobą.
Definicja typu strukturowego ma następującą postać
struct nazwaTypu
{ typPola1
nazwaPola1;
typPola2
nazwaPola2;
.
.
typPolaN
nazwaPolaN;
};
Tak więc definicja typu strukturowego składa się ze słowa kluczowego
struct, po którym następuje nazwa danego typu strukturowego ( czasami
określana jako etykieta), po czym po nawiasie otwierającym występują
typy poszczególnych składowych struktury oraz ich nazwy. Składowe
typu strukturowego zwane są polami struktury.
Język ANSI C-struktury
Definicja typu strukturowego kończy się nawiasem zamykającym i
średnikiem.
W typie strukturowym mogą wystąpić pola, które same mogą być
typu strukturowego, mówimy wtedy o tzw. typie strukturowym
zagnieżdżonym.
Nazwy pól muszą być różne w ramach jednego typu strukturowego,
jednak można stosować te same nazwy w ramach innych typów
strukturowych.
Nazwa pola struktury może być taka sama jak nazwa danego typu
strukturowego czy też zmiennej strukturowej.
Język ANSI C-struktury
Przykład. W ramach jednego typu danych chcemy przechowywać pewne
informacje o pracownikach. Zdefiniujemy uproszczony typ strukturowy
pozwalający na przechowywanie takich informacji ( w rzeczywistych
sytuacjach może być konieczne stosowanie nawet kilkudziesięciu pól).
struct pracownik
{ char nazwisko [20];
char imie [20];
int wiek;
double dochod;
} rek1, rek2;
rek1, rek2 są zmiennymi typu pracownik. Zmienne strukturowe
można też zdefiniować w sposób następujący:
struct pracownik rek3, rek4, rek5;
Język ANSI C-pliki
Można też zdefiniować tablicę struktur
struct pracownik
pracownicy [20];
Zmienna pracownicy jest tablicą struktur składającą się z 20 struktur
typu pracownik.
Dla realizacji dostępu do pól typu strukturowego wprowadzono w
języku C specjalny operator dostępu do pól struktury – operator " ."
( kropka). Operator ten jest stosowany w sposób następujący: jeśli mamy
zmienną strukturową rek1 typu pracownik, to możemy wprowadzić
wartość do jej pola dochod w sposób następujący:
rek1.dochod=1500;
W ogólnym przypadku, polami zmiennych strukturowych możemy
posługiwać się jak zmiennymi takiego typu, jak typ danego pola struktury.
Język ANSI C-struktury
Wprowadzanie/wyprowadzanie informacji z /do pól zmiennych
strukturowych cz. 1
Jak zaznaczono powyżej, pola takie można stosować, jako zmienne
danego typu
rek2.dochod=1000;
rek2.wiek=25;
pracownicy[0].dochod=1200;
pracownicy [0].wiek=24;
scanf("%f",&rek3.dochod);
scanf("%d",&rek3.wiek);
1. Pola typu numerycznego ( typy całkowite i typy rzeczywiste)
scanf ("%lf",&pracownicy[1].dochod);
scanf ("%d", &pracownicy[1].wiek);
Język ANSI C-struktury
Wprowadzanie/wyprowadzanie informacji z /do pól zmiennych
strukturowych cz. 2
2. Pola typu tablica znaków
strcpy (rek1.nazwisko,"Kowalski");
scanf("%s",rek2.nazwisko);
gets( rek3.nazwisko);
Wyprowadzanie informacji odbywa się podobnie jak dla innych
zmiennych.
printf ("\n
%d ", rek1.dochod);
printf("\n
%s ", rek1.nazwisko);
Język ANSI C-struktury
Inicjalizacja tablic struktur
Przykład. Inicjalizacja tablicy struktur typu student
struct student
{ char nazwisko[20];
char imie [20];
int rok studiow;
char wydzial[20];
};
struct student studenci[3]=\
{
{"Kowalski","Marcin",2, "EiA"},
{"Iksiński","Andrzej",2,"EiA"},
{"Malinowski","Dariusz”,2,"EiA"} };
Język ANSI C-struktury
Przykład. Program rekordy1 wczytujący i drukujący pojedyncze struktury.
(cz.1)
#include <stdio.h>
#include <string.h>
// program rekordy1 wczytuje dane do struktur i drukuje
int main(int argc, char **argv)
{ struct student
{
char nazwisko[20];
char imie [20];
int rokStudiow;
char wydzial[20];
};
struct student student1, student2;
/* Bezpośrednie nadawanie wartości polom
struktur */
strcpy(student1.nazwisko,"Kowalski");
strcpy(student1.imie,"Jan");
student1.rokStudiow=2;
strcpy(student1.wydzial,"EiA");
Język ANSI C-struktury
// Program rekordy1 cz. II
/* Do wczytywania pól struktury student 2
z klawiatury
zastosowano trzy różne funkcje wczytywania pól typu
tablica znaków, by pokazać różne sposoby wczytywania
takich pól */
printf ("\n Podaj dane 2-go studenta ");
printf ("\n
Nazwisko: ");
scanf("%s",student2.nazwisko);
printf ("\n
Imie: ");
fflush(stdin);
fgets(student2.imie,15,stdin);
printf("\n Rok studiow :");
scanf("%d",&student2.rokStudiow);
printf ("\n
Wydział: ");
scanf("%s",student2.wydzial);
Język ANSI C-struktury
// program rekordy1 cz. III
/* Drukowanie struktur student1 i student2 */
printf("\n\n Dane studenta 1 ");
printf("\n Nazwisko
:%s", student1.nazwisko);
printf("\n
Imie
:%s", student1.imie);
printf("\n Rok studiow :%d", student1.rokStudiow);
printf("\n Wydzial
:%s", student1.wydzial);
printf("\n\n\n Dane studenta 2 ");
printf("\n Nazwisko
:%s", student2.nazwisko);
printf("\n
Imie
:%s", student2.imie);
printf(" Rok studiow :%d", student2.rokStudiow);
printf("\n Wydzial
:%s", student2.wydzial);
getch();
return 0;
}
Język ANSI C-struktury
Struktury zagnieżdżone
Struktury zagnieżdżone to takie struktury w których
przynajmniej jedno z pól jest typu strukturowego.
struct nazwaTypu
{
typPola1
nazwaPola1;
struct nazwaTypuStrukturowego
.
.
typPolaN
} ;
nazwaPolaN;
nazwaPola2;
Język ANSI C-struktury
Przykład. Definicja typu strukturowego zagnieżdżonego.
struct data
{
int dzien;
int miesiac;
int rok;
};
struct daneStudenta
{ char nazwisko[20];
char imie [20];
struct data dataUr ;
int rokStudiow;
char wydzial[20];
};
struct daneStudenta daneStudenta1, daneStudenta2;
Język ANSI C-struktury
Przykład . Program rekordy2 wczytujący dane do tablicy struktur i
drukujący tablicę struktur.
int main(int argc, char **argv)
{
struct data
{
int dzien;
int miesiac;
int rok;
};
struct dane_studenta
{
char nazwisko[20];
char imie [20];
struct data dataUr;
int rokStudiow;
char wydzial[20];
};
struct daneStudenta studenci[4];
Język ANSI C-struktury
// Program rekordy2 cz. II
int i;
/* Bezpośrednie nadawanie wartości polom
tablicy struktur */
strcpy(studenci[0].nazwisko,"Kowalski");
strcpy(studenci[0].imie,"Jan");
studenci[0].rokStudiow=2;
studenci[0].dataUr.dzien=2;
studenci[0].dataUr.miesiac=5;
studenci[0].dataUr.rok=1990;
strcpy(studenci[0].wydzial,"EiA");
strcpy(studenci[1].nazwisko,"Nowak");
strcpy(studenci[1].imie,"Andrzej");
studenci[1].rokStudiow=2;
studenci[1].dataUr.dzien=2;
studenci[1].dataUr.miesiac=6;
studenci[1].dataUr.rok=1991;
strcpy(studenci[1].wydzial,"EiA");
Język ANSI C-struktury
// program rekordy2 cz. III
for (i=2;i<4;i++)
{ printf ("\n Podaj dane studenta %i",i+1);
printf ("\n
Nazwisko: ");
scanf("%s",studenci[i].nazwisko);
fflush(stdin);
printf ("\n
Imie: ");
scanf("%s",studenci[i].imie);
fflush(stdin);
printf("\n Podaj date urodzenia ");
printf("\n
dzien :");
scanf ("%d",&studenci[i].dataUr.dzien);
printf("\n miesiac :");
scanf ("%d",&studenci[i].dataUr.miesiac);
printf("\n
rok :");
scanf ("%d",&studenci[i].dataUr.rok);
printf("\n Rok studiow :");
scanf("%d",&studenci[i].rokStudiow);
printf ("\n
Wydział: ");
scanf("%s",studenci[i].wydzial); fflush(stdin);
Język ANSI C-struktury
// Program rekordy2 cz. IV
/* Drukowanie tablicy struktur */
for (i=0;i<4;i++)
{
printf("\n\n Dane studenta %d ", i+1);
printf("\n Nazwisko
:%s", studenci[i].nazwisko);
printf("\n
Imie
:%s", studenci[i].imie);
printf(" data urodzenia :%d.%d.%d ",\
studenci[i].dataUr.dzien,\
studenci[i].dataUr.miesiac,studenci[i].dataUr.rok);
printf("\n Rok studiow :%d", studenci[i].rokStudiow);
printf("\n Wydzial
:%s", studenci[i].wydzial);
}
getchar();
return 0;
}