Szoftver technikák ZH, 2006. 11. 19. forrásának megtekintése

{{GlobalTemplate|Infoszak|SzoftverTechnikakZH20061116}}


==1. Jellemezze a Windows üzenetkezelését, melynek során térjen ki a következő fogalmakra is! (15p)==
# eseményvezérelt programok
# üzenetek
# üzenetsor (message queue)
# üzenetkezelő ciklus (message loop)
# ablakkezelő függvény

A Windows alatt futó programok futási menetét különböző események határozzák meg, program ezekre az eseményekre reagál. Ha valamilyen esemény bekövetkezik a rendszerben,az operációs rendszer meghívja a programunkat (illetve annak egy függvényét). Ilyen események például: a felhasználói események, időzítő események, parancs események (WM_command) stb. 

Ennek megfelelően a Windows '''üzenet''' alapú. Amikor egy esemény történik, akkor egy üzenetet generál a Windows, bár maga az applikáció is generálhat üzeneteket. Az applikáció reagálása ezekre az eseményekre &#8211; vagyis az üzenetek kezelése -  határozza meg a program menetét illetve viselkedését. 

A windows az üzeneteket egy '''MSG''' nevű struktúrában tárolja, amely a következőket tartalmazza: 
* a címzett ablak leírója (HWND), 
* az üzenet tárgya/tartalma (UINT típusú szám), 
* az üzenet paraméterei (WORD wParam, LONG lParam), 
* az üzenet keltének időpontja,
* az üzenet keltésekor érvényes kurzor pozíció.

Üzeneteknek a célablakhoz (illetve annak ablakkezelő függvényéhez) való eljuttatásának kétféle módja lehet:

* *Queued*: az üzenet bekerül az üzenetsorba (ez egy FIFO sor, amelyben aszinkron módon kerülnek feldolgozásra az üzenetek) és onnan továbbítódik az üzenetkezelő ciklusnak. Ezt a fajta üzenet kézbesítést üzenet feladásnak (*post* a message) nevezzük. Minden GUI-threadhez tartozik egy üzenetsor.
* *Not-queued*: az üzenetsor kikerülésével közvetlenül az ablakkezelő függvény kapja meg az üzenetet. Ezt a fajta üzenet kézbesítést üzenet küldésnek (*send* a message) nevezzük. (ez szinkron - a küldő addig vár, amíg választ nem kap.)

Minden applikációnak (minden GUI thread-nek) tartalmaznia kell egy '''üzenetkezelő''' *ciklust*, ami kiszedi az üzeneteket az üzenetsorból és azt továbbítja a megfelelő ablakkezelő függvénynek.

Az '''ablakkezelő''' *függvény* CALLBACK típusú (az OS hívja), ez gondoskodik az ablakhoz érkező események kezeléséről. Tehát, ha üzenet érkezik, az üzenetkezelő ciklus meghívja a célablak ablakkezelő függvényét és paraméterként átadja neki az üzenetet. Ennélfogva ezen függvényen keresztül kommunikál a Windows az alkalmazásunkkal. 
	
==2. Winapi: WndProc-ot kellett megírni + rajzolgatni az ablakba + egy modális dialógusablakot megjeleníteni (20p)==

ehhez hasonló példakód: https://wiki.sch.bme.hu/pub/Infoszak/SzoftverTechnikakZH20061116/main.cpp

<pre>
//kirajzol egy téglalapot az aktív területre, valamint egy menüelemre való kattintásnál feljön egy modal dialog
//nem futtatható kód, némely részeit kihagytam az átláthatóság kedvéért, meg zh-n amúgy sem kell minden részlet
//készült Hassan példakódjai alapján

#include <windows.h>

//példány leíró
HINSTANCE hInst;								

// ablakkezelo fuggveny(ek) deklaracioja
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);


int APIENTRY WinMain(HINSTANCE hInstance,
							HINSTANCE hPrevInstance,
							LPSTR	  lpCmdLine,
							int		 nCmdShow)
{

	HWND hWnd;
	MSG msg; 
	char* szAppName = "Hello World";
	hInst = hInstance; 

	// ------------  ablakosztaly regisztralasa -------------
	//itt egy csomó paramétert be kell állítani, de nem ez a lényeg, szerintem nem kell zh-n

	RegisterClassEx(&wcex);

	// --------------- foablak letrehozasa -------------------
	//szintén rengeteg dolgot argumentuma hiányzik a CreateWindownak, mindegy.

	hWnd = CreateWindow(...) 

	if (!hWnd) return FALSE;
	
	// --------------- foablak megjelenitese ------------------
	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);


	// --------------- uzenetkezelo ciklus ------------------
	//ez fontos
	while (GetMessage(&msg, NULL, 0, 0)) 
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return msg.wParam;
}


// foablak ablakkezelo fuggvenye
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	static HDC hdc,hmemdc;
	static HPEN pen,oldpen;
	PAINTSTRUCT ps;
	switch (message) 
	{
	case WM_CREATE:
		{
			hdc = GetDC(hWnd);
			hmemdc = CreateCompatibleDC(hdc);
			pen=(HPEN)GetStockObject(BLACK_PEN);
			oldpen=(HPEN)SelectObject(hmemdc,pen);
			Rectangle( hmemdc, 10, 10, 110, 110);
			ReleaseDC(hWnd,hdc);
			InvalidateRect( hWnd, NULL, 1 );
		}
	case WM_PAINT:
		{
			hdc = BeginPaint( hWnd, &ps );
			Rectangle( hdc, 10, 10, 110, 110);
			EndPaint( hWnd, &ps );
			break;

		}

		case WM_COMMAND:
			switch(LOWORD(wParam)){			
				case IDM_SHOWDEMODIALOG:
				//feltételezzük, hogy létezik ilyen ID-jű menüelem, és rákattintottak
					MessageBox( hWnd, "Modal dialog displayed", "DlgDemo", MB_OK);
				break;
			}
			break;
		case WM_DESTROY:
			SelectObject(hdc,oldpen);
			PostQuitMessage(0);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}
</pre>

==3. Mi az interfész? Mire jó (szöveges magyarázat + programkód).==
	
Az interfész egy entitás olyan absztrakciója, amelyet a külvilág számára elérhetővé tesz. Az interfész különválasztja a külső objektumokkal való kommunikációt a belső működéstől. Így a belső megvalósítás úgy változtatható meg, hogy az érintett külső objektumok változatlanok maradhatnak. Emellett elfedi a implementáció részleteit, és szabályozott hozzáférést biztosít az entitás erőforrásaihoz.

JAVA-ban:
fontos: 
* egy osztálynak csak egy ősosztálya lehet, de akármennyi interfészt implementálhat!
* egy interfészt implementáló osztály vagy definiálja az interfész osszes metódusát, vagy absztrakt.
* egy interfész metódusai definíció szerint (implicite) publikusak

Pl:
<pre>
public interface Predator {
		 boolean chasePrey(Prey p);
		 void eatPrey(Prey p);
}

public class Cat implements Predator {
 
		  public boolean chasePrey(Prey p) {
					// TODO:osztályspecifikus kód
		  }
 
		  public void eatPrey (Prey p) {
					// TODO:osztályspecifikus kód
		  }
}
</pre>

C#, C++:

TODO!

==4, Tervezési minták (17p)==
* Miben és hogyan segítenek a tervezési minták a tervezés során?

A tervezési minta leír egy gyakran előforduló problémát, annak környezetét és a megoldás magját, amit alkalmazva számos gyakorlati eset hatékonyan megoldható.

* Jellemezze a composite tervezési mintát! Mire ad megoldást a compoite tervezési minta?
* Mutassa be konkrétan vagy egy példán keresztül a minta működését! Ezen belül rajzolja fel a minta osztálydiagramját, valamint jellemezze a mintában szereplő osztályokat.
	
==5a, Készítse el a fenti gyógyszertár szakterületi modelljét (használati esetek, osztálydiagram, esetleg tevékenységdiagram)! (10p)==

===Aktorok===
* Gyógyszerész
* '''Beteg''' (elsődleges, mert ő kezdeményezi a szolgáltatást annak ellenére, hogy a gyógyszerész végzi a rendszer kezelését)
* Raktárfeltöltő
* Karbantartó
* Szerelő
* Számlázó rendszer
===Forgatókönyv(ek)===

===Kiegészítések===

===Használati esetek===

===Használati eset diagram===

===UML modellezés===
	
==5b, Jelölje meg az alábbi állításokat azok igazságtartalmának megfelelő ''bool'' típusú értékkel! (5p)==
* A vízesés modell legnagyobb problémája a kockázatkezelés
** true
* A Unified Process életciklusmodellje iteratív, de nem inkrementális
** false
* Az XP módszertan nem írja elő kötelezően a modellezés
** true
* A kétrétegű információs rendszer architektúra elavult
** false
* Az MVC architektúra az adatokat párhuzamosan megjelenítő nézetek architektúrájára ad egy kizárólagos megoldást
** false

(A kijavított ZH-m alapján -- [[KarakoMiklos|palacsint]] - 2006. 12. 07.)

==Adja meg röviden, hogy mi a következő osztályok szerepe az MFC-ben! (16p)==
* [[CObject]]
* CWinApp
* CCmdTarget
	  
----
Osztályzás:
* 0-50p 1
* 51-60p 2
* 61-70p 3
* 71-84p 4
* 85- 5

-- [[KarakoMiklos|palacsint]] - 2006.11.19.
* {{InLineFileLink|Infoszak|SzoftverTechnikakZH20061116|main.cpp|main.cpp}}: A 2.feladathoz hasonló, működő kód


[[Category:Infoszak]]