Wykład 4 adt- reprezentacja kolejki jako tablicy I struktury wiązanej



Pobieranie 191.1 Kb.
Data01.05.2016
Rozmiar191.1 Kb.
Wykład 4

ADT- reprezentacja kolejki jako tablicy i struktury wiązanej
Reprezentacja typu ([6]) T = (CI(I), S  O) składa się z

  1. wybranej interpretacji operacji zawartych w S  O czyli modelu aksjomatów specyfikacji T

  2. funkcji  odwzorowującej termy w dziedzinę modelu aksjomatów.

Należy udowodnić poprawność reprezentacji weryfikując dwa rodzaje niezmienników:



  • niezmienników wrodzonych

  • niezmienników reprezentacji.


Niezmienniki wrodzone reprezentują relacje, które muszą być spełnione przez każdą reprezentację typu, tj. relacje odpowiadające aksjomatom specyfikacji.
Niezmienniki reprezentacji są specyficzne dla każdej wybranej reprezentacji.
Algorytm wyznaczenia poprawności reprezentacji algebraicznej specyfikacji typu w terminach języka programowania ([6])
  1. Podstawowa procedura w dowodzeniu poprawności reprezentacji polega na zamianie-dla każdego aksjomatu specyfikacji-wszystkich wystąpień każdej funkcji w aksjomacie przez jej interpretację.


  2. Następnie, na podstawie aksjomatyzacji operacji użytych przy budowie reprezentacji należy udowodnić, że wyrażenie otrzymane w wyniku opisanego zastępowania jest tożsamością.



Przykład 4.1


Reprezentacja typu Queue (wykład 3) jako Quadruple- czyli czwórki, w której pierwszy element jest wektorem, drugi indeksem w obrębie wektora następnego elementu, który ma być dodany do kolejki, trzeci jest indeksem elementu znajdującego się aktualnie na początku kolejki, a czwarty maksymalną liczbą elementów wektora. Zakłada się liczenie elementów od 0, czyli numer 0 oznacza pierwszy element wektora.

Dziedzina funkcji : .typ Quadruple

Przeciwdziedzina funkcji : .typ Queue

Dla każdej funkcji F w dziedzinie kolejki (Queue) mamy funkcje F_F w dziedzinie czwórki (Quadruple), określane jako termy.

Zgodnie z definicją reprezentacji typu Queue, należy termy w dziedzinie Quadruple odwzorować za pomocą funkcji w dziedzinę modelu aksjomatów Queue.
1) Definicje funkcji F_F

(error)=error

EMPTY=(EMPTY_F)

ADD((x),y)= (ADD_F(x, y))

FRONT((x))= (FRONT_F(x))

REMOVE((x))= (REMOVE_F(x))

IS_EMPTY?((x))= (IS_EMPTY_F?(x))
oraz opis syntaktyczno-aksjomatyczny Queue w dziedzinie Quadruple

EMPTY_F:  Quadruple

ADD_F: Quadruple  Item  Quadruple

FRONT_F: Quadruple  Item

REMOVE_F: Quadruple  Quadruple

IS_EMPTY_F?: Quadruple  Boolean



  1. IS_EMPTY_F? (EMPTY_F) = true

  2. IS_EMPTY_F?(ADD_F(q, i)) = false

  3. FRONT_F(EMPTY_F) = error

  4. FRONT_F(ADD_F(q,i))= if IS_EMPTY_F?(q) then i

else FRONT_F(q)

  1. REMOVE_F(EMPTY_F)=error

  2. REMOVE_F(ADD_F(q,i))= if IS_EMPTY_F?(q) then EMPTY_F

else ADD_F(REMOVE_F(q),i)
Należy podać sekwencje „instrukcji maszynowych” dla typów Quadruple, Vector, Item i Integer, reprezentujących Queue w dziedzinie programu. Zakłada się, że typy Item i Integer są predefiniowane w danym języku.

2. Definicje ADT w dziedzinie reprezentacji


2.1)Vector

  1. opis nieformalny operacji na wektorze elementów

EMPTY_V: Zainicjowanie wektora pustego

ASSIGN: Wstawienie do zainicjowanego wektora elementu na wybranej pozycji

READ: Pobranie z zainicjowanego wektora elementu z wybranej pozycji

IS_EMPTY_V?: Sprawdzenie, czy zainicjowany wektor jest pusty




  1. opis syntaktyczny operacji na wektorze elementów

EMPTY_V:  Vector

ASSIGN: Vector  Index  Item  Vector

READ: Vector  Index  Item

IS_EMPTY_V?: Vector  Boolean





  1. opis aksjomatyczny operacji wektorze elementów

Uwaga: do opisu zastosowano funkcję EQUAL? dla Index=Integer


  1. IS_EMPTY_V?(EMPTY_V)= true

  2. IS_EMPTY_V?(ASSIGN(v,i,a))= false

  3. READ(EMPTY_V,i)=error

  4. READ(ASSIGN(v,i1,a),i2)= if EQUAL? (i1,i2) then a

else READ(v,i2)

2.2) Quadruple



zainicjowanie kolejki: n=8 end=0, start=n

dodanie: vector[end], end=(end+1) mod n

usuwanie: start=start mod n , return vector[start], start++


  • Kolejka pusta zainicjowana: MAX=8 n=MAX end=0, start=n




0

1

2

3

4

5

6

7




























  • Kolejka zawiera trzy elementy: end=3, start=0




start







end













a

b

c















  • Kolejka zawiera trzy elementów: end=6, start=3














start







end












d

e

f










  • Kolejka zawiera pięć elementów: end=2, start=5










end







start







d

e










a

b

c




  • Kolejka pełna: end=5, start=5 (po wstawieniu na end=4)



















start

end








d

e

f

g

h

a

b

c




  • Kolejka pusta, stan nieokreślony: end=2, start=2 (po usunięciu elementu start=1). Należy więc po usunięciu ostatniego elementu zainicjować kolejkę tak, aby start =n, end=0, czyli wprowadzić kolejkę w stan a)










start

end












































  1. definicja nieformalna operacji na czwórce

BUILD: Udostępnia cztery dane: pierwsza- wektor danych (tablicę), druga- indeks nowego elementu kolejki umieszczanego za ostatnio wstawionym elementem w wektorze (end), trzeci- indeks pierwszego elementu kolejki (start), czwarty- maksymalną pojemność kolejki czyli maksymalny rozmiar wektora (n)

FIRST: Podaje pierwszy element czwórki, czyli wektor elementów

SECOND: Podaje drugi element czwórki, czyli indeks nowego elementu w wektorze, za ostatnio wstawionym

THIRD: Podaje trzeci element czwórki, czyli indeks elementu w wektorze oznaczający pierwszy element kolejki (początek kolejki)

FOURTH: Podaje czwarty element czwórki czyli maksymalny rozmiar wektora


  1. opis syntaktyczny operacji na czwórce
BUILD: Item1  Item2  Item3  Item4  Quadruple

FIRST: Quadruple  Item1

SECOND: Quadruple  Item2

THIRD: Quadruple  Item3

FOURTH: Quadruple  Item4




  1. opis aksjomatyczny operacji na trójce

Uwaga: Do opisu zastosowano funkcje SUCC, ZERO, EQUAL?, >? dla Item2=Item3=Item4=Integer. Pierwszy element czwórki jest Item1=Vector.
(T1) FIRST(BUILD(v, i, f, n))= v

(T2) SECOND(BUILD(v, i, f, n))= i

(T3) THIRD(BUILD(v, i, f, n))= f

(T4) FOURTH(BUILD(v, i, f, n))= n


Pominięto dowód niesprzeczności i wystarczającej zupełności dla typów Vector (wykład 3) i Quadruple.


  1. Definicje interpretacji operacji kolejki (Queue) w dziedzinie czwórki (Quadruple)

(IT1) EMPTY_F: BUILD(EMPTY_V, ZERO, MAX, MAX)


(IT2) ADD_F(A, B):

if (not EQUAL?(SECOND(A), THIRD(A)))

then

( if (EQUAL?(THIRD(A), FOURTH(A)))



then THIRD(A)=THIRD(A) mod FOURTH(A);

BUILD(ASSIGN(FIRST(A), SECOND(A), B),

SUCC(SECOND(A)) mod FOURTH(A),THIRD(A), FOURTH(A));)

else error
(IT3) FRONT_F(A):

if (EQUAL?(SECOND(A),ZERO)and EQUAL?(THIRD(A),FOURTH(A)))

then error

else READ(FIRST(A),THIRD(A) mod FORTH(A))
(IT4) REMOVE_F(A):

if (EQUAL?(SECOND(A),ZERO) and EQUAL?(THIRD(A),FOURTH(A)))

then error

else if EQUAL?(SECOND(A),

SUCC(THIRD(A) mod FORTH(A)) mod FORTH(A))



then EMPTY_F

else BUILD(FIRST(A),SECOND(A),SUCC(THIRD(A)mod FORTH(A)),

FORTH(A))


(IT5) IS__EMPTY_F?(A):

EQUAL?(SECOND(A),ZERO) and EQUAL?(THIRD(A),FOURTH(A))





  1. Definicja funkcji 




  1. (error)= error

  2.  (BUILD(EMPTY_V, ZERO, N, N))= EMPTY

  3. (BUILD(FIRST(A),SECOND(A),SUCC(THIRD(A) mod FOURTH(A))))=

if EQUAL?(SECOND(A),

SUCC(THIRD(A) mod FORTH(A)) mod FORTH(A))



then EMPTY

else REMOVE((A))

(4)  (BUILD(ASSIGN(FIRST(A), SECOND(A), B),

SUCC(SECOND(A)) mod FORTH(A), THIRD(A)))= ADD((A),B)

(5)  (BUILD(ASSIGN(FIRST(A), SECOND(A), B),

SUCC(SECOND(A)) mod FOURTH(A),

SUCC(THIRD(A) mod FOURTH(A)), FOURTH(A)))

= if EQUAL?(SECOND(A),

SUCC(THIRD(A)mod FOURTH(A))mod FOURTH(A))



then ADD(EMPTY, B)

else REMOVE(ADD((A),B))


  1. Dowód niezmiennika czwórki

(NT1) Dla dowolnej czwórki A zdefiniowanej jako Quadruple jest albo

EQUAL?(SECOND(A), THIRD(A) mod FOURTH(A))= true

albo not EQUAL?(SECOND(A), THIRD(A) mod FOURTH(A))= true


Dowód (NT1) można przeprowadzić przez indukcję względem zagnieżdżeń operatora EQUAL? oraz własności dzielenia z resztą liczb całkowitych. Pierwsza reguła jest prawdziwa zarówno po usunięciu ostatniego elementu i zainicjowaniu kolejki lub zapełnieniu kolejki. Druga reguła jest prawdziwa tylko w przypadku niepustej kolejki, do której można wstawić nowy element.

6) Weryfikacja wybranych niezmienników z sześciu niezmienników wrodzonych





  1. FRONT_F(EMPTY_F) = error (IT3), (IT1)

FRONT_F(EMPTY_F)

= if (EQUAL?(SECOND(BUILD(EMPTY_V,ZERO,MAX,MAX)),ZERO)

and EQUAL?(THIRD(BUILD(EMPTY_V,ZERO,MAX,MAX)),

FOURTH(BUILD(EMPTY_V,ZERO,MAX,MAX))))



then error

else READ(FIRST(BUILD(EMPTY_V,ZERO,MAX,MAX)),

THIRD(BUILD(EMPTY_V,ZERO,MAX,MAX))



mod FORTH(BUILD(EMPTY_V,ZERO,MAX,MAX)))

=if (EQUAL?(ZERO,ZERO) and EQUAL?(MAX,MAX)) then error

(T2),(T3),(T4)

else READ(EMPTY_V,(MAX) mod (MAX)) (T1),(T3),(T4)

=error wł.liczb c.


(4) FRONT_F(ADD_F(A,B))= if IS_EMPTY_F?(A) then B

else FRONT_F(A) (IT3), (IT2)
Zakładamy, że przed wykonaniem ADD_F kolejka jest niepełna lub pusta, czyli:

not EQUAL?(SECOND(A),THIRD(A) mod FORTH(A)) or

(EQUAL?(SECOND(A),ZERO) and EQUAL?(THIRD(A),FOURTH(A)))=true

FRONT_F(ADD_F(A,B))

= if (EQUAL?(SECOND(BUILD(ASSIGN(FIRST(A), SECOND(A), B),

SUCC(SECOND(A)) mod FOURTH(A),

THIRD(A),FOURTH(A))),

ZERO)

and

EQUAL?(THIRD(BUILD(ASSIGN(FIRST(A), SECOND(A), B),

SUCC(SECOND(A)) mod FOURTH(A),

THIRD(A), FOURTH(A))),

FOURTH(BUILD(ASSIGN(FIRST(A), SECOND(A), B),

SUCC(SECOND(A)) mod FOURTH(A),

THIRD(A), FOURTH(A)))))

then error

else READ(FIRST(BUILD(ASSIGN(FIRST(A), SECOND(A), B),

SUCC(SECOND(A)) mod FOURTH(A),

THIRD(A), FOURTH(A))),

THIRD(BUILD(ASSIGN(FIRST(A), SECOND(A), B),

SUCC(SECOND(A)) mod FOURTH(A),

THIRD(A), FOURTH(A)))



mod FORTH(BUILD(ASSIGN(FIRST(A), SECOND(A), B),

SUC(SECOND(A)) mod FOURTH(A),

THIRD(A), FOURTH(A))))

= if (EQUAL?((SUCC(SECOND(A)) mod FOURTH(A))), ZERO) (T2)



and EQUAL?(THIRD(A), FOURTH(A))) then error (T3),(T4)

else

READ(ASSIGN(FIRST(A), SECOND(A), B), THIRD(A) mod FOURTH(A))

(T1),(T3),(T4)

= READ(ASSIGN(FIRST(A),SECOND(A),B),THIRD(A) mod FOURTH(A))

(NT1)

= if EQUAL?(SECOND(A),THIRD(A) mod FOURTH(A)) then B (V4)



else READ(FIRST(A),THIRD(A) mod FOURTH(A))

= if IS_EMPTY_F?(A)) then B z założenia i (IT5)



else FRONT_F(A) (IT3)
Przykład 4.2

Reprezentacja typu Queue w postaci dwójki Couple, której pierwszy element zawiera wskazanie na ostatni element kolejki, a drugi element zawiera wskazanie na pierwszy element kolejki jako struktury wiązanej. Kolejka czyli struktura wiązana (rekurencyjna struktura danych) składa się z elementów, które zawierają dane oraz wskazanie na następny element takiej samej struktury.

Dziedzina funkcji : .typ Couple

Przeciwdziedzina funkcji : : typ Queue

Dla każdej funkcji F w dziedzinie kolejki mamy funkcje F_T w dziedzinie dwójki.
1) Definicje funkcji F_T

EMPTY=(EMPTY_C)

ADD((x),y)= (ADD_C(x,y))

FRONT((x))= (FRONT_C(x))

REMOVE((x))= (REMOVE_C(x))

IS_EMPTY?((x))= (IS_EMPTY_C?(x))


oraz opis syntaktyczno-aksjomatyczny Queue w dziedzinie Couple
EMPTY_C:  Couple

ADD_C: Couple  Item  Couple

FRONT_C: Couple  Item

REMOVE_C: Couple  Couple

IS_EMPTY_C?: Couple  Boolean


  1. IS_EMPTY_C? (EMPTY_C) = true

  2. IS_EMPTY_C?(ADD_C(q, i)) = false

  3. FRONT_C(EMPTY_C) = error

  4. FRONT_C(ADD_C(q,i))= if IS_EMPTY_C?(q) then i

else FRONT_C(q)

  1. REMOVE_C(EMPTY_C)=error

  2. REMOVE_C(ADD_C(q,i))= if IS_EMPTY_C?(q) then EMPTY_C

else ADD_C(REMOVE_C(q),i)
Należy podać sekwencje „instrukcji maszynowych” dla typów Couple, Stack_Q, Item i Integer, reprezentujących Queue w dziedzinie programu. Zakłada się, że typy Item i Integer są predefiniowane w danym języku.

  1. Definicje ADT

2.1)Stack_Q


a) opis nieformalny operacji na strukturze wiązanej elementów

NEW: Zainicjowanie pustej struktury wiązanej

PUSH_Q: Wstawienie do zainicjowanej wiązanej struktury elementu na wybranej pozycji

POP_Q: Usunięcie z niepustej struktury wiązanej elementu z wybranej pozycji

TOP_Q: Pobranie danej z pierwszego elementu

IS_EMPTY_Q?: Sprawdzenie, czy zainicjowana struktura wiązana jest pusta



  1. opis syntaktyczny operacji na strukturze wiązanej elementów

NEW_Q:  Stack_Q

PUSH_Q: Stack_Q  Item  Stack_Q

POP_Q: Stack_Q  Stack_Q

TOP_Q: Stack_Q  Item

IS_EMPTY_Q?: Stack_Q  Boolean


  1. opis aksjomatyczny operacji na strukturze wiązanej elementów

  1. IS_EMPTY_Q?(NEW_Q)= true

  2. IS_EMPTY_Q?(PUSH_Q(s,a))= false

  3. POP_Q(NEW_Q)= error

  4. POP_Q(PUSH_Q(s,a))= if IS_EMPTY_Q?(s) then NEW_Q

else PUSH_Q(POP_Q(s),a)

  1. TOP_Q(NEW_Q)= error

  2. TOP_Q(PUSH_Q(s,a))= if IS_EMPTY_Q?(s) then a

else TOP_Q(s)

2.2) Couple



  • Kolejka pusta: end=start=0

  • Kolejka zawiera dwa elementy: end  start

start end

a




b




c




d



______­­




_______




_______

0




  • Kolejka zawiera jeden element

start = end  0

a

0

  1. definicja nieformalna operacji na dwójce

BUILD: Udostępnia dwie dane: pierwsza- wskazanie na ostatni element w strukturze wiązanej, druga- wskazanie na pierwszy element struktury wiązanej (kolejki)

FIRST: Podaje pierwszy element dwójki, czyli wskazanie na element, który będzie przechowywał wskazanie na wstawiany element do kolejki

SECOND: Podaje drugi element dwójki wskazujący na pierwszy element kolejki

COPY: Operacja nadaje kopię elementu pierwszego elementowi drugiemu w dwójce




  1. opis syntaktyczny operacji na trójce

Uwaga: Item1=Item2=Stack_Q

BUILD: Item1  Item2  Couple

COPY Couple  Couple

FIRST: Couple  Item1


SECOND: Couple  Item2




  1. opis aksjomatyczny operacji na dwójce

(T1) FIRST(BUILD(k, p))= k

(T2) SECOND(BUILD(k, p))= p

(T3) COPY(BUILD(k,p))=BUILD(k,k)
Pominięto dowód niesprzeczności i wystarczającej zupełności dla typów Stack_Q i Couple.


  1. Definicje interpretacji operacji kolejki w dziedzinie dwójki

(IC1) EMPTY_C: BUILD(NEW_Q, NEW_Q)


(IC2) IS__EMPTY_C?(A): IS_EMPTY_Q?(SECOND(A))
(IC3) ADD_C(A, B):if IS_EMPTY_Q?(SECOND(A))

then COPY(BUILD(PUSH_Q(FIRST(A),B), SECOND(A)))

else BUILD(PUSH_Q(FIRST(A), B), SECOND(A))
(IC4) REMOVE_C(A): if IS_EMPTY_Q?(SECOND(A))

then error

else if IS_EMPTY_Q?(POP_Q(SECOND(A)))

then EMPTY_C

else BUILD(FIRST(A), POP_Q(SECOND(A)))
(IC5) FRONT_C(A): if IS_EMPTY_Q?(SECOND(A))

then error

else TOP_Q(SECOND(A))



  1. Definicja funkcji 




  1. (error)= error

  2. (BUILD(NEW_Q, NEW_Q))= EMPTY

  3. (BUILD(FIRST(A), POP_Q(SECOND(A))))=

= if IS_EMPTY_Q?(SECOND(A))

then error

else if IS_EMPTY_Q?(POP_Q(SECOND(A)))

then EMPTY else REMOVE((A))

  1.  (ADD_C(A,B))= ADD((A),B)

  2.  (BUILD(PUSH_B(FIRST(A),B), POP_Q(SECOND(A))))

= if IS_EMPTY_Q?(POP(SECOND(A)) then ADD(EMPTY,B)

else REMOVE(ADD((A),B))

  1. Dowód niezmiennika dwójki:

(NC1) Dla dowolnej dwójki A zdefiniowanej jako Couple jest albo

IS_EMPTY_Q?(FIRST(A)) and IS_EMPTY_Q?(SECOND(A))= true

albo


not IS_EMPTY_Q?(FIRST(A)) and not IS_EMPTY_Q?(SECOND(A))= true
Dowód (NC1) można przeprowadzić na podstawie własności dwójki (IC1) dla kolejki pustej oraz (SQ1):

jeśli FIRST(A) wynosi NEW_Q to IS_EMPTY_Q?(NEW_Q)=true


jeśli SECOND(A) wynosi NEW_Q to IS_EMPTY_Q?(NEW_Q)=true

stąd true and true=true

oraz (IC3)

FIRST(A) jest identyczne z SECOND(A) po wykonaniu operacji PUSH_Q(NEW_Q,B) na pustej strukturze wiązanej i przypisanie tego samego wskazania do dwóch elementów dwójki. Stąd mamy:



not IS_EMPTY_Q?(FIRST(A))=not false =true

not IS_EMPTY_Q?(SECOND(A))IS_EMPTY_Q?(FIRST(A))=not false =true

stąd true and true=true

W przypadku kolejki, która posiada co najmniej dwa elementy, jest zawsze słuszna ta zależność.
6) Weryfikacja wybranych niezmienników z sześciu niezmienników wrodzonych
(3) FRONT_C(EMPTY_C) = error (IC5),(IC1)
FRONT_C(EMPTY_C)

= if IS_EMPTY_Q?(SECOND(BUILD(NEW_Q, NEW_Q))) then error



else TOP_Q(SECOND(A))

= if IS_EMPTY_Q?( NEW_Q) then error



else TOP_Q(SECOND(A)) (T2)

=error (SQ1)

(4) FRONT_C(ADD_C(A,B))= if IS_EMPTY_C?(A) then B

else FRONT_C(A) (IC5),(IC3)
1)Zakładamy, że kolejka jest pusta.

Stąd mamy:

IS_EMPTY_C?(A)=true, czyli A=EMPTY_C

FIRST(A)=SECOND(A)=NEW_Q.

ADD_C(A,B)= COPY(BUILD(PUSH_Q(FIRST(A), B), SECOND(A)))
FRONT_C(ADD_C(A,B))

= if IS_EMPTY_Q?(SECOND(COPY(BUILD(PUSH_Q(FIRST(A), B),

SECOND(A)))))

then error

else TOP_Q(SECOND(COPY(BUILD(PUSH_Q(FIRST(A), B), SECOND(A)))))

= if IS_EMPTY_Q?(PUSH_Q(FIRST(A), B)) (T3),(T2)



then error

else TOP_Q(PUSH_Q(FIRST(A),B)) (T3),(T2)

= TOP_Q(PUSH_Q(FIRST(A),B)) (SQ2)



= if IS_EMPTY_Q?(FIRST(A)) then B (SQ6)

else TOP_Q(FIRST(A))

=if IS_EMPTY_C?(A) then B z założenia (1), (NC1), (IC2)
2)Zakładamy, że kolejka nie jest pusta.

Stąd mamy

IS_EMPTY_C?(A)=false.

ADD_C(A,B)= BUILD(PUSH_Q(FIRST(A), B), SECOND(A)))


FRONT_C(ADD_C(A,B))

=if IS_EMPTY_Q?(SECOND(BUILD(PUSH_Q(FIRST(A), B), SECOND(A))))

then error

else TOP_Q(SECOND(BUILD(PUSH_Q(FIRST(A), B), SECOND(A))))

= if IS_EMPTY_Q?(SECOND(A)) (T2)



then error

else TOP_Q(SECOND(A)) (T2)

= TOP_Q(SECOND(A))  FRONT_C(A) z założenia 2,(T2) i (IC5)


Stąd mamy:

FRONT_C(ADD_C(A,B)) = if IS_EMPTY_C?(A) then B



else FRONT_C(A)


Budowa oprogramowania

Program dla przykładu 4.1- kolejka jako tablica cykliczna



#ifndef _mkolejka

#define _mkolejka

#include

#include "strukt.h"

const int MAX=4;

typedef struct Item* PItem; //typ wskazania na dane umieszczone w strukturze Item

typedef PItem* Vector; //typ wskazania na wskazanie na dane

typedef void(* Pfunction)(Item&); //typ wskaźnika na funkcję do obsługi danej
struct Quadruple //czwórka- struktura Quadruple

{ Vector vector; //wektor



int end,start,size; //indeks miejsca do wstawienia, indeks elementu do

}; //usuwania, rozmiar wektora



void BUILD(Vector vector, int end,int start,int size,

Quadruple &quadruple);



/*działanie: udostępnia do zapisu tablicę-vector, indeks end elementu na końcu danych w tablicy vector, indeks start elementu na początku danych w tablicy vector oraz rozmiar tablicy vector. Zapisuje te dane do struktury quadruple.

warunki początkowe: zainicjowana tablica pusta vector (NULL) lub wskazanie na pierwszy element tablicy vector, indeks end elementu wstawianego za ostatnio wstawionym elementem do tablicy vector, indeks start elementu stojącego na początku danych w kolejce-vector, maksymalny rozmiar size tablicy vector

warunki końcowe: dane vector, end, start, size funkcja umieszcza w zwracanej strukturze quadruple*/

inline Vector& FIRST(Quadruple& quadruple);

/*działanie: zapisuje lub czyta adres pierwszego elementu tablicy vector ze struktury quadruple

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania podaje referencję do wskazania vector (tablicy) umieszczoną w strukturze quadruple*/

inline int& SECOND(Quadruple& quadruple);

/*działanie: zapisuje lub czyta indeks nowego elementu w tablicy vector ze struktury quadruple

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania podaje referencję do indeksu miejsca na nowy element w tablicy vector, umieszczoną w strukturze quadruple*/

inline int& THIRD(Quadruple& quadruple);

/*działanie: zapisuje lub czyta indeks miejsca na pierwszy (usuwany) element w tablicy vector ze struktury quadruple

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania podaje referencję do indeksu miejsca na pierwszy element (usuwany) w tablicy vector, umieszczoną w strukturze quadruple*/

inline int& FOURTH(Quadruple& quadruple);

/*działanie: zapisuje lub czyta rozmiar tablicy vector ze struktury quadruple

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania podaje referencję do rozmiaru tablicy vector, umieszczoną w strukturze quadruple*/

//typ kolejka pomocnicza-dynamiczna tablica wskaźników

inline int IS_EMPTY_V(Vector vector);

/*działanie: sprawdza, czy tablica vector jest zainicjowana

warunki początkowe: zainicjowana struktura quadruple pusta lub niepusta

warunki końcowe: funkcja jako wynik swojego działania podaje wartość logiczną 1, gdy tablica jest pusta lub 0 w przeciwnym wypadku*/

inline Vector EMPTY_V(int size);

/*działanie: przydziela pamięć na tablicę vector jako ciąg size niezainicjowanych wskaźników na struktury Item

warunki początkowe: niezainicjowana tablica vector

warunki końcowe: funkcja jako wynik swojego działania podaje wskazanie vector na pierwszy niezainicjowany wskaźnik umieszczony w tablicy vector*/

Vector ASSIGN(Vector vector,int& index, PItem pitem);



/*działanie: zapisuje nowy element w tablicy vector na miejscu index i zwiększa index o 1

warunki początkowe: zainicjowana tablica vector oraz wolne miejsce index w tablicy vector

warunki końcowe: funkcja jako wynik swojego działania podaje tablicę vector oraz zwraca nową wartość index*/

PItem READ(Vector vector, int index);



/*działanie: czyta element tablicy vector na miejscu indeks

warunki początkowe: zainicjowana tablica vector oraz zainicjowany element Item o wskazaniu przechowywanym na miejscu index

warunki końcowe: funkcja jako wynik swojego działania podaje wskaźnik elementu Item odczytanego na miejscu index w tablicy vector*/
//kolejka

void EMPTY_F(Quadruple &quadruple);

/*działanie: inicjuje kolejkę jako pustą za pośrednictwem funkcji BUILD oraz EMPTY_V i inicjuje end jako 0, start jako Max oraz size jako Max

warunki początkowe: nie zainicjowana struktura quadruple

warunki końcowe: funkcja zwraca zainicjowaną strukturę quadruple*/

int IS_EMPTY_F(Quadruple quadruple);

/*działanie: sprawdza, czy kolejka jest pusta, czyli end ==0 i start==size

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania podaje wartość logiczną 1, gdy tablica jest pusta, w przeciwnym wypadku 0*/

int ADD_F(Quadruple &quadruple, Item item);

/*działanie: przydziela pamięć pitem na nowy element item za pomocą NEW_ITEM i dodaje go na końcu kolejki - do tablicy vector pobranej ze struktury quadruple, jeśli tablica jest pusta *(IS_EMPTY_F==1) lub nie jest pełna (end != start % size)

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania zwraca 1, gdy było miejsce w kolejce, ustawia start=start%size oraz przekazuje indeks na nowy element równy end=end%size, w przeciwnym wypadku zwraca 0*/

int REMOVE_F(Quadruple &quadruple);

/*działanie: usuwa z pamięci element pierwszy z niepustej kolejki: wyznacza aktualny adres pierwszego elementu start=start%size i czyta element z tablicy vector za pomocą READ i usuwa go za pomocą delete- dane kolejki pobiera ze struktury quadruple, następnie zwiększa start o 1

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania podaje 1, gdy usunęła element z tablicy niepustej (EMPTY_F==1) i w przypadku, gdy był to ostatni element ustawia end=0, start=size, w przeciwnym wypadku zwraca 0*/

int FRONT_F(Quadruple quadruple,Item& item);

/*działanie: czyta dane item z pierwszego elementu z niepustej kolejki: wyznacza aktualny adres pierwszego elementu start=start%size i za pomocą READ czyta go z tablicy vector- dane kolejki pobiera ze struktury quadruple

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania podaje 1, gdy odczytała element z tablicy niepustej i podaje go w item, w przeciwnym wypadku zwraca 0 (kolejka pusta: end=0, start=size)*/
//funkcje pomocnicze

PItem NEW_ITEM(Item n_item);



/*działanie: przydziela pamięć element na element Item i wstawia do niego dane n_item

warunki początkowe: dane n_item

warunki końcowe: funkcja jako wynik swojego działania podaje adres utworzonej struktury z danymi n_tem lub adres pusty NULL, gdy nie udało sie przydzielić pamięci */

int FOR_ONE(Quadruple& quadruple, Pfunction function);

/*działanie: wykonuje operację function na danej pobranej z pierwszego elementu niepustej kolejki- dane kolejki pobrane ze struktury quadruple

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania podaje 1, gdy wykonała operację function na elemencie pierwszym z kolejki- z tablicy niepustej i w przypadku, w przeciwnym wypadku zwraca 0*/

int FOR_EACH(Quadruple& quadruple, Pfunction function);

/*działanie: wykonuje operację function na wszystkich danych pobranych z niepustej kolejki- dane kolejki pobrane ze struktury quadruple

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: funkcja jako wynik swojego działania podaje 1, gdy tablica była niepusta, w przeciwnym wypadku zwraca 0*/

void FREE(Quadruple& quadruple);

/*działanie: usuwa z pamięci wszystkie elementy z niepustej kolejki oraz tablicę vector– dane kolejki pobrane ze struktury quadruple

warunki początkowe: zainicjowana struktura quadruple

warunki końcowe: niezainicjowana struktura quadruple/

#endif


#include

#include

#include "mkolejka.h"

//typ Quadruple


void BUILD(Vector vector, int end,int start,int size,

Quadruple &quadruple)

{ quadruple.vector=vector;

quadruple.end=end;

quadruple.start=start;

quadruple.size=size;}



inline Vector& FIRST(Quadruple& quadruple) {return quadruple.vector;}

inline int& SECOND(Quadruple& quadruple) {return quadruple.end;}

inline int& THIRD(Quadruple& quadruple) {return quadruple.start;}

inline int& FOURTH(Quadruple& quadruple) {return quadruple.size;}
//typ kolejka pomocnicza-dynamiczna tablica wskaznikow

inline int IS_EMPTY_V(Vector vector) {return vector==NULL;}

inline Vector EMPTY_V(int size) {return new PItem [size];}
Vector ASSIGN(Vector vector,int& index, PItem pitem)

{ vector[index++]=pitem;



return vector; }
PItem READ(Vector vector, int index) { return vector[index];}
//kolejka
void EMPTY_F(Quadruple &quadruple)

{BUILD(EMPTY_V(MAX),0,MAX,MAX,quadruple);}


int IS_EMPTY_F(Quadruple quadruple)

{ return FOURTH(quadruple)==THIRD(quadruple) && SECOND(quadruple)==0;}


int ADD_F(Quadruple &quadruple, Item item)

{PItem pitem;



if (!(SECOND(quadruple)==THIRD(quadruple)))

{pitem=NEW_ITEM(item);



if (pitem==NULL) return 0;

if (THIRD(quadruple)==FOURTH(quadruple))

THIRD(quadruple)%=FOURTH(quadruple);

ASSIGN(FIRST(quadruple),SECOND(quadruple),pitem);

SECOND(quadruple)%=FOURTH(quadruple);



return 1;}

return 2;}

int REMOVE_F(Quadruple &quadruple)

{ if (IS_EMPTY_F(quadruple)) return 0;

THIRD(quadruple)%=FOURTH(quadruple);

delete READ(FIRST(quadruple),THIRD(quadruple)++);



if (SECOND(quadruple)==(THIRD(quadruple)%FOURTH(quadruple)))

{ SECOND(quadruple)=0; THIRD(quadruple)=MAX;}



return 1;}
int FRONT_F(Quadruple quadruple,Item& item)

{if (IS_EMPTY_F(quadruple)) return 0;

THIRD(quadruple)%=FOURTH(quadruple);

item=*READ(FIRST(quadruple),THIRD(quadruple));



return 1;}
//funkcje pomocnicze

PItem NEW_ITEM(Item n_item)

{PItem pitem = new Item;

if (pitem!=NULL) *pitem=n_item;

return pitem;}
int FOR_ONE(Quadruple& quadruple, Pfunction function)

{ if (IS_EMPTY_F(quadruple)) return 0;



int a=THIRD(quadruple)%FOURTH(quadruple);

function(*READ(FIRST(quadruple),a));



return 1;}
int FOR_EACH(Quadruple& quadruple, Pfunction function)

{ if (IS_EMPTY_F(quadruple)) return 0;



int a=THIRD(quadruple);

int b=SECOND(quadruple);

int c=FOURTH(quadruple);

if (b==0)b=c;

do

{a%=c;function(*READ(FIRST(quadruple),a));a++;

}while(a!=b);

return 1;}
void FREE(Quadruple& quadruple)

{ if (!IS_EMPTY_F(quadruple))

{ int a=(THIRD(quadruple)%=FOURTH(quadruple));

int b=SECOND(quadruple);

int c=FOURTH(quadruple);

if (b==0) b=c;

do

{a%=c; delete READ(FIRST(quadruple),a); a++;

}while(a!=b);}

delete[] FIRST(quadruple);}



#include

#include

#include

#include "mkolejka.h"

#include "dodatki.h"

#include "we_wy.h"
char *options[N] = {"1 : Wstawianie do kolejki- na poczatek",

"2 : Usuwanie z kolejki-na poczatku",

"3 : Wydruk kolejki",

"4 : Usun kolejke",

" >4 Koniec programu"};
void INSERT(Quadruple& quadruple);

void REMOVE(Quadruple& quadruple);

void main(void)

{ Quadruple queue; char option;

clrscr();

EMPTY_F(queue);



do

{ option= MENU(N, options);



switch (option)

{ case '1' : INSERT(queue); break;



case '2' : REMOVE(queue);break;

case '3' : if (!FOR_EACH(queue,SHOW_ITEM))

INFO("\r\nKolejka pusta");break;



case '4' : FREE(queue);

EMPTY_F(queue);break;

default : INFO("\r\nKoniec programu");

}

} while (option < '5' && option >'0' );



FREE(queue);

}

void INSERT(Quadruple& quadruple)

{ int a=ADD_F(quadruple, DATA());

switch(a)

{

case 0:INFO("\r\nBrak pamieci");break;



case 1:INFO("\r\nWstawiono do kolejki");break;

case 2:INFO("\r\nKolejka pelna");break;

}}

void REMOVE(Quadruple& quadruple)

{ int a=REMOVE_F(quadruple);

switch(a)

{ case 0:INFO("\r\nkolejka pusta");break;



case 1:INFO("\r\nUsunieto kolejki");break;

}}



- usuwanie elementów zawsze na początku struktury


#ifndef _mkolejka

#define _mkolejka

#include

#include "strukt.h"

typedef struct Stack_Q* PStack_Q; //wskaźnik na element struktury wiązanej

//wskaźnik na funkcję przetwarzającą dane umieszczone w elementach struktury wiązanej

typedef void(* Pfunction)(Item&);

struct Stack_Q //element struktury wiązanej

{Item data;

PStack_Q next; //adres kolejnego elementu

};

struct Couple //struktura couple przechowująca dane kolejki

{ PStack_Q end,start; //czyli wskazania ostatniego i pierwszego elementu

}; //struktury wiązanej - kolejki


//typ Couple
Couple& BUILD(PStack_Q end,PStack_Q start,Couple &couple);

/*działanie: udostępnia do zapisu i odczytu wskazania na pierwszy i ostatni element struktury wiązanej-kolejki

warunki początkowe: zainicjowana lub niezainicjowana struktura couple

warunki końcowe: zainicjowana struktura couple wskazaniami na puste lub niepuste elementy struktury wiązanej - kolejki*/

inline PStack_Q& FIRST(Couple& couple);

/*działanie: udostępnia do zapisu i odczytu wskazanie na ostatni element struktury wiązanej-kolejki

warunki początkowe: zainicjowana struktura couple

warunki końcowe: funkcja zwraca jako wynik swojego działania wskazanie na pusty lub niepusty ostatni element struktury wiązanej - kolejki*/

inline PStack_Q& SECOND(Couple& couple);

/*działanie: udostępnia do zapisu i odczytu wskazanie na pierwszy element struktury wiązanej-kolejki

warunki początkowe: zainicjowana struktura couple

warunki końcowe: funkcja zwraca jako wynik swojego działania wskazanie na pusty lub niepusty pierwszy element struktury wiązanej - kolejki*/

inline void COPY(Couple &couple);

/*działanie: kopiuje wskazanie na ostatni element kolejki do wskazania na pierwszy element

warunki początkowe: zainicjowana struktura couple

warunki końcowe: funkcja zwraca strukturę couple, której oba wskazania są identyczne */
//typ kolejka pomocnicza

inline int IS_EMPTY_Q(PStack_Q pstack_q);

/*działanie: sprawdza, czy wskaźnik pstack_q jest pusty

warunki początkowe: zainicjowana struktura pstack_q

warunki końcowe: funkcja zwraca jako wynik swojego działania 1, gdy wskaźnik jest pusty, w przeciwnym wypadku zwraca 0*/

inline PStack_Q NEW_Q();

/*działanie: podaje adres pusty NULL

warunki początkowe:

warunki końcowe: funkcja zwraca jako wynik swojego działania wskazanie puste NULL*/

PStack_Q PUSH_Q(PStack_Q& end, Item item);



/*działanie: przydziela pamięć na nowy element kolejki (NEW_ITEM). W przypadku pomyślnego przydziału pamięci umieszcza dane item w nowym elemencie i wstawia dane na końcu kolejki end. Jeśli kolejka nie jest pusta, wskazanie na nowy element umieszcza w ostatnim elemencie i zawsze inicjuje adres ostatniego elementu end na nowo wstawiony. Inicjuje wskazanie puste na następny element w ostatnim elemencie kolejki.

warunki początkowe: zainicjowane wskazanie end na ostatni pusty lub niepusty element kolejki oraz dane do wstawienia item

warunki końcowe: funkcja zwraca jako wynik swojego działania wskazanie na pusty lub niepusty ostatni element struktury wiązanej - kolejki*/

PStack_Q POP_Q(PStack_Q& start);



/*działanie: usuwa pierwszy element z niepustej kolejki.. W przypadku usunięcia ostatniego elementu zwraca adres pusty, w przeciwnym wypadku zwraca adres elementu, na który wskazywał usuwany element

warunki początkowe: zainicjowany niepusty adres start pierwszego elementu kolejki

warunki końcowe: funkcja zwraca jako wynik swojego działania wskazanie na pusty lub niepusty element znajdujący się na początku kolejki*/

Item TOP_Q(PStack_Q start);



/*działanie: pobiera dane z pierwszego elementu niepustej kolejki

warunki początkowe: zainicjowany niepusty adres pierwszego elementu kolejki start

warunki końcowe: funkcja zwraca jako wynik swojego działania dane item umieszczone w pierwszym elemencie niepustej kolejki*/

//kolejka



void EMPTY_C(Couple & couple);

/*działanie: inicjuje adres pierwszego i ostatniego elemetu kolejki na adres pusty NULL jako składowych struktury couple

warunki początkowe: zainicjowana lub niezainicjowana struktura couple

warunki końcowe: funkcja zwraca zainicjowaną pustymi adresami strukturę couple*/

int IS_EMPTY_C(Couple couple);

/*działanie: sprawdza czy kolejka jest pusta, testując składową end==NULL struktury couple

warunki początkowe: zainicjowana struktura couple

warunki końcowe: funkcja zwraca jako wynik swojego działania 1, gdy kolejka jest pusta, w przeciwnym wypadku zwraca 0*/

void ADD_C(Couple &couple, Item item);

/*działanie: wstawia dane item na końcu kolejki za pomocą PUSH_Q. Jeśli jest to pierwszy element kolejki, za pomocą funkcji COPY kopiuje adres wstawionego elementu do adresu pierwszego elementu

warunki początkowe: dane n_item, zainicjowana struktura couple

warunki końcowe: funkcja zwraca strukturę couple niepustą, obie składowe mają tylko wtedy równe wartości, gdy wstawiono pierwszy element do pustej kolejki*/

int REMOVE_C(Couple & couple);

/*działanie: usuwa pierwszy element z kolejki niepustej za pomocą POP_Q., W przypadku, gdy jest to ostatni element (wynik POP_Q ==NULL), ustawia adres ostatniego elementu na NULL

warunki początkowe: zainicjowna kolejka

warunki końcowe: funkcja zwraca jako wynik swojego działania 1, gdy kolejka nie była pusta, w przeciwnym wypadku zwraca 0 */

int FRONT_C(Couple couple,Item& item);

/*działanie: funkcja podaje dane przechowywane w pierwszym elemencie niepustej kolejki za pomocą funkcji TOP_Q

warunki początkowe: zainicjowana kolejka

warunki końcowe: funkcja jako wynik swojego działania zwraca 1, gdy kolejka nie była pusta oraz dane item przechowywane w pierwszym elemencie kolejki, w przeciwnym wypadku zwraca 0*/

//funkcje pomocnicze

PStack_Q NEW_ITEM(Item item);

/*działanie: przydziela pamięć na element Item i wstawia do niego dane n_item

warunki początkowe: dane n_item

warunki końcowe: funkcja jako wynik swojego działania podaje adres utworzonej struktury z danymi n_tem lub adres pusty NULL, gdy nie udało sie przydzielić pamięci */

void FREE(Couple &couple);

{działanie: usuwa elementy z kolejki i inicjuje kolejkę jako pustą- dane pobiera ze struktury couple



warunki początkowe: couple jest zainicjowaną strukturą

warunki końcowe: couple jest zainicjowaną strukturą, przechowującą dane pustej kolejki}

int FOR_EACH(Couple& couple, Pfunction function);

/*działanie: wykonuje operację function na wszystkich danych pobranych z niepustej kolejki- dane kolejki pobrane ze struktury couple

warunki początkowe: zainicjowana struktura couple

warunki końcowe: funkcja jako wynik swojego działania podaje 1, gdy kolejka była niepusta, w przeciwnym wypadku zwraca 0*/

int FOR_ONE(Couple& couple, Pfunction function);

/*działanie: wykonuje operację function na danej pobranej z pierwszego elementu niepustej kolejki- dane kolejki pobrane ze struktury couple

warunki początkowe: zainicjowana struktura couple

warunki końcowe: funkcja jako wynik swojego działania podaje 1, gdy wykonała operację function na elemencie pierwszym z kolejki niepustej, w przeciwnym wypadku zwraca 0*/

#endif
#include

#include "mkolejka.h"

//typ Couple


Couple& BUILD(PStack_Q end,PStack_Q start,Couple &couple)

{ couple.end=end;

couple.start=start;

return couple;}
inline PStack_Q& FIRST(Couple& couple) { return couple.end; }

inline PStack_Q& SECOND(Couple& couple) { return couple.start; }

inline void COPY(Couple &couple) { couple.start=couple.end;}
//typ Stack_Q
PStack_Q NEW_ITEM(Item item)

{ PStack_Q pstack_q;

pstack_q = new Stack_Q;

if (!IS_EMPTY_Q(pstack_q)) pstack_q->data=item;

return pstack_q;}
inline int IS_EMPTY_Q(PStack_Q pstack_q) { return pstack_q==NULL;}

inline PStack_Q NEW_Q() {return NULL;}
PStack_Q PUSH_Q(PStack_Q& end, Item item)

{PStack_Q pstack_q;

pstack_q = NEW_ITEM(item);

if (IS_EMPTY_Q(pstack_q)) return NULL;

if (!IS_EMPTY_Q(end)) end->next= pstack_q;

end= pstack_q; end->next= NULL;



return end;}
PStack_Q POP_Q(PStack_Q& start)

{PStack_Q pop;

pop = start; start = start->next;

delete pop;



return start;}
Item TOP_Q(PStack_Q start) { return start->data;}

// kolejka


void EMPTY_C(Couple &couple) { BUILD(NULL, NULL, couple);}

int IS_EMPTY_C(Couple couple) { return IS_EMPTY_Q(SECOND(couple));}
void ADD_C(Couple &couple, Item item)

{ PUSH_Q(FIRST(couple), item);



if(IS_EMPTY_Q(SECOND(couple))) COPY(couple);}
int REMOVE_C(Couple & couple)

{ if (IS_EMPTY_Q(SECOND(couple))) return 0;



if (IS_EMPTY_Q(POP_Q(SECOND(couple)))) FIRST(couple)=NULL;

return 1;}
int FRONT_C(Couple couple,Item& item)

{ if (IS_EMPTY_Q(SECOND(couple))) return 0;

item=TOP_Q(SECOND(couple));

return 1;}
//dodatkowe funkcje
void FREE(Couple & couple)

{ PStack_Q pop,start=SECOND(couple);



while (!IS_EMPTY_Q(start))

{pop= start;

start= start->next;

delete pop;}

EMPTY_C(couple);}
int FOR_EACH(Couple& couple, Pfunction function)

{ PStack_Q start=SECOND(couple);



if (IS_EMPTY_Q(start)) return 0;

while (!IS_EMPTY_Q(start))

{function(TOP_Q(start));

start=start->next;}

return 1;}
int FOR_ONE(Couple& couple, Pfunction function)

{ if (IS_EMPTY_C(couple)) return 0;

function(TOP_Q(FIRST(couple)));

return 1;}

#include

#include "mkolejka.h"

#include "dodatki.h"

#include "we_wy.h"

char * options[N] ={"1 : Wstawianie do kolejki- na koncu",

"2 : Usuwanie z kolejki-na poczatku",

"3 : Wydruk kolejki",

"4 : Usun kolejke",

" >4 Koniec programu"};

void main(void)

{ Couple queue; char option;

clrscr();

EMPTY_C(queue);



do

{ option= MENU(N, options);



switch (option)

{case '1' : ADD_C(queue, DATA()); break;



case '2' : if (!REMOVE_C(queue))

INFO("\r\nKolejka pusta"); break;



case '3' : if (!FOR_EACH(queue, SHOW_ITEM))

INFO("\r\nKolejka pusta");;break;



case '4' : FREE(queue);break;

default: INFO("\r\nKoniec programu");}

} while (option < '5' && option >'0' );

FREE(queue);

}

#ifndef DODATKI



#define DODATKI

const int N=5;

// funkcje ogólnego przeznaczenia



void INFO(char*);

char MENU(const int ile, char* options[]);

#endif
#include

#include "dodatki.h"

char MENU(const int ile, char* menu[])

{clrscr();



for (int i=0; i
return getch();}
void INFO(char* s) {cprintf(s); getch();}
#ifndef WE_WY

#define WE_WY

#include "strukt.h"

void SHOW_ITEM (Item &item);

Item DATA();



#endif
#include

#include

#include

#include "we_wy.h"

Item DATA()

{char bufor[S+2]; bufor[0]=S;

Item item;

cprintf("\r\nnumer: "); cgets(bufor); item.number=atoi(bufor+2);

cprintf("\r\nnazwisko: "); strcpy(item.name,cgets(bufor));



return item;}
void SHOW_ITEM(Item &item)

{cprintf("\r\nNumer: %d\r\n", item.number);

cprintf("Nazwisko: %s\r\n", item.name);

cprintf("Nacisnij dowolny klawisz...\r\n"); getch();}


#ifndef STRUKT

#define STRUKT

const int S=10;

struct Item

{int number;



char name[S];};

#endif

Zofia Kruczkiewicz, Języki programowania 1, Wykład 4




©absta.pl 2016
wyślij wiadomość

    Strona główna