180

16. Mellékletek

Calc osztály deklarációja (Calc.h)

/****************************************************************** * Calc osztálydeklarációja * * Demonstrációs célok: * * -> egységbezárás: class * * -> adattagok * * -> konstruktor * * -> tagfüggvények * * -> láthatóságok * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #pragma once //előfordító direktíva (nem szabványos!) //================================================================= class Calc { //================================================================= private: //kívülről nem elérhető int a, b; //adattagok public: //kívülről is elérhető Calc(int a, int b); //paraméteres konstruktor int Ossz(); //Ossz függvény deklaráció int Kiv(); //Kiv függvény deklaráció int Szor(); //Szor függvény deklaráció int Oszt(); //Oszt függvény deklaráció void Kiir(); //Kiir függvény deklaráció };

Calc osztály implementálása (Calc.cpp)

/****************************************************************** * Calc osztály definiálása/implementálása * * Demonstrácios célok: * * -> this referenciamutató * * -> adattagok inicializálása * * -> :: hatókör operátor * * -> tagfüggvények feladatainak kifejtése * * -> std névtér * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include "Calc.h" //a Calc osztály deklarációi //----------------------------------------------------------------- Calc :: Calc (int x, int y) //----------------------------------------------------------------- { this->a = x; this->b = y; } //----------------------------------------------------------------- int Calc :: Ossz()

181

//----------------------------------------------------------------- { return a+b; } //----------------------------------------------------------------- int Calc :: Kiv() //----------------------------------------------------------------- { return a-b; } //----------------------------------------------------------------- int Calc :: Szor() //----------------------------------------------------------------- { return a*b; } //----------------------------------------------------------------- int Calc :: Oszt() //----------------------------------------------------------------- { return a/b; } //----------------------------------------------------------------- void Calc :: Kiir() //----------------------------------------------------------------- { std::cout << a << " + " << b << " = " << Ossz() << std::endl; std::cout << a << " - " << b << " = " << Kiv() << std::endl; std::cout << a << " * " << b << " = " << Szor() << std::endl; std::cout << a << " / " << b << " = " << Oszt() << std::endl; std::cout << "\nPress any key to exit..."; }

Calc osztály példányosítása (main.cpp)

/****************************************************************** * Calc osztály példányosítása * * Demonstrációs célok: * * -> statikus objektumpéldány * * -> osztály tagfüggvényeinek a hívása * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <conio.h> //DOS konzol I/O rutinok hívása #include "Calc.h" //a Calc osztály deklarációi //***************************************************************** int main() //***************************************************************** { Calc obj(20,10);//objektumpéldány létrehozása obj.Kiir(); //az osztály Kiir() tagfüggvényének hívása

182

getch(); //egy karakter megadását várja return 0; //visszatérési érték az operációs rendszer felé }

Szoveg osztály deklarációja (Szoveg.h)

/****************************************************************** * Szoveg osztálydeklarációja * * Demonstrácios célok: * * -> egységbe zárás: class * * -> adattagok * * -> konstruktor * * -> tagfüggvények * * -> láthatóságok * * -> char tömb * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef SZOVEG_H //if not define egy szimbólum nemlétét ellenőrzi #define SZOVEG_H //egy szimbólum definiálása és értékének megadása //================================================================= class Szoveg { //================================================================= private: //kívülről nem elérhető char szov[]; //osztály adattagja public: //kívülről is elérhető Szoveg(char[]); //paraméteres konstruktor int MaganhangzokSzama(); //tagfüggvény deklaráció int MassalhangzokSzama(); //tagfüggvény deklaráció int SzokozokSzama(); //tagfüggvény deklaráció void SzokozCsere(); //tagfüggvény deklaráció void Kiir(); //tagfüggvény deklaráció }; #endif //feltétel lezárása

Szoveg osztály implementálása (Szoveg.cpp)

/************************************************************************************ * Szoveg osztály definiálása/implementálása * * Demonstrácios célok: * * -> this referenciamutató * * -> adattagok inicializálása * * -> :: hatókör operátor * * -> tagfüggvények feladatainak kifejtése * * -> std névtér * * -> strlen függvény bemutatása * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include "Szoveg.h" //a Szoveg osztály deklarációi //------------------------------------------------------------------------------------ Szoveg :: Szoveg(char x[]) //------------------------------------------------------------------------------------ { for (int i = 0; i < strlen(x); i++) //strlen->return szoveg hossz

183

this->szov[i] = x[i]; //adattag inicializálás } //------------------------------------------------------------------------------------ int Szoveg :: MaganhangzokSzama() //------------------------------------------------------------------------------------ { int maganDb = 0; char magan[5] = {'a','e','i','o','u'}; for (int i = 0; i < strlen(szov); i++) { for (int j = 0; j < strlen(magan); j++) if(szov[i] == magan[j]) maganDb++; } return maganDb; } //------------------------------------------------------------------------------------ int Szoveg::MassalhangzokSzama() //------------------------------------------------------------------------------------ { int massalDb = 0; char massal[21] = {'b','c','d','f','g','h','j','k','l','m','n', 'p','r','q','s','t','v','w','x','y','z'}; for (int i = 0; i < strlen(szov); i++) { for (int j = 0; j < strlen(massal); j++) if(szov[i] == massal[j]) massalDb++; } return massalDb; } //------------------------------------------------------------------------------------ int Szoveg::SzokozokSzama() //------------------------------------------------------------------------------------ { int szokozDb = 0; for (int i = 0; i < strlen(szov); i++) if(szov[i] == ' ') szokozDb++; return szokozDb; } //------------------------------------------------------------------------------------ void Szoveg::SzokozCsere() //------------------------------------------------------------------------------------ { for (int i = 0; i < strlen(szov); i++) if(szov[i] == ' ') szov[i] = '#'; } //------------------------------------------------------------------------------------- void Szoveg::Kiir() //------------------------------------------------------------------------------------- {

184

std::cout << "AZ EREDETI SZOVEG" << std::endl; std::cout << "=================" << std::endl; std::cout << szov << std::endl << std::endl; std::cout << "ADATOK" << std::endl; std::cout << "=================" << std::endl; std::cout << "maganhangzok szama : " << MaganhangzokSzama() << "db" << std::endl; std::cout << "massalhangzok szama : " << MassalhangzokSzama() << "db" << std::endl; std::cout << "szokozok szama : " << SzokozokSzama() << "db" << std::endl; std::cout << std::endl; std::cout << "SZOKOZOK CSEREJE" << std::endl; std::cout << "=================" << std::endl; SzokozCsere(); std::cout << szov << std::endl; }

Szoveg osztály példányosítása (main.cpp)

/***************************************************************************** * Szoveg osztály példányosítása * * Demonstrácios célok: * * -> statikus objektumpéldány * * -> osztály tagfüggvényeinek a hívása * * * * Katona József <katona.jozsef.duf@freemail.hu> * ******************************************************************************/ #include <conio.h> //DOS konzol I/O rutinok hívása #include "Szoveg.h" //a Szoveg osztály deklarációi //**************************************************************************** int main() //**************************************************************************** { //objektumpéldány létrehozása Szoveg obj("lorem ipsum dolor sit amet, consectetur adipisicing elit..."); obj.Kiir(); //az osztály Kiir() tagfüggvényének hívása getch(); //egy karakter megadását várja return 0; //visszatérési érték az operációs rendszer felé }

Muvelet osztály deklarációja (Muvelet.h)

/****************************************************************** * Muvelet osztály deklarációja * * Demonstrációs célok: * * -> alapértelmezett konstruktor * * -> paraméteres konstruktor * * -> másoló konstruktor * * -> objketum paraméter * * -> inline módszer * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef MUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define MUVELET_H //egy szimbólum definiálása és értékének megadása //================================================================= class Muvelet { //=================================================================

185

private: double x, y, eredmeny; char muv; public: //alapértelmezett konstruktor (inline módszer) Muvelet() {x=1; y=1; muv='+';} //paraméteres konstruktor Muvelet(double x1, double y1, char muv1); //másoló konstruktor Muvelet(const Muvelet &v); void Szamol(); void Kiir(); }; #endif //feltétel lezárása

Muvelet osztály implementálása (Muvelet.cpp)

/****************************************************************** * Muvelet osztály definiálása/implementálása * * Demonstrációs célok: * * -> alapértelmezett konstruktor * * -> paraméteres konstruktor * * -> másoló konstruktor * * -> objketum paraméter * * -> inline módszer * * -> std névtér * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include "Muvelet.h" //a Muvelet osztály deklarációi using namespace std; //az std névtér behívása //----------------------------------------------------------------- Muvelet :: Muvelet(double x1, double y1, char muv1) //----------------------------------------------------------------- { this->x=x1; this->y=y1; this->muv=muv1; } //----------------------------------------------------------------- Muvelet :: Muvelet(const Muvelet &v) //----------------------------------------------------------------- { this->x=v.x; this->y=v.y; this->muv=v.muv; } //----------------------------------------------------------------- void Muvelet :: Szamol() //----------------------------------------------------------------- { switch(muv) { case '+': eredmeny = x+y; break; case '-': eredmeny = x-y; break; case '*': eredmeny = x*y; break;

186

case '/': eredmeny = x/y; break; } } //----------------------------------------------------------------- void Muvelet :: Kiir() //----------------------------------------------------------------- { cout << x << " " << muv << " " << y << " = " << eredmeny << endl; }

Muvelet osztály példányosítása (main.cpp)

/****************************************************************** * Muvelet osztály példányosítása * * Demonstrációs célok: * * -> különböző típusú konstruktorok hívások * * -> strchr() * * -> cin függvény * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <cstring> //C++ verziója, C "string.h"-nak #include <conio.h> //DOS konzol I/O rutinok hívása #include "Muvelet.h" //a Muvelet osztály deklarációi using namespace std; //az std névtér behívása //***************************************************************** int main() //***************************************************************** { double a1, b1; char m; Muvelet w1; //alapértelmezett konstruktor hívása w1.Szamol(); w1.Kiir(); cout << "1.adat: "; cin >> a1; cout << "2.adat: "; cin >> b1; do { cout << "muveleti jel (+,-,*,/): "; cin >> m; } while(!strchr("+-*/",m)); Muvelet w2(a1, b1, m); //a paraméteres konstruktor hívása w2.Szamol(); w2.Kiir(); Muvelet w3(w2); //a másoló konstruktor hívása w3.Szamol(); w3.Kiir(); getch(); return 0; }

187

CReactangle osztály deklarációja (CRectangle.h)

/****************************************************************** * CRectangle osztály deklarációja * * Demonstrációs célok: * * -> adattag mutatók * * -> dinamikus memória kezelés OOP-ben * * -> destruktor * * -> inline módszer * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef CRECTANGLE_H //if not define egy szimbólum nemlétét ellenőrzi #define CRECTANGLE_H //egy szimbólum definiálása és értékének megadása //================================================================= #include <iostream> //C++ alapvető adatfolyam I/O rutinok using namespace std; //az std névtér behívása //================================================================= class CRectangle { //================================================================= private: double *a, *b; public: CRectangle(double magassag, double szelesseg) { this->a = new double(magassag); //dinamikus helyfoglalás this->b = new double(szelesseg); //az adattag-mutatók számára } double Kerulet() { return 2*(*a+*b); } double Terulet() { return *a**b; } void Kiir() { cout << "A TEGLALAP ADATAI: " << endl; cout << "================== " << endl; cout << "a oldal = " << *a << " cm" << endl; cout << "b oldal = " << *b << " cm" << endl; printf("Kerulet: %.2lf cm^2", this->Kerulet()); cout << endl; printf("Terulet: %.2lf cm^2", this->Terulet()); } ~CRectangle() { delete a; //adattagmutató törlése a memóriából delete b; //adattagmutató törlése a memóriából

188

} }; #endif //feltétel lezárása

CReactangle osztály példányosítása (main.cpp)

/****************************************************************** * CRectangle osztály példányosítása * * Demonstrációs célok: * * -> dinamikus helyfoglalású objketumpéldány * * -> "->" operátor * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <conio.h> //DOS konzol I/O rutinok hívása #include "CRectangle.h" //a CRectangle osztály deklarációi //***************************************************************** int main() //***************************************************************** { //dinamikus helyfoglalású objektumpéldány CRectangle *Tegla = new CRectangle(10.2, 21.5); Tegla->Kerulet(); Tegla->Terulet(); Tegla->Kiir(); //objektumpéldány meszüntetése delete Tegla; getch(); return 0; }

Csere osztály deklarációja (Csere.h)

/****************************************************************** * Csere osztály deklarációja * * Demonstrációs célok: * * -> memóriacím szerinti paraméterátadadás * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef CSERE_H //if not define egy szimbólum nemlétét ellenőrzi #define CSERE_H //egy szimbólum definiálása és értékének megadása //================================================================= class Csere { //================================================================= public: Csere(void); //függvény értékátadás cím szerint void adatcsere1(int& v1, int& v2); void adatcsere2(float& v1, float& v2); void adatcsere3(char& v1, char& v2); ~Csere(void); }; #endif //feltétel lezárása

189

Csere osztály implementálása (Csere.cpp)

/****************************************************************** * Csere osztály definiálása/implementálása * * Demonstrációs célok: * * -> különböző típusú adatok cseréje * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include "Csere.h" //a Csere osztály deklarációi //----------------------------------------------------------------- Csere::Csere(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- void Csere::adatcsere1(int& v1, int& v2) //----------------------------------------------------------------- { int temp; temp = v1; v1 = v2; v2 = temp; } //----------------------------------------------------------------- void Csere::adatcsere2(float& v1, float& v2) //----------------------------------------------------------------- { float temp; temp = v1; v1 = v2; v2 = temp; } //----------------------------------------------------------------- void Csere::adatcsere3(char& v1, char& v2) //----------------------------------------------------------------- { char temp; temp = v1; v1 = v2; v2 = temp; } //----------------------------------------------------------------- Csere::~Csere(void) {} //-----------------------------------------------------------------

Csere osztály példányosítása (main.cpp)

/****************************************************************** * Csere osztály példányosítása * * Demonstrációs célok: * * -> Csere osztály példányosítása *

190

* * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <conio.h> //DOS konzol I/O rutinok hívása #include "Csere.h" //a Csere osztály deklarációi using namespace std; //az std névtér behívása //***************************************************************** int main() //***************************************************************** { int i1=10, i2=-4; float f1=1.5, f2=2.8; char c1='*', c2='#'; Csere *csObj = new Csere(); cout << "csere elott i1 : " << i1 << " i2 : " << i2 << endl; csObj->adatcsere1(i1, i2); cout << "csere utan i1 : " << i1 << " i2 : " << i2 << endl; cout << "csere elott f1 : " << f1 << " f2 : " << f2 << endl; csObj->adatcsere2(f1, f2); cout << "csere utan f1 : " << f1 << " f2 : " << f2 << endl; cout << "csere elott c1 : " << c1 << " c2 : " << c2 << endl; csObj->adatcsere3(c1, c2); cout << "csere utan c1 : " << c1 << " c2 : " << c2 << endl; delete csObj; getch(); return 0; }

OverloadingExample osztály deklarációja (OverloadingExample.h)

/***************************************************************************** * OverloadingExample osztály deklarációja * * Demonstrációs célok: * * -> függvények túlterhelése/felüldefiniálása * * * * Katona József <katona.jozsef.duf@freemail.hu> * ******************************************************************************/ #ifndef OVERLOADINGEXAMPLE_H //if not define egy szimbólum nemlétét ellenőrzi #define OVERLOADINGEXAMPLE_H //egy szimbólum definiálása és értékének megadása //============================================================================ class OverloadingExample { //============================================================================ public: OverloadingExample(void); void adatcsere(int& v1, int& v2); void adatcsere(float& v1, float& v2); void adatcsere(char& v1, char& v2); ~OverloadingExample(void); }; #endif //feltétel lezárása

OverloadingExample osztály implementálása (OverloadingExample.cpp)

191

/****************************************************************** * OverloadingExample osztály definiálása/implementálása * * Demonstrációs célok: * * -> túlterhelet függvények kifejtése * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include "OverloadingExample.h" // az OverloadingExample osztály // deklarációi //----------------------------------------------------------------- OverloadingExample::OverloadingExample(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- void OverloadingExample::adatcsere(int& v1, int& v2) //----------------------------------------------------------------- { int temp; temp = v1; v1 = v2; v2 = temp; } //----------------------------------------------------------------- void OverloadingExample::adatcsere(float& v1, float& v2) //----------------------------------------------------------------- { float temp; temp = v1; v1 = v2; v2 = temp; } //----------------------------------------------------------------- void OverloadingExample::adatcsere(char& v1, char& v2) //----------------------------------------------------------------- { char temp; temp = v1; v1 = v2; v2 = temp; } //----------------------------------------------------------------- OverloadingExample::~OverloadingExample(void) {} //-----------------------------------------------------------------

OverloadingExample osztály példányosítása (main.cpp)

/************************************************************************** * OverloadingExample osztály példányosítása * * Demonstrációs célok: * * -> túlterhelt függvények hívásai * * * * Katona József <katona.jozsef.duf@freemail.hu> * ***************************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok

192

#include <conio.h> //DOS konzol I/O rutinok hívása #include "OverloadingExample.h" //az OverloadingExample osztály deklarációi using namespace std; //az std névtér behívása //************************************************************************* int main() //************************************************************************* { int i1 = 10, i2 = -4; float f1 = 1.5, f2 = 2.8; char c1 = '*', c2 = '#'; OverloadingExample *overObj = new OverloadingExample(); cout << "csere elott i1 : " << i1 << " i2 : " << i2 << endl; overObj->adatcsere(i1, i2); cout << "csere utan i1 : " << i1 << " i2 : " << i2 << endl; cout << "csere elott f1 : " << f1 << " f2 : " << f2 << endl; overObj->adatcsere(f1, f2); cout << "csere utan f1 : " << f1 << " f2 : " << f2 << endl; cout << "csere elott c1 : " << c1 << " c2 : " << c2 << endl; overObj->adatcsere(c1, c2); cout << "csere utan c1 : " << c1 << " c2 : " << c2 << endl; delete overObj; getch(); return 0; }

TemplateCsere osztály példányosítása (TemplateCsere.h)

/*********************************************************************** * TemplateCsere osztály deklarációja * * Demonstrációs célok: * * -> függvénysablonok * * -> template kulcsszó * * * * Katona József <katona.jozsef.duf@freemail.hu> * ************************************************************************/ #ifndef TEMPLATECSERE_H //if not define egy szimbólum nemlétét ellenőrzi #define TEMPLATECSERE_H //egy szimbólum definiálása és értékének megadása //======================================================================= template <class T> class TemplateCsere { //======================================================================= public: TemplateCsere(void); void adatcsere(T& v1, T& v2); ~TemplateCsere(void); }; #endif //feltétel lezárása

TemplateCsere osztály implementálása (TemplateCsere.cpp)

/****************************************************************** * TemplateCsere osztály definiálása/implementálása * * Demonstrációs célok: * * -> függvénysablonok kifejtése *

193

* * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include "TemplateCsere.h" //a TemplateCsere osztály deklaráció //----------------------------------------------------------------- template <class T> TemplateCsere<T> :: TemplateCsere(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- template <class T> void TemplateCsere<T> :: adatcsere(T& v1, T& v2) //----------------------------------------------------------------- { T t; t = v1; v1 = v2; v2 = t; } //----------------------------------------------------------------- template <class T> TemplateCsere<T> :: ~TemplateCsere(void) {} //-----------------------------------------------------------------

TemplateCsere osztály példányosítása (main.cpp)

/****************************************************************** * TemplateCsere osztály példányosítása * * Demonstrációs célok: * * -> függvénysablonok hívása különböző típusokkal * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <conio.h> //DOS konzol I/O rutinok hívása #include "TemplateCsere.cpp" //a TemplateCsere osztály deklarációi using namespace std; //az std névtér behívása //***************************************************************** int main() //***************************************************************** { int i1 = 10, i2 = -4; float f1 = 1.5, f2 = 2.8; char c1 = '*', c2 = '#'; TemplateCsere<int> *p1 = new TemplateCsere<int>(); cout << "csere elott i1 : " << i1 << " i2 : " << i2 << endl; p1->adatcsere(i1, i2); //függvénysablon hívása integer típussal cout << "csere utan i1 : " << i1 << " i2 : " << i2 << endl; delete p1; TemplateCsere<float> *p2 = new TemplateCsere<float>(); cout << "csere elott f1 : " << f1 << " f2 : " << f2 << endl; p2->adatcsere(f1, f2); //függvénysablon hívása float típussal cout << "csere utan f1 : " << f1 << " f2 : " << f2 << endl; delete p2;

194

TemplateCsere<char> *p3 = new TemplateCsere<char>(); cout << "csere elott c1 : " << c1 << " c2 : " << c2 << endl; p3->adatcsere(c1, c2); //függvénysablon hívása char típussal cout << "csere utan c1 : " << c1 << " c2 : " << c2 << endl; delete p3; getch(); return 0; }

TempClass osztály deklarációja (TempClass.h)

/******************************************************************** * TempClass osztály deklarációja * * Demonstrációs célok: * * -> osztálysablon deklaráció * * * * Katona József <katona.jozsef.duf@freemail.hu> * *********************************************************************/ #ifndef TEMPCLASS_H //if not define egy szimbólum nemlétét ellenőrzi #define TEMPCLASS_H //egy szimbólum definiálása és értékének megadása //=================================================================== template <class T> class TempClass { //=================================================================== T a, b; //alapértelmezett láthatóságú T //T típusú adattag public: TempClass(T first, T second); T getmax(); ~TempClass(void); }; #endif //feltétel lezárása

TempClass osztály implementálása (TempClass.cpp)

/****************************************************************** * TempClass osztály definiálása/implementálása * * Demonstrációs célok: * * -> osztálysablon függvényeinek kifejtése * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include "TempClass.h" //a TempClass osztály deklarációi //----------------------------------------------------------------- template <class T> TempClass<T> :: TempClass(T first, T second) //----------------------------------------------------------------- { this->a = first; this->b = second; } //----------------------------------------------------------------- template <class T> T TempClass<T> :: getmax() //----------------------------------------------------------------- { T c; c = a > b ? a : b; //ternális kifejezés

195

//<feltétel> ? true : false return c; } //----------------------------------------------------------------- template <class T> TempClass<T> :: ~TempClass(void) {} //-----------------------------------------------------------------

TempClass osztály példányosítása (main.cpp)

/****************************************************************** * TempClass osztály példányosítása * * Demonstrációs célok: * * -> osztálysablon példányosítása * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include "TempClass.cpp" //a TempClass osztály deklarációi using namespace std; //az std névtér behívása //***************************************************************** int main () //***************************************************************** { TempClass <float> obj(100.23, 75.34); //osztálysablon példánya cout << obj.getmax(); cin.get(); return 0; }

MuvBarat osztály deklarációja (MuvBarat.h)

/****************************************************************** * MuvBarat osztály deklarációja * * Demonstrációs célok: * * -> friend (barát) függvények * * -> konstans referencia * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef MUVBARAT_H //if not define egy szimbólum nemlétét ellenőrzi #define MUVBARAT_H //egy szimbólum definiálása és értékének megadása //================================================================= class MuvBarat { //================================================================= private: double x, y, eredmeny; char muv; public: MuvBarat::MuvBarat(void); void Init(double x1, double y1, char muv1); void Szamol(); double GetEredmeny() { return eredmeny; } void Kiir(); //barát függvény deklarálása

196

friend double Hatvanyoz(const MuvBarat& v); MuvBarat::~MuvBarat(void); }; #endif //feltétel lezárása

MuvBarat osztály implementálása (MuvBarat.cpp)

/****************************************************************** * MuvBarat osztály definiálása/implementálása * * Demonstrációs célok: * * -> friend (barát) függvények kifejtése * * -> objektum paraméter * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <cmath> //általános matematikai műveletek #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include "MuvBarat.h" //a MuvBarat osztály deklarációi using namespace std; //az std névtér behívása //----------------------------------------------------------------- MuvBarat :: MuvBarat(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- void MuvBarat :: Init(double x1, double y1, char muv1) //----------------------------------------------------------------- { x = x1; y = y1; muv = muv1; } //----------------------------------------------------------------- void MuvBarat :: Szamol() //----------------------------------------------------------------- { switch(muv) { case '+' : eredmeny = x + y; break; case '-' : eredmeny = x - y; break; case '*' : eredmeny = x * y; break; case '/' : eredmeny = x / y; break; } } //----------------------------------------------------------------- void MuvBarat :: Kiir() //----------------------------------------------------------------- { cout << x << " " << muv << " " << y << " = " << eredmeny << endl; } //----------------------------------------------------------------- double Hatvanyoz(const MuvBarat& v) //friend függvény //----------------------------------------------------------------- { return pow(v.x, v.y);

197

} //----------------------------------------------------------------- MuvBarat :: ~MuvBarat(void) {} //-----------------------------------------------------------------

MuvBarat osztály példányosítása (main.cpp)

/****************************************************************** * MuvBarat osztály példányosítása * * Demonstrációs célok: * * -> MuvBarat osztály példányosítása * * -> Friend függvény hívása * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <conio.h> //DOS konzol I/O rutinok hívása #include "MuvBarat.h" //a MuvBarat osztály deklarációi using namespace std; //az std névtér behívása //***************************************************************** int main() //***************************************************************** { double a1 = 2.3, b1 = 4.2; char m = '-'; MuvBarat w; w.Init(a1, b1, m); w.Szamol(); w.Kiir(); cout << "Hatvany: " << Hatvanyoz(w) << endl; //barátfüggvény hívása getch(); return 0; }

CSquare osztály deklarációja (CSquare.h)

/****************************************************************** * CSquare osztály deklarációja * * Demonstrációs célok: * * -> friend mechanizmus (osztályok barátsága) * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef CSQUARE_H //if not define egy szimbólum nemlétét ellenőrzi #define CSQUARE_H //egy szimbólum definiálása és értékének megadása //================================================================= class CSquare { //================================================================= private: int side; public: void set_side (int a) { side = a; } friend class CRectangle; //Az négyzet osztály barátja a

198

//téglalap osztály }; #endif //feltétel lezárása

CRectangle osztály deklarációja (CRectangle.h)

#ifndef CRECTANGLE_H //if not define egy szimbólum nemlétét ellenőrzi #define CRECTANGLE_H //egy szimbólum definiálása és értékének megadása //================================================================= class CRectangle { //================================================================= private: int width, height; public: int area() {return (width * height);} void convert (CSquare a); /*{ width = a.side; //elérhető a négyzet osztály private height = a.side; //adattagja is }*/ }; #endif //feltétel lezárása

CRectangle osztály implementálása (CRectangle.cpp)

/****************************************************************** * CRectangle osztály definiálása/implementálása * * Demonstrációs célok: * * -> friend mechanizmusa * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include "Square.h" //a Square osztály deklarációi //----------------------------------------------------------------- void CRectangle :: convert(CSquare a) //----------------------------------------------------------------- { width = a.side; //elérhető a négyzet osztály private height = a.side; //adattagja is }

CSquare osztály példányosítása (main.cpp)

/****************************************************************** * CSquare osztály példányosítása * * Demonstrációs célok: * * -> friend mechanizmus * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <conio.h> //DOS konzol I/O rutinok hívása #include "Square.h" //a Square osztály deklarációi using namespace std; //az std névtér behívása

199

//***************************************************************** int main () //***************************************************************** { CSquare sqr; CRectangle rect; sqr.set_side(4); rect.convert(sqr); cout << rect.area(); getch(); return 0; }

Muvelet osztály deklarációja (Muvelet.h)

/****************************************************************** * Muvelet osztály deklarációja * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef MUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define MUVELET_H //egy szimbólum definiálása és értékének megadása //================================================================= class Muvelet { //================================================================= protected: //öröklés esetén szerencsésebb a protected elérés használata double x, y, eredmeny; char muv; public: Muvelet(double x1, double y1, char muv1); ~Muvelet(void); void Szamol(); double GetEredmeny() {return eredmeny;} void Kiir(); }; #endif //feltétel lezárása

UjMuvelet osztály deklarációja (UjMuvelet.h)

/****************************************************************** * UjMuvelet osztály deklarációja * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef UJMUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define UJMUVELET_H //egy szimbólum definiálása és értékének megadása

200

#include "Muvelet.h"//A Muvelet osztály deklarációi //================================================================= class UjMuvelet : public Muvelet { //leszármaztatás //================================================================= public: UjMuvelet(double x1, double x2, char muv1); ~UjMuvelet(void); void Szamol(); }; #endif //feltétel lezárása

Muvelet osztály implementálása (Muvelet.cpp)

/****************************************************************** * Muvelet osztály definiálása/implementálása * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include "Muvelet.h" //a Muvelet osztály deklarációi using namespace std; //az std névtér behívása //----------------------------------------------------------------- Muvelet::Muvelet(double x1, double y1, char muv1) //----------------------------------------------------------------- { x = x1; y = y1; muv = muv1; eredmeny = 0; } //----------------------------------------------------------------- Muvelet::~Muvelet(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- void Muvelet::Szamol() //----------------------------------------------------------------- { switch(muv) { case '+' : eredmeny = x + y; break; case '-' : eredmeny = x - y; break; case '*' : eredmeny = x * y; break; case '/' : eredmeny = x / y; break; } } //----------------------------------------------------------------- void Muvelet::Kiir() //----------------------------------------------------------------- { cout << x << " " << muv << " " << y << " = " << eredmeny << endl;

201

}

UjMuvelet osztály implementálása (UjMuvelet.cpp)

/****************************************************************** * UjMuvelet osztály definiálása/implementálása * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <cmath> //matematikai függvények #include "UjMuvelet.h" //az UjMuvelet osztály deklarációi //----------------------------------------------------------------- UjMuvelet::UjMuvelet(double x1, double y1, char muv1): Muvelet(x1,y1,muv1) //----------------------------------------------------------------- // paraméterek átadva a Muvelet konstruktorának {} //üres a törzse, muvel nincs saját inicializálható adattagja //----------------------------------------------------------------- UjMuvelet::~UjMuvelet(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- void UjMuvelet::Szamol() //----------------------------------------------------------------- { if (muv == '^') eredmeny = pow(x,y); //ez a bővített művelet //a pow() igényli a cmatch fejlécállományt else Muvelet::Szamol(); }

UjMuvelet osztály példányosítása (main.cpp)

/****************************************************************** * UjMuvelet osztály példányosítása * * Demonstrációs célok: * * -> kiterjesztett osztály példányosítása * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <cstring> //C++ verziója, C "string.h"-nak #include <conio.h> //DOS konzol I/O rutinok hívása #include "UjMuvelet.h" //az UjMuvelet osztály deklarációi using namespace std; //az std névtér behívása //***************************************************************** int main() //***************************************************************** {

202

double a1, b1; char m; cout << "1. adat: "; cin >> a1; cout << "2. adat: "; cin >> b1; do { cout << "muveleti jel (+,-,*,/,^): "; cin >> m; } while(!strchr("+-*/^",m)); UjMuvelet w1(a1,b1,m); w1.Szamol(); w1.Kiir(); getch(); return 0; }

Muvelet osztály deklarációja (Muvelet.h)

/****************************************************************** * Muvelet osztály deklarációja * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> koria kötés problémája * * -> inline tagfüggvény * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef MUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define MUVELET_H //egy szimbólum definiálása és értékének megadása //================================================================= class Muvelet { //================================================================= protected: double x, y, eredmeny; char muv; public: Muvelet(double x1, double y1, char muv1); ~Muvelet(void); void Szamol(); double GetEredmeny() {return eredmeny;} void Kiir(); void Vegrehajt() { Szamol(); } //új inline tagfüggvény }; #endif //feltétel lezárása

UjMuvelet osztály deklarációja (UjMuvelet.h)

/****************************************************************** * UjMuvelet osztály deklarációja * * Demonstrációs célok: * * -> öröklődés mechanizmusa *

203

* -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> koria kötés problémája * * -> inline tagfüggvény * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef UJMUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define UJMUVELET_H //egy szimbólum definiálása és értékének megadása #include "Muvelet.h"//A Muvelet osztály deklarációi //================================================================= class UjMuvelet : public Muvelet { //================================================================= public: UjMuvelet(double x1, double x2, char muv1); ~UjMuvelet(void); void Szamol(); }; #endif //feltétel lezárása

Muvelet osztály implementálása (Muvelet.cpp)

/****************************************************************** * Muvelet osztály implementálása * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> koria kötés problémája * * -> inline tagfüggvény * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include "Muvelet.h" //a Muvelet osztály deklarációi using namespace std; //az std névtér behívása //----------------------------------------------------------------- Muvelet::Muvelet(double x1, double y1, char muv1) //----------------------------------------------------------------- { x = x1; y = y1; muv = muv1; eredmeny = 0; } //----------------------------------------------------------------- Muvelet::~Muvelet(void) //----------------------------------------------------------------- { } //----------------------------------------------------------------- void Muvelet::Szamol() //-----------------------------------------------------------------

204

{ switch(muv) { case '+' : eredmeny = x + y; break; case '-' : eredmeny = x - y; break; case '*' : eredmeny = x * y; break; case '/' : eredmeny = x / y; break; default: eredmeny = 0; cerr << "Ervenytelen muveleti jel: " << muv << endl; } } //----------------------------------------------------------------- void Muvelet::Kiir() //----------------------------------------------------------------- { cout << x << " " << muv << " " << y << " = " << eredmeny << endl; }

UjMuvelet osztály implementálása (UjMuvelet.cpp)

/****************************************************************** * UjMuvelet osztály implementációja * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> koria kötés problémája * * -> inline tagfüggvény * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <cmath> //általános matematikai műveletek #include "UjMuvelet.h" //az UjMuvelet osztály deklarációi //----------------------------------------------------------------- UjMuvelet::UjMuvelet(double x1, double y1, char muv1): Muvelet(x1,y1,muv1) {} //----------------------------------------------------------------- //----------------------------------------------------------------- UjMuvelet::~UjMuvelet(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- void UjMuvelet::Szamol() //----------------------------------------------------------------- { if (muv == '^') eredmeny = pow(x,y); else Muvelet::Szamol(); }

UjMuvelet osztály példányosítása (main.cpp)

/******************************************************************

205

* UjMuvelet osztály példányosítása * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> koria kötés problémája * * -> inline tagfüggvény * * * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <cstring> //C++ verziója, C "string.h"-nak #include <conio.h> //DOS konzol I/O rutinok hívása #include "UjMuvelet.h" //az UjMuvelet osztály deklarációi using namespace std; //az std névtér behívása //***************************************************************** int main() //***************************************************************** { double a1, b1; char m; cout << "1. adat: "; cin >> a1; cout << "2. adat: "; cin >> b1; do { cout << "muveleti jel (+,-,*,/,^): "; cin >> m; }while(!strchr("+-*/^",m)); UjMuvelet w1(a1,b1,m); // w1 UjMuvelet objektumpéldánya w1.Vegrehajt(); // aktiválja a Vegrehajt() tagfüggvényt w1.Kiir(); getch(); return 0; }

Muvelet osztály deklarációja (Muvelet.h)

/****************************************************************** * Muvelet osztály deklarációja * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> késői kötés * * -> virutális tagfüggvények * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef MUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define MUVELET_H //egy szimbólum definiálása és értékének megadása

206

//================================================================= class Muvelet { //================================================================= protected: double x, y, eredmeny; char muv; public: Muvelet(double x1, double y1, char muv1); ~Muvelet(void); virtual void Szamol(); // virtuális a Szamol() tagfüggvény double GetEredmeny() { return eredmeny; } void Kiir(); void Vegrehajt() { Szamol(); } }; #endif //feltétel lezárása

UjMuvelet osztály deklarációja (UjMuvelet.h)

/****************************************************************** * UjMuvelet osztály deklarációja * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> késői kötés * * -> virutális tagfüggvények * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef UJMUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define UJMUVELET_H //egy szimbólum definiálása és értékének megadása #include "Muvelet.h" //================================================================= class UjMuvelet : public Muvelet { //================================================================= public: UjMuvelet(double x1, double x2, char muv1); ~UjMuvelet(void); void Szamol(); }; #endif //feltétel lezárása

Muvelet osztály implementálása (Muvelet.cpp)

/****************************************************************** * Muvelet osztály implementálása * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> késői kötés * * -> virutális tagfüggvények * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/

207

#include <iostream> //C++ alapvető adatfolyam I/O rutinok #include "Muvelet.h" //a Muvelet osztály deklarációi using namespace std; //az std névtér behívása //----------------------------------------------------------------- Muvelet::Muvelet(double x1, double y1, char muv1) //----------------------------------------------------------------- { x = x1; y = y1; muv = muv1; eredmeny = 0; } //----------------------------------------------------------------- Muvelet::~Muvelet(void){} //----------------------------------------------------------------- //----------------------------------------------------------------- void Muvelet::Szamol() //----------------------------------------------------------------- { switch(muv) { case '+' : eredmeny = x + y; break; case '-' : eredmeny = x - y; break; case '*' : eredmeny = x * y; break; case '/' : eredmeny = x / y; break; default: eredmeny = 0; cerr << "Ervenytelen muveleti jel: " << muv << endl; } } //----------------------------------------------------------------- void Muvelet::Kiir() //----------------------------------------------------------------- { cout << x << " " << muv << " " << y << " = " << eredmeny << endl; }

UjMuvelet osztály implementálása (UjMuvelet.cpp)

/****************************************************************** * UjMuvelet osztály implementálása * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> késői kötés * * -> virutális tagfüggvények * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <cmath> //alapvető matematikai műveletek #include "UjMuvelet.h" //az UjMuvelet osztály deklarációi //----------------------------------------------------------------- UjMuvelet::UjMuvelet(double x1, double y1, char muv1): Muvelet(x1,y1,muv1) {}

208

//----------------------------------------------------------------- //----------------------------------------------------------------- UjMuvelet::~UjMuvelet(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- void UjMuvelet::Szamol() //----------------------------------------------------------------- { if (muv == '^') eredmeny = pow(x,y); else Muvelet::Szamol(); }

UjMuvelet osztály példányosítása (main.cpp)

/****************************************************************** * UjMuvelet osztály példányosítása * * Demonstrációs célok: * * -> öröklődés mechanizmusa * * -> kód újra felhasználás * * -> ősosztály * * -> osztályok kiterjesztése * * -> késői kötés * * -> virutális tagfüggvények * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> //C++ alapvető adatfolyam I/O rutinok #include <cstring> //C++ verziója, C "string.h"-nak #include <conio.h> //DOS konzol I/O rutinok hívása #include "UjMuvelet.h" //az UjMuvelet osztály deklarációi using namespace std; //az std névtér behívása //***************************************************************** int main() //***************************************************************** { double a1, b1; char m; cout << "1. adat: "; cin >> a1; cout << "2. adat: "; cin >> b1; do { cout << "muveleti jel (+,-,*,/,^): "; cin >> m; }while(!strchr("+-*/^",m)); UjMuvelet w1(a1,b1,m); w1.Vegrehajt(); w1.Kiir(); getch(); return 0;

209

}

Adatok osztály deklarációja (Adatok.h)

/****************************************************************** * Adatok osztály deklarációja * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef ADATOK_H //if not define egy szimbólum nemlétét ellenőrzi #define ADATOK_H //egy szimbólum definiálása és értékének megadása //================================================================= class Adatok { //================================================================= protected: double x, y; public: Adatok(double x1, double y1); ~Adatok(void); }; #endif //feltétel lezárása

Eredmeny osztály deklarációja (Eredmeny.h)

/****************************************************************** * Eredmeny osztály deklarációja * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef EREDMENY_H //if not define egy szimbólum nemlétét ellenőrzi #define EREDMENY_H //egy szimbólum definiálása és értékének megadása //================================================================= class Eredmeny { //================================================================= protected: double eredmeny; public: Eredmeny(void); ~Eredmeny(void); }; #endif //feltétel lezárása

MuveletiJel osztály deklarációja (MuveletiJel.h)

/****************************************************************** * MuveletiJel osztály deklarációja * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás *

210

* * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef MUVELETIJEL_H //if not define egy szimbólum nemlétét ellenőrzi #define MUVELETIJEL_H //egy szimbólum definiálása és értékének megadása //================================================================= class MuveletiJel { //================================================================= protected: char muv; public: MuveletiJel(char muv1); ~MuveletiJel(void); }; #endif //feltétel lezárása

Muvelet osztály deklarációja (Muvelet.h)

/****************************************************************** * Muvelet osztály deklarációja * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef MUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define MUVELET_H //egy szimbólum definiálása és értékének megadása #include "Adatok.h" #include "MuveletiJel.h" #include "Eredmeny.h" //================================================================= class Muvelet : public Adatok, public MuveletiJel, public Eredmeny //================================================================= { public: Muvelet(double x1, double y1, char muv1); ~Muvelet(void); virtual void Szamol(); void Vegrehajt() { Szamol(); } double GetEredmeny() { return eredmeny; } void Kiir(); }; #endif //feltétel lezárása

UjMuvelet osztály deklarációja (UjMuvelet.h)

/****************************************************************** * UjMuvelet osztály deklarációja * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás * * * * Katona József <katona.jozsef.duf@freemail.hu> *

211

*******************************************************************/ #ifndef UJMUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define UJMUVELET_H //egy szimbólum definiálása és értékének megadása #include "Muvelet.h" //================================================================= class UjMuvelet : public Muvelet { //================================================================= public: UjMuvelet(double x1, double y1, char muv1); ~UjMuvelet(void); void Szamol(); }; #endif //feltétel lezárása

Adatok osztály implementálása (Adatok.cpp)

/****************************************************************** * Adatok osztály implementálása * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include "Adatok.h" //----------------------------------------------------------------- Adatok::Adatok(double x1, double y1) //----------------------------------------------------------------- { x = x1, y = y1; } //----------------------------------------------------------------- Adatok::~Adatok(void){} //----------------------------------------------------------------- /****************************************************************** * Eredmeny osztály implementálása * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include "Eredmeny.h" //----------------------------------------------------------------- Eredmeny::Eredmeny(void) //----------------------------------------------------------------- { eredmeny = 0; } //-----------------------------------------------------------------

212

Eredmeny::~Eredmeny(void) {} //-----------------------------------------------------------------

Muvelet osztály implementálása (Muvelet.cpp)

/****************************************************************** * Muvelet osztály implementálása * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> #include "Muvelet.h" using namespace std; //----------------------------------------------------------------- Muvelet::Muvelet(double x1, double y1, char muv1): Adatok(x1, y1), MuveletiJel(muv1), Eredmeny() //----------------------------------------------------------------- {} //----------------------------------------------------------------- Muvelet::~Muvelet(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- void Muvelet::Szamol() //----------------------------------------------------------------- { switch(muv) { case '+' : eredmeny = x + y; break; case '-' : eredmeny = x - y; break; case '*' : eredmeny = x * y; break; case '/' : eredmeny = x / y; break; default: eredmeny = 0; cerr << "Ervenytelen muveleti jel: " << muv << endl; } } //----------------------------------------------------------------- void Muvelet::Kiir() //----------------------------------------------------------------- { cout << x << " " << muv << " " << y << " = " << eredmeny << endl; }

MuveletiJel osztály implementálása (MuveletiJel.cpp)

/****************************************************************** * MuveletiJel osztály implementálása * * Demonstrációs célok: *

213

* -> többszörös öröklődés mechanizmusa * * -> virtualitás * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include "MuveletiJel.h" //----------------------------------------------------------------- MuveletiJel::MuveletiJel(char muv1) //----------------------------------------------------------------- { muv = muv1; } //----------------------------------------------------------------- MuveletiJel::~MuveletiJel(void) {} //-----------------------------------------------------------------

UjMuvelet osztály implementálása (UjMuvelet.cpp)

/****************************************************************** * UjMuvelet osztály implementálása * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include "UjMuvelet.h" #include <cmath> //----------------------------------------------------------------- UjMuvelet::UjMuvelet(double x1, double y1, char muv1) : Muvelet(x1, y1, muv1) {} //----------------------------------------------------------------- //----------------------------------------------------------------- UjMuvelet::~UjMuvelet(void) {} //----------------------------------------------------------------- //----------------------------------------------------------------- void UjMuvelet::Szamol() //----------------------------------------------------------------- { if (muv == '^') eredmeny = pow(x,y); else Muvelet::Szamol(); }

UjMuvelet osztály példányosítása (main.cpp)

/****************************************************************** * UjMuvelet osztály példányosítása * * Demonstrációs célok: * * -> többszörös öröklődés mechanizmusa * * -> virtualitás * * *

214

* Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> #include <cstring> #include <conio.h> #include "UjMuvelet.h" using namespace std; //***************************************************************** int main() //***************************************************************** { double a1, b1; char m; cout << "1. adat: "; cin >> a1; cout << "2. adat: "; cin >> b1; do { cout << "muveleti jel (+,-,*,/,^): "; cin >> m; }while(!strchr("+-*/^",m)); UjMuvelet w1(a1,b1,m); w1.Vegrehajt(); w1.Kiir(); getch(); return 0; }

Shape osztály deklarációja (Shape.h)

/****************************************************************** * Shape osztály deklarációja * * Demonstrációs célok: * * -> absztrakt osztályok * * -> tisztán virtuális metódusok * * -> a 0 suffixum * * -> öröklődés absztrakt osztályból * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef MUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define MUVELET_H //egy szimbólum definiálása és értékének megadása //================================================================= class Shape { //================================================================= public: //Tisztán virtuális metódusok virtual void Area(int length, int breadth) = 0; virtual void Perimeter(int length, int breadth) = 0; }; #endif //feltétel lezárása

Rectangle osztály deklarációja (Rectangle.h)

215

/****************************************************************** * Rectangle osztály deklarációja * * Demonstrációs célok: * * -> absztrakt osztályok * * -> tisztán virtuális metódusok * * -> a 0 suffixum * * -> öröklődés absztrakt osztályból * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef RECTANGLE_H //if not define egy szimbólum nemlétét ellenőrzi #define RECTANGLE_H //egy szimbólum definiálása és értékének megadása //================================================================= #include "Shape.h" //A Shape osztály deklarációi //================================================================= class Rectangle : public Shape { //================================================================= public: void Area(int length, int breadth); void Perimeter(int length, int breadth); private: int someData; }; #endif //feltétel lezárása

Rectangle osztály implementálása (Rectangle.cpp)

/****************************************************************** * Rectangle osztály implementáció * * Demonstrációs célok: * * -> absztrakt osztályok * * -> tisztán virtuális metódusok * * -> a 0 suffixum * * -> öröklődés absztrakt osztályból * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> #include "Rectangle.h" using namespace std; //----------------------------------------------------------------- void Rectangle::Area(int length, int breadth) //----------------------------------------------------------------- { cout << "\nThe Area of Rectangle for length = " << length << " and\ breadth = " << breadth << " is " << (length * breadth) << endl; } //----------------------------------------------------------------- void Rectangle::Perimeter(int length, int breadth) //----------------------------------------------------------------- { cout << "\nThe Perimeter of Rectangle for length = " << length << " and\ breadth = " << breadth <<" is " << 2 * (length + breadth) << endl;

216

}

Triangle osztály deklarációja (Triangle.h)

/****************************************************************** * Triangle osztály deklarációja * * Demonstrációs célok: * * -> absztrakt osztályok * * -> tisztán virtuális metódusok * * -> a 0 suffixum * * -> öröklődés absztrakt osztályból * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef TRIANGLE_H //if not define egy szimbólum nemlétét ellenőrzi #define TRIANGLE_H //egy szimbólum definiálása és értékének megadása //================================================================= #include "Shape.h" //A Shape osztály deklarációi //================================================================= class Triangle : public Shape { //================================================================= public: void Area(int length, int breadth); void Perimeter(int length, int breadth); private: int someData; }; #endif //feltétel lezárása

Triangle osztály implementációja (Triangle.cpp)

/****************************************************************** * Triangle osztály implementáció * * Demonstrációs célok: * * -> absztrakt osztályok * * -> tisztán virtuális metódusok * * -> a 0 suffixum * * -> öröklődés absztrakt osztályból * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> #include "Triangle.h" using namespace std; //----------------------------------------------------------------- void Triangle::Area(int length, int breadth) //----------------------------------------------------------------- { cout << "\nThe Area of Triangle for length = " << length << " and\ breadth = " << breadth << " is " << (length * breadth)/2 << endl; } //----------------------------------------------------------------- void Triangle::Perimeter(int length, int breadth)

217

//----------------------------------------------------------------- { cout << "\nThe Perimeter of Triangle for length = " << length << " and\ breadth = " << breadth << " is " << (length * breadth)/3 << endl; }

Rectangle és Triangle osztály példányosítása (main.cpp)

/****************************************************************** * Rectangle osztály példányosítása * * Triangle osztály példányosítása * * * * Demonstrációs célok: * * -> absztrakt osztályok * * -> tisztán virtuális metódusok * * -> a 0 suffixum * * -> öröklődés absztrakt osztályból * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> #include <conio.h> #include "Triangle.h" #include "Rectangle.h" using namespace std; //***************************************************************** int main() //***************************************************************** { Rectangle r; Triangle t; cout<<"\n\n"; r.Area(3,4); r.Perimeter(3,4); t.Area(3,4); t.Perimeter(3,4); cout<<"\n\n"; getch(); return 0; }

Muvelet osztály deklarációja (Muvelet.h)

/****************************************************************** * Muvelet osztály deklarációja * * Demonstrációs célok: * * -> operátor túlterhelés * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef MUVELET_H //if not define egy szimbólum nemlétét ellenőrzi #define MUVELET_H //egy szimbólum definiálása és értékének megadása

218

//================================================================= #include <iostream> using namespace std; //================================================================= class Muvelet { //================================================================= private: double x, y, eredmeny; char muv; public: Muvelet() {x = 1, y = 1, muv = '+'; } Muvelet(double x1, double y1, char muv1); Muvelet(const Muvelet& v); void Szamol(); double GetEredmeny() { return eredmeny; } void Kiir(); friend istream & operator >> (istream&, Muvelet&); friend ostream & operator << (ostream&, const Muvelet&); }; #endif //feltétel lezárása

Muvelet osztály implementálása (Muvelet.cpp)

/****************************************************************** * Muvelet osztály implementálása * * Demonstrációs célok: * * -> operátor túlterhelés * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> #include <cstring> #include "Muvelet.h" using namespace std; //----------------------------------------------------------------- Muvelet::Muvelet(double x1, double y1, char muv1) //----------------------------------------------------------------- { x = x1; y = y1; muv = muv1; } //----------------------------------------------------------------- Muvelet::Muvelet(const Muvelet& v) //----------------------------------------------------------------- { x = v.x; y = v.y; muv = v.muv; } //----------------------------------------------------------------- void Muvelet::Szamol() //----------------------------------------------------------------- { switch (muv)

219

{ case '+' : eredmeny = x + y; break; case '-' : eredmeny = x - y; break; case '*' : eredmeny = x * y; break; case '/' : eredmeny = x / y; break; } } //----------------------------------------------------------------- void Muvelet::Kiir() //----------------------------------------------------------------- { cout << x << " " << muv << " " << y << " = " << eredmeny << endl; } //----------------------------------------------------------------- // >> adatbevitel átdefiniálása (túlterhelés) istream & operator >> (istream& is, Muvelet& v) //----------------------------------------------------------------- { cout << "1. adat: "; is >> v.x; cout << "2. adat: "; is >> v.y; do { cout << "Muveleti jel (+-*/): "; is >> v.muv; }while(!strchr("+-*/",v.muv)); return is; } //----------------------------------------------------------------- // << adatkivitel átdefiniálása (túlterhelés) ostream & operator << (ostream& os, const Muvelet& v) //----------------------------------------------------------------- { os << v.x << " " << v.muv << " " << v.y << " = " << v.eredmeny << endl; return os; }

Muvelet osztály példányosítása (main.cpp)

/****************************************************************** * Muvelet osztály példányosítása * * Demonstrációs célok: * * -> operátor túlterhelés * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <conio.h> #include <iostream> #include "Muvelet.h" using namespace std; //***************************************************************** int main()

220

//***************************************************************** { Muvelet w; cout << "Muvelet osztaly adattagjainak beolvasasa\n"; //az átdefiniált >> operátor a cin adatfolyamtól a w //objektumpéldány adattagjait olvassa be cin >> w; w.Szamol(); cout << "Muvelet osztaly adattagjainak kiírása\n"; //az átdefiniált << operátor a cout adatfolyamra írja ki //a w objektumpéldány adattagjait cout << w; getch(); return 0; }

Statikus osztály deklarációja (Statikus.h)

/****************************************************************** * Statikus osztály deklarációja * * Demonstrációs célok: * * -> statikus adattag * * -> statikus tagfüggvény * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #ifndef STATIKUS_H //if not define egy szimbólum nemlétét ellenőrzi #define STATIKUS_H //egy szimbólum definiálása és értékének megadása //================================================================= class Statikus { //================================================================= private: static int sum; //statikus adat int x; public: Statikus(void); ~Statikus(void); static void s_fv(); //statikus függvény void number(); }; #endif //feltétel lezárása

Statikus osztály implementálása (Statikus.cpp)

/****************************************************************** * Statikus osztály implementálása * * Demonstrációs célok: * * -> statikus adattag * * -> statikus tagfüggvény * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <iostream> #include "Statikus.h" using namespace std;

221

//----------------------------------------------------------------- Statikus::Statikus(void) //----------------------------------------------------------------- { sum+=1; x=sum; } //----------------------------------------------------------------- Statikus::~Statikus(void) //----------------------------------------------------------------- { sum-=1; } //----------------------------------------------------------------- void Statikus::s_fv() //----------------------------------------------------------------- { cout << "\nResult is: " << sum; } //----------------------------------------------------------------- void Statikus::number() //----------------------------------------------------------------- { cout << "\nNumber is: " << x; }

Statikus osztály példányosítása (main.cpp)

/****************************************************************** * Statikus osztály példányosítása * * Demonstrációs célok: * * -> statikus adattag * * -> statikus tagfüggvény * * * * Katona József <katona.jozsef.duf@freemail.hu> * *******************************************************************/ #include <conio.h> #include "Statikus.h" int Statikus::sum=0; //***************************************************************** int main() //***************************************************************** { Statikus s1; Statikus::s_fv(); //statikus függvény hívása Statikus s2, s3, s4; Statikus::s_fv(); s1.number(); //normál függvény hívása s2.number(); s3.number();

222

s4.number(); getch(); return 0; }

223

FajlMenu osztály deklarációja (FajlMenu.h)

/************************************************************************************* * FajlMenu osztály deklarációja * * Demonstrációs célok: * * -> richTextBox vezérlő * * -> openFileDialog vezérlő * * -> saveFileDialog vezérlő * * -> printDialog vezérlő * * -> printDocument vezérlő * * -> fontDialog vezérlő * * -> printPreviewDialog vezérlő * * -> menuStrip vezérlő * * -> toolStrip vezérlő * * -> colorDialog vezérlő * * -> névterek jelentősége * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #ifndef FAJLMENU_H //if not define egy szimbólum nemlétét ellenőrzi #define FAJLMENU_H //egy szimbólum definiálása és értékének megadása //=================================================================================== namespace WFA_11 { //=================================================================================== using namespace System; //a String típus miatt using namespace System::Windows::Forms; //a Form típus miatt using namespace System::IO; //a StringReader miatt ref class frmMain; //referencia hivatkozás az frmMain osztályra //=================================================================================== ref class FajlMenu { //=================================================================================== private: frmMain^ mainfrm; //a form tárolóvezérlő String^ aktFajlNev; //aktuális fájl név public: FajlMenu(frmMain^ frm); //konstruktor void Uj(); //Új menüpont függvénye void Megnyitas(); //Megnyitás menüpont függvénye void Mentes(); //Mentés menüpont függvénye void Kilepes(); //Kilépés menüpont függvénye void Nyomtatas(); //Nyomtatás menüpont függvénye void NyomtatasiElokep(); //Nyomtatási előkép függvénye DialogResult MentesKerdesMegnyitas(); //a mentés megfogalmazása megnyitásnál DialogResult MentesKerdesUj(); //a mentés megfogalmazása új dokumentumnál DialogResult MentesKerdesKilepes(); //a mentés megfogalmazása kilépésnél void SetMegnyitasDialog(); //megnyitás paramétereinek beállítása void SetMentesDialog(); //mentés paramétereinek beállítása void OpenFile(); //a megnyitási mechanizmus void SaveFile(); //a mentési mechanizmus void SetNyomtatasiOldal(System::Object^ sender, System::Drawing::Printing::PrintPageEventArgs^ e, StringReader^ myReader); //A nyomtatási oldal beállítása }; } #endif

FajlMenu osztály implementálása (FajlMenu.cpp)

/************************************************************************************ * FajlMenu osztály implementálása *

224

* Demonstrációs célok: * * -> richTextBox vezérlő * * -> openFileDialog vezérlő * * -> saveFileDialog vezérlő * * -> printDialog vezérlő * * -> printDocument vezérlő * * -> fontDialog vezérlő * * -> printPreviewDialog vezérlő * * -> menuStrip vezérlő * * -> toolStrip vezérlő * * -> colorDialog vezérlő * * -> névterek jelentősége * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #include "StdAfx.h" //precompiled header #include "FajlMenu.h" //FajlMenu deklarációi #include "frmMain.h" //frmMain deklarációi //==================================================================================== namespace WFA_11 { //==================================================================================== using namespace System::Windows::Forms; //az ablakok miatt using namespace System::IO; //streamReader miatt //------------------------------------------------------------------------------------ FajlMenu::FajlMenu(frmMain^ frm) //------------------------------------------------------------------------------------ { this->mainfrm = frm; //az osztály adattagjának az inicializálása } //------------------------------------------------------------------------------------ void FajlMenu::Uj() //------------------------------------------------------------------------------------ { try { //ha már módosítás történt if(mainfrm->richTextBox1->Modified == true) { //megkérdezzük, hogy a felhasználó szeretné-e menteni a változásokat DialogResult answer = MentesKerdesUj(); //ha a válasz igen, akkor mentjük a változásokat if(answer == DialogResult::Yes) { //beállítjuk a mentés dialógust SetMentesDialog(); //ha a fájl azonosító hossza nagyobb, mint nulla és a válasz igen if (mainfrm->saveFileDialog1->ShowDialog() == DialogResult::OK && mainfrm->saveFileDialog1->FileName->Length > 0) { //a fájl mentése SaveFile(); //A szövegterület törlése mainfrm->richTextBox1->Clear(); } } //ha a válasz nem, akkor létrehozunk egy üres fájlt else if(answer == DialogResult::No) //a szövegterület törlése mainfrm->richTextBox1->Clear(); //ha a válasz mégse, visszatérünk a szöveghez else return;

225

} //ha nem történt módosítás else //A szövegterület törlése mainfrm->richTextBox1->Clear(); aktFajlNev = ""; mainfrm->aktFajlNev_lbl->Text = "Aktuális fájlnév: " + aktFajlNev; } catch (Exception^ ex) { MessageBox::Show("Az új fájl létrehozása sikertelen: " + ex->Message, "Új művelet hiba", MessageBoxButtons::OK, MessageBoxIcon::Error); } } //------------------------------------------------------------------------------------ void FajlMenu::Megnyitas() //------------------------------------------------------------------------------------ { try { //ha már módosítás történt if(mainfrm->richTextBox1->Modified == true) { //megkérdezzük, hogy szeretné-e menteni a változásokat DialogResult answer = MentesKerdesMegnyitas(); //ha a válasz igen, akkor mentjük a változásokat if(answer == DialogResult::Yes) { //beállítjuk a mentés dialógust SetMentesDialog(); //ha a fájl azonosító hossza nagyobb, mint nulla és a válasz igen if (mainfrm->saveFileDialog1->ShowDialog() == DialogResult::OK && mainfrm->saveFileDialog1->FileName->Length > 0) //a fájl mentése SaveFile(); } //ha a válasz nem, akkor nyitunk egy üres fájlt else if(answer == DialogResult::No) { //az open dialógus beállítása SetMegnyitasDialog(); //az open dialógus megnyitása if (mainfrm->openFileDialog1->ShowDialog() == DialogResult::OK) //a fájl megnyitása OpenFile(); } //ha a válasz mégse, visszatérünk a szöveghez else return; } //ha nem történt módosítás else { //az open dialógus beállítása SetMegnyitasDialog(); //az open dialógus megnyitása if (mainfrm->openFileDialog1->ShowDialog() == DialogResult::OK) //a fájl megnyitása OpenFile(); } } catch (Exception^ ex) { MessageBox::Show("A fájl megnyitása sikertelen: "+ex->Message, "Megnyitás művelet hiba", MessageBoxButtons::OK, MessageBoxIcon::Error);

226

} } //----------------------------------------------------------------------------------- void FajlMenu::Mentes() //----------------------------------------------------------------------------------- { try { //A mentés dialógus beállítása SetMentesDialog(); //Ha a felhasználó elszeretné menteni a fájlt és a fájl azonosítója hosszabb, //mint nulla, akkor mentjük a fájlt if (mainfrm->saveFileDialog1->ShowDialog() == DialogResult::OK && mainfrm->saveFileDialog1->FileName->Length > 0) SaveFile(); } catch (Exception^ ex) { MessageBox::Show("A fájl mentése sikertelen: "+ex->Message,"Fájl mentés hiba", MessageBoxButtons::OK, MessageBoxIcon::Error); } } //----------------------------------------------------------------------------------- void FajlMenu::Nyomtatas() //----------------------------------------------------------------------------------- { try { //több oldalas dokumentum engedélyezése mainfrm->printDialog1->AllowSomePages = true; //a help menü megjelenítése mainfrm->printDialog1->ShowHelp = true; //a dialógus dokumentum beállítása az aktuális dokumentumra mainfrm->printDialog1->Document = mainfrm->printDocument1; //ha a nyomtatási dokumentum nem létezik, akkor hibaüzenet if (mainfrm->printDocument1 == nullptr) MessageBox::Show("A nyomtatási dokumentum üres: ","Nyomtatás hiba", MessageBoxButtons::OK, MessageBoxIcon::Error); //egyébként nyomtatás else if(mainfrm->printDialog1->ShowDialog() == DialogResult::OK) { mainfrm->printDocument1->Print(); } } catch (Exception^ ex) { MessageBox::Show("A fájl nyomtatása nem lehetséges: "+ex->Message, "Nyomtatási hiba", MessageBoxButtons::OK, MessageBoxIcon::Error); } } //------------------------------------------------------------------------------------ void FajlMenu::NyomtatasiElokep() //------------------------------------------------------------------------------------ { try { mainfrm->printPreviewDialog1->Document = mainfrm->printDocument1; //Nyomtatási előkép megjelenítése mainfrm->printPreviewDialog1->ShowDialog(); } catch(Exception^ e) {

227

MessageBox::Show("A következő fájl nem olvasható: "+e->Message, "Nyomtatási kép hiba", MessageBoxButtons::OK, MessageBoxIcon::Error); } } //------------------------------------------------------------------------------------ void FajlMenu::SetNyomtatasiOldal(System::Object^ sender, System::Drawing::Printing::PrintPageEventArgs^ e, StringReader^ myReader) //------------------------------------------------------------------------------------ { //sorok kiolvasása String^ line = nullptr; //szöveg felépítésére String^ str = nullptr; //betűtípus beállítása Font^ printFont = mainfrm->richTextBox1->SelectionFont; //a téglalap keret színének beállítása Pen ^ penCurrent = gcnew Pen(Color::White); //A4-es oldal méretének beállítása Rectangle rect(50, 50, 730, 1070); //kiszámoljuk, hogy egy oldalra hány sor fér float linesPerPage = 1040 / printFont->GetHeight(e->Graphics); //sorok száma int count = 0; //téglalap kirajzolása e->Graphics->DrawRectangle(penCurrent, rect); //Nyomtassunk ki minden egyes sort, ami a fájlban szerepel while(count < linesPerPage && ((line=myReader->ReadLine()) != nullptr)) { str += line; str += "\r\n"; count++; } //ha több sor létezik, mint ami egy oldalra ráfér, //akkor szükségünk lesz egy másik oldalra if(line != nullptr) e->HasMorePages = true; else e->HasMorePages = false; //szöveg kirajzolása e->Graphics->DrawString(str, printFont, Brushes::Black, rect); } //------------------------------------------------------------------------------------ void FajlMenu::Kilepes() //------------------------------------------------------------------------------------ { try { //ha már módosítás történt if(mainfrm->richTextBox1->Modified == true) { //megkérdezzük, hogy szeretné-e menteni a változásokat DialogResult answer = MentesKerdesKilepes(); //ha a válasz igen, akkor mentjük a változásokat if(answer == DialogResult::Yes) { //beállítjuk a mentés dialógust SetMentesDialog(); if (mainfrm->saveFileDialog1->ShowDialog() == DialogResult::OK && mainfrm->saveFileDialog1->FileName->Length > 0) SaveFile(); }

228

//ha a válasz nem, akkor nyitunk egy üres fájlt else if(answer == DialogResult::No) { //kilépés mainfrm->Close(); } //ha a válasz mégse, visszatérünk a szöveghez else return; } //ha nem történt módosítás else { mainfrm->Close(); } } catch (Exception^ ex) { MessageBox::Show("Kilépés sikertelen: "+ex->Message,"Kilépés hiba", MessageBoxButtons::OK, MessageBoxIcon::Error); } } //--------------------------------------------------------------------------------- DialogResult FajlMenu::MentesKerdesMegnyitas() //--------------------------------------------------------------------------------- { DialogResult answer = MessageBox::Show( "A dokumentumban változás történt. Szeretné menteni?" "\nKlikk\n" "Igen\tAktuális dokumentum mentése és egy új nyitása.\n" "Nem\tAktuális dokumentumot nem mentem, de nyitok egy újat.\n" "Mégse\tNe történjen semmi.", "Fájl mentése", MessageBoxButtons::YesNoCancel, MessageBoxIcon::Question); return answer; } //----------------------------------------------------------------------------------- DialogResult FajlMenu::MentesKerdesUj() //----------------------------------------------------------------------------------- { DialogResult answer = MessageBox::Show( "A dokumentumban változás történt. Szeretné menteni?" "\nKlikk\n" "Igen\tAktuális dokumentum mentése és egy új nyitása.\n" "Nem\tAktuális dokumentumot nem mentem, de létrehozok egy újat.\n" "Mégse\tNe történjen semmi.","Fájl mentése", MessageBoxButtons::YesNoCancel, MessageBoxIcon::Question); return answer; } //---------------------------------------------------------------------------------- DialogResult FajlMenu::MentesKerdesKilepes() //---------------------------------------------------------------------------------- { DialogResult answer = MessageBox::Show( "A dokumentumban változás történt. Szeretné menteni?" "\nKlikk\n" "Igen\tAktuális dokumentum mentése és kilépés.\n" "Nem\tAktuális dokumentumot nem mentem, de kilépek.\n" "Mégse\tNe történjen semmi.", "Fájl mentése", MessageBoxButtons::YesNoCancel, MessageBoxIcon::Question);

229

return answer; } //---------------------------------------------------------------------------------- void FajlMenu::SetMegnyitasDialog() //---------------------------------------------------------------------------------- { //a megjelenő ablak fejlécének szövege mainfrm->openFileDialog1->Title = "Megnyitás"; //állomány típuskorlátozás mainfrm->openFileDialog1->Filter = "Text Document (.txt)|*.txt|"+ "Rich Text Document (.rtf)|*.rtf|Word Document (.doc)|*.doc"+ "|Batch File (.bat)|*.bat|All Files (*.*)|*.*"; //a fájl nevének "kinullázása" mainfrm->openFileDialog1->FileName = ""; //kiválasztjuk, hogy hányadik szűrő feltétel //legyen az aktív a Filter-ben megadottak közül. mainfrm->openFileDialog1->FilterIndex = 2; //a dialóg megjelenésekor ez lesz az aktuális alkönyvtár mainfrm->openFileDialog1->InitialDirectory = "My documents"; //a dialóg ellenőrzi, hogy a megadott állomány létezik-e mainfrm->openFileDialog1->CheckFileExists = true; //a megadott alkönyvtár létezőségének ellenőrzése mainfrm->openFileDialog1->CheckPathExists = true; } //-------------------------------------------------------------------------------- void FajlMenu::SetMentesDialog() //-------------------------------------------------------------------------------- { //az alapértelmezett fájl kiterjesztés beállítása mainfrm->saveFileDialog1->DefaultExt = ".rtf"; //állomány típuskorlátozás mainfrm->saveFileDialog1->Filter = "Text Document (.txt)|*.txt|"+ "Rich Text Document (.rtf)|*.rtf|Word Document (.doc)|*.doc"+ "|Batch File (.bat)|*.bat|All Files (*.*)|*.*"; //kiválasztjuk, hogy hányadik szűrő feltétel //legyen az aktív a Filter-ben megadottak közül. mainfrm->saveFileDialog1->FilterIndex = 2; //a dialóg megjelenésekor ez lesz az aktuális alkönyvtár //alapértelmezett fájl név mainfrm->saveFileDialog1->FileName = "<Fájl neve>"; //figyelmezteti a felhasználót, ha a fájl már létezik mainfrm->saveFileDialog1->OverwritePrompt = true; //a dialógus ablak címsor szövege mainfrm->saveFileDialog1->Title = "Fájl mentése"; } //--------------------------------------------------------------------------------- void FajlMenu::OpenFile() //--------------------------------------------------------------------------------- { try { //fájlunk betöltése mainfrm->richTextBox1->LoadFile(mainfrm->openFileDialog1->FileName, RichTextBoxStreamType::RichText); //aktuális fájlnév beállítása aktFajlNev = mainfrm->openFileDialog1->FileName; mainfrm->aktFajlNev_lbl->Text = "Aktuális fájlnév: " + aktFajlNev; } catch(Exception^ e) { MessageBox::Show("Hiba történt a fájl megnyitása során! Kérem ellenőrizze!", "Fájl megnyitási hiba", MessageBoxButtons::OK, MessageBoxIcon::Error);

230

} } //--------------------------------------------------------------------------------- void FajlMenu::SaveFile() //--------------------------------------------------------------------------------- { try { //mentjük a richTextBox tartalmát a megadott fájlnévvel és típussal mainfrm->richTextBox1->SaveFile(mainfrm->saveFileDialog1->FileName, RichTextBoxStreamType::RichText); MessageBox::Show("Mentés sikeres!", "Fájl elérési útvonala : " + mainfrm->saveFileDialog1->FileName, MessageBoxButtons::OK, MessageBoxIcon::Information); //az aktuális fájl név beállítása aktFajlNev = mainfrm->saveFileDialog1->FileName; mainfrm->aktFajlNev_lbl->Text = "Aktuális fájlnév: " + aktFajlNev; } catch(Exception^ e) { MessageBox::Show("Hiba történt a fájl mentése során! Kérem ellenőrizze!", "Fájl mentés hiba", MessageBoxButtons::OK, MessageBoxIcon::Error); } } }

EditMenu osztály deklarációja (EditMenu.h)

/************************************************************************************* * EditMenu osztály deklarációja * * Demonstrációs célok: * * -> richTextBox vezérlő * * -> openFileDialog vezérlő * * -> saveFileDialog vezérlő * * -> printDialog vezérlő * * -> printDocument vezérlő * * -> fontDialog vezérlő * * -> printPreviewDialog vezérlő * * -> menuStrip vezérlő * * -> toolStrip vezérlő * * -> colorDialog vezérlő * * -> névterek jelentősége * * * * Katona József <katona.jozsef.duf@freemail.hu> * **************************************************************************************/ #ifndef EDITMENU_H //if not define egy szimbólum nemlétét ellenőrzi #define EDITMENU_H //egy szimbólum definiálása és értékének megadása //==================================================================================== namespace WFA_11 { //==================================================================================== using namespace System; //a String^ típus miatt using namespace System::Windows::Forms; //a From^ típus miatt ref class frmMain; //referencia hivatkozás a főablakra ref class findForm; //referencia hivatkozás a keresőablakra ref class findReplaceForm; //referencia hivatkozás a csereablakra //==================================================================================== ref class EditMenu { //==================================================================================== private: static frmMain^ f1; //fő form tárolóvezérlő static findForm^ fndfrm; //kereső form tárolóvezérlő

231

static findReplaceForm^ fndrepfrm; //csere form tárolóvezérlő public: EditMenu(frmMain^ frm); //konstruktor void ShowFindForm(); //a kereső form megjelenítése void ShowFindReplaceForm(); //a csere form megjelenítése void Kereses(); //a kereső form kereső metódusa void KovetkezoKereses(); //a kereső form következő metódusa void Kereses2(); //a csere form kereső metódusa void KovetkezoKereses2(); //a csere form következő metódusa void Csere(); //a csere form csere metódusa void CsereAll(); //a csere form összes cseréje metódusa }; } #endif;

EditMenu osztály implementálása (EditMenu.cpp)

/************************************************************************************* * EditMenu osztály implementálása * * Demonstrációs célok: * * -> richTextBox vezérlő * * -> openFileDialog vezérlő * * -> saveFileDialog vezérlő * * -> printDialog vezérlő * * -> printDocument vezérlő * * -> fontDialog vezérlő * * -> printPreviewDialog vezérlő * * -> menuStrip vezérlő * * -> toolStrip vezérlő * * -> colorDialog vezérlő * * -> névterek jelentősége * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #include "StdAfx.h" //precompiled header #include "EditMenu.h" //EditMenu deklarációi #include "frmMain.h" //a főablak deklarációi #include "frmFind.h" //a kereső ablak deklarációi #include "frmReplace.h" //a keres és csere ablak deklarációi //================================================================================== namespace WFA_11 { //================================================================================== using namespace System::Windows::Forms; //az ablakok miatt using namespace System::IO; //streamReader miatt //----------------------------------------------------------------------------------- EditMenu::EditMenu(frmMain^ frm) //----------------------------------------------------------------------------------- { f1 = frm; } //----------------------------------------------------------------------------------- void EditMenu::ShowFindForm() //----------------------------------------------------------------------------------- { fndfrm = gcnew findForm(); fndfrm->Show(); } //-----------------------------------------------------------------------------------

232

void EditMenu::ShowFindReplaceForm() //----------------------------------------------------------------------------------- { fndrepfrm = gcnew findReplaceForm(); fndrepfrm->Show(); } //----------------------------------------------------------------------------------- void EditMenu::Kereses() //----------------------------------------------------------------------------------- { try { //kiinduló pozíció int StartPosition; //keresési típus StringComparison SearchType; //ha a pontos egyezés van kiválasztva if (fndfrm->chkMatchCase->Checked == true) //a keresési típus beállítása pontos egyezésre (case sensitive) SearchType = StringComparison::Ordinal; else //a keresési típus beállítása kis és nagybetűs egyezésre egyaránt //(non case sensitive) SearchType = StringComparison::OrdinalIgnoreCase; //a kiindulási pozíció a beviteli mezőben megadott szöveg //richTextBox-ban megtalált pozíció indexe lesz StartPosition = f1->richTextBox1->Text->IndexOf(fndfrm->txtSearchTerm->Text, SearchType); //ha ez a pozíció nulla, (tehát nincs egyezőség a szövegben) akkor a //felhasználót figyelmeztetjük if (StartPosition == 0) { MessageBox::Show("Szövegminta: " + fndfrm->txtSearchTerm->Text->ToString() + " nem található!", "Nincs egyezés", MessageBoxButtons::OK, MessageBoxIcon::Asterisk); return; } //a minta kijelölése a szövegben f1->richTextBox1->Select(StartPosition, fndfrm->txtSearchTerm->Text->Length); //automatikus görgetés bekapcsolása f1->richTextBox1->ScrollToCaret(); //a fókusz áthelyezésre a szövegre f1->richTextBox1->Focus(); //A következő gomb aktívvá tétele fndfrm->btnFindNext->Enabled = true; } catch (Exception^ ex) { MessageBox::Show(ex->Message->ToString(), "Hiba", MessageBoxButtons::OK, MessageBoxIcon::Warning); } } //----------------------------------------------------------------------------------- void EditMenu::KovetkezoKereses() //----------------------------------------------------------------------------------- { try { //kiinduló pozíció

233

int StartPosition = f1->richTextBox1->SelectionStart + 2; //keresési típus StringComparison SearchType; //ha a pontos egyezés van kiválasztva if (fndfrm->chkMatchCase->Checked == true) //a keresési típus beállítása pontos egyezésre (case sensitive) SearchType = StringComparison::Ordinal; else //a keresési típus beállítása kis és nagybetűs egyezésre egyaránt //(non case sensitive) SearchType = StringComparison::OrdinalIgnoreCase; //a kiindulási pozíció a beviteli mezőben megadott szöveg //richTextBox-ban megtalált pozíció indexe lesz StartPosition = f1->richTextBox1->Text->IndexOf(fndfrm->txtSearchTerm->Text, StartPosition, SearchType); //ha ez a pozíció nulla, (tehát nincs egyezőség a szövegben) vagy a //szöveg végén vagyunk akkor a felhasználót figyelmeztetjük if (StartPosition == 0 || StartPosition < 0) { MessageBox::Show("Szövegminta: " + fndfrm->txtSearchTerm->Text->ToString() + " nem található", "Nincs egyezés", MessageBoxButtons::OK, MessageBoxIcon::Asterisk); return; } //a minta kijelölése a szövegben f1->richTextBox1->Select(StartPosition, fndfrm->txtSearchTerm->Text->Length); //automatikus görgetés bekapcsolása f1->richTextBox1->ScrollToCaret(); //a fókusz áthelyezésre a szövegre f1->Focus(); } catch (Exception^ ex) { MessageBox::Show(ex->Message->ToString(), "Hiba", MessageBoxButtons::OK, MessageBoxIcon::Warning); } } //----------------------------------------------------------------------------------- void EditMenu::Kereses2() //----------------------------------------------------------------------------------- { try { //kiinduló pozíció int StartPosition; //keresési típus StringComparison SearchType; //ha a pontos egyezés van kiválasztva if (fndrepfrm->chkMatchCase->Checked == true) //a keresési típus beállítása pontos egyezésre (case sensitive) SearchType = StringComparison::Ordinal; else //a keresési típus beállítása kis és nagybetűs egyezésre egyaránt //(non case sensitive) SearchType = StringComparison::OrdinalIgnoreCase; //a kiindulási pozíció a beviteli mezőben megadott szöveg //richTextBox-ban megtalált pozíció indexe lesz StartPosition = f1->richTextBox1->Text->IndexOf(fndrepfrm->txtSearchTerm->Text, SearchType);

234

//ha ez a pozíció nulla, (tehát nincs egyezőség a szövegben) akkor a //felhasználót figyelmeztetjük if (StartPosition == 0) { MessageBox::Show("Szövegminta: " + fndrepfrm->txtSearchTerm->Text->ToString() +" nem található", "Nincs egyezés", MessageBoxButtons::OK, MessageBoxIcon::Asterisk); return; } //a minta kijelölése a szövegben f1->richTextBox1->Select(StartPosition, fndrepfrm->txtSearchTerm->Text->Length); //automatikus görgetés bekapcsolása f1->richTextBox1->ScrollToCaret(); //a fókusz áthelyezésre a szövegre f1->richTextBox1->Focus(); //A következő gomb aktívvá tétele fndrepfrm->btnFindNext->Enabled = true; } catch (Exception^ ex) { MessageBox::Show(ex->Message->ToString(), "Hiba", MessageBoxButtons::OK, MessageBoxIcon::Warning); } } //----------------------------------------------------------------------------------- void EditMenu::KovetkezoKereses2() //----------------------------------------------------------------------------------- { try { //kiinduló pozíció int StartPosition = f1->richTextBox1->SelectionStart + 2; //keresési típus StringComparison SearchType; //ha a pontos egyezés van kiválasztva if (fndrepfrm->chkMatchCase->Checked == true) //a keresési típus beállítása pontos egyezésre (case sensitive) SearchType = StringComparison::Ordinal; else //a keresési típus beállítása kis és nagybetűs egyezésre egyaránt //(non case sensitive) SearchType = StringComparison::OrdinalIgnoreCase; //a kiindulási pozíció a beviteli mezőben megadott szöveg //richTextBox-ban megtalált pozíció indexe lesz StartPosition = f1->richTextBox1->Text->IndexOf(fndrepfrm->txtSearchTerm->Text, StartPosition, SearchType); //ha ez a pozíció nulla, (tehát nincs egyezőség a szövegben) vagy a //szöveg végén vagyunk akkor a felhasználót figyelmeztetjük if (StartPosition == 0 || StartPosition < 0) { MessageBox::Show("Szövegminta: " + fndrepfrm->txtSearchTerm->Text->ToString() + " nem található", "Nincs egyezés", MessageBoxButtons::OK,MessageBoxIcon::Asterisk); return; } //a minta kijelölése a szövegben f1->richTextBox1->Select(StartPosition, fndrepfrm->txtSearchTerm->Text->Length); //automatikus görgetés bekapcsolása f1->richTextBox1->ScrollToCaret(); //a fókusz áthelyezésre a szövegre f1->Focus(); } catch (Exception^ ex) {

235

MessageBox::Show(ex->Message->ToString(), "Hiba", MessageBoxButtons::OK, MessageBoxIcon::Warning); } } //----------------------------------------------------------------------------------- void EditMenu::Csere() //----------------------------------------------------------------------------------- { try { //ha a kiválasztott elem hossza nem egyenlő nullával if (f1->richTextBox1->SelectedText->Length != 0) //szöveg kiválasztása f1->richTextBox1->SelectedText = fndrepfrm->txtReplacementText->Text; //kiinduló pozíció int StartPosition; //kiindulási típus StringComparison SearchType; //ha a pontos egyezés van kiválasztva if (fndrepfrm->chkMatchCase->Checked == true) //a keresési típus beállítása pontos egyezésre (case sensitive) SearchType = StringComparison::Ordinal; else //a keresési típus beállítása kis és nagybetűs egyezésre egyaránt //(non case sensitive) SearchType = StringComparison::OrdinalIgnoreCase; //a kiindulási pozíció a beviteli mezőben megadott szöveg //richTextBox-ban megtalált pozíció indexe lesz StartPosition = f1->richTextBox1->Text->IndexOf(fndrepfrm->txtSearchTerm->Text, SearchType); //ha ez a pozíció nulla, (tehát nincs egyezőség a szövegben) vagy a //szöveg végén vagyunk akkor a felhasználót figyelmeztetjük if (StartPosition == 0 || StartPosition < 0) { MessageBox::Show("Szövegminta: " + fndrepfrm->txtSearchTerm->Text->ToString() + " nem található", "Nincs egyezés", MessageBoxButtons::OK,MessageBoxIcon::Asterisk); return; } //a minta kijelölése a szövegben f1->richTextBox1->Select(StartPosition, fndrepfrm->txtSearchTerm->Text->Length); //automatikus görgetés bekapcsolása f1->richTextBox1->ScrollToCaret(); //a fókusz áthelyezésre a szövegre f1->Focus(); } catch (Exception^ ex) { MessageBox::Show(ex->Message->ToString(), "Hiba", MessageBoxButtons::OK, MessageBoxIcon::Warning); } } //----------------------------------------------------------------------------------- void EditMenu::CsereAll() //----------------------------------------------------------------------------------- { try { //Az úgynevezett white space karakterek eltávolítása és //az elemek cseréje a richTextBox-ban f1->richTextBox1->Rtf = f1->richTextBox1->Rtf->Replace (fndrepfrm->txtSearchTerm->Text->Trim(), fndrepfrm->txtReplacementText->Text->Trim());

236

//kiinduló pozíció int StartPosition; //kiindulási típus StringComparison SearchType; //ha a pontos egyezés van kiválasztva if (fndrepfrm->chkMatchCase->Checked == true) //a keresési típus beállítása pontos egyezésre (case sensitive) SearchType = StringComparison::Ordinal; else //a keresési típus beállítása kis és nagybetűs egyezésre egyaránt //(non case sensitive) SearchType = StringComparison::OrdinalIgnoreCase; //a kiindulási pozíció a beviteli mezőben megadott szöveg //richTextBox-ban megtalált pozíció indexe lesz StartPosition = f1->richTextBox1->Text->IndexOf(fndrepfrm->txtReplacementText->Text, SearchType); //a minta kijelölése a szövegben f1->richTextBox1->Select(StartPosition, fndrepfrm->txtReplacementText->Text->Length); //automatikus görgetés bekapcsolása f1->richTextBox1->ScrollToCaret(); //a fókusz áthelyezésre a szövegre f1->Focus(); } catch (Exception^ ex) { MessageBox::Show(ex->Message->ToString(), "Hiba", MessageBoxButtons::OK, MessageBoxIcon::Warning); } } }

ToolStripExtras osztály deklarációja (ToolStripExtras.h)

/************************************************************************************* * ToolStripExtras osztály deklarációja * * Demonstrációs célok: * * -> richTextBox vezérlő * * -> openFileDialog vezérlő * * -> saveFileDialog vezérlő * * -> printDialog vezérlő * * -> printDocument vezérlő * * -> fontDialog vezérlő * * -> printPreviewDialog vezérlő * * -> menuStrip vezérlő * * -> toolStrip vezérlő * * -> colorDialog vezérlő * * -> névterek jelentősége * * * * Katona József <katona.jozsef.duf@freemail.hu> * **************************************************************************************/ #ifndef TOOLSTRIPEXTRAS_H //if not define egy szimbólum nemlétét ellenőrzi #define TOOLSTRIPEXTRAS_H //egy szimbólum definiálása és értékének megadása //=================================================================================== namespace WFA_11 { //=================================================================================== ref class frmMain; //referencia hivatkozás az frmMain osztályra //=================================================================================== ref class ToolStripExtras //=================================================================================== { private:

237

frmMain^ mainfrm; //a form tárolóvezérlő public: ToolStripExtras(frmMain^ frm); //konstruktor void SelectFont(); //betű típus megváltozatás void SelectColorFont(); //betű színének megváltoztatása void SelectBoldFont(); //félkövér betűtípus beállítása void SelectItalicFont(); //dőlt betűtípus beállítása void SelectUnderlineFont(); //aláhúzott betűtípus beállítása }; } #endif

ToolStripExtras osztály implementálása (ToolStripExtras.cpp)

/************************************************************************************ * ToolStripExtras osztály implementálása * * Demonstrációs célok: * * -> richTextBox vezérlő * * -> openFileDialog vezérlő * * -> saveFileDialog vezérlő * * -> printDialog vezérlő * * -> printDocument vezérlő * * -> fontDialog vezérlő * * -> printPreviewDialog vezérlő * * -> menuStrip vezérlő * * -> toolStrip vezérlő * * -> colorDialog vezérlő * * -> névterek jelentősége * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #include "StdAfx.h" //precompiled header #include "ToolStripExtras.h" //FajlMenu deklarációi #include "frmMain.h" //frmMain deklarációi //=================================================================================== namespace WFA_11 { //=================================================================================== //----------------------------------------------------------------------------------- ToolStripExtras::ToolStripExtras(frmMain^ frm) //----------------------------------------------------------------------------------- { this->mainfrm = frm; //az osztály adattagjának az inicializálása } //----------------------------------------------------------------------------------- void ToolStripExtras::SelectFont() //----------------------------------------------------------------------------------- { try { //ha a kiválaszott betű nem mutat null értékre if(!(mainfrm->richTextBox1->SelectionFont == nullptr)) //a betű dialógus betűtípusa legyen egyenlő a //szövegmezőben szereplő kiválasztott betűtípussal mainfrm->fontDialog1->Font = mainfrm->richTextBox1->SelectionFont; else //a betű dialógis betűtípusa legyen egyenlő null értékkel mainfrm->fontDialog1->Font = nullptr; mainfrm->fontDialog1->ShowApply = true; if(mainfrm->fontDialog1->ShowDialog() == DialogResult::OK)

238

//a kiválaszott betűtípus engedélyezése a szövegmezőben mainfrm->richTextBox1->SelectionFont = mainfrm->fontDialog1->Font; } catch (Exception^ ex) { MessageBox::Show(ex->Message, "Hiba"); } } //----------------------------------------------------------------------------------- void ToolStripExtras::SelectColorFont() //----------------------------------------------------------------------------------- { try { //a szín dialógusnak adjuk értékül a szövegmező színét mainfrm->colorDialog1->Color = mainfrm->richTextBox1->ForeColor; if(mainfrm->colorDialog1->ShowDialog() == DialogResult::OK) //Ha kiválasztottuk a szükséges színt, akkor a szín dialógusból adjuk értékül //a szövegmező színének mainfrm->richTextBox1->SelectionColor = mainfrm->colorDialog1->Color; } catch (Exception^ ex) { MessageBox::Show(ex->Message, "Hiba"); } } //----------------------------------------------------------------------------------- void ToolStripExtras::SelectBoldFont() //----------------------------------------------------------------------------------- { try { //amennyiben a kiválasztott betű nem null értékű if (!(mainfrm->richTextBox1->SelectionFont == nullptr)) { //hozzunk létre egy átmeneti betűtípust Font^ currentFont = mainfrm->richTextBox1->SelectionFont; //hozzunk létre egy új betűttípust FontStyle newFontStyle; //ha a kiválasztott betűtípus félkövér if(mainfrm->richTextBox1->SelectionFont->Bold == true) newFontStyle = FontStyle::Regular; else newFontStyle = FontStyle::Bold; //az új betűstílus beállítása mainfrm->richTextBox1->SelectionFont = gcnew Font(currentFont->FontFamily, currentFont->Size, newFontStyle); } } catch (Exception^ ex) { MessageBox::Show(ex->Message, "Hiba"); } } //----------------------------------------------------------------------------------- void ToolStripExtras::SelectItalicFont() //----------------------------------------------------------------------------------- { try { //amennyiben a kiválasztott betű nem null értékű

239

if (!(mainfrm->richTextBox1->SelectionFont == nullptr)) { //hozzunk létre egy átmeneti betűtípust Font^ currentFont = mainfrm->richTextBox1->SelectionFont; //hozzunk létre egy új betűttípust FontStyle newFontStyle; //ha a kiválasztott betűtípus dőlt if(mainfrm->richTextBox1->SelectionFont->Italic == true) newFontStyle = FontStyle::Regular; else newFontStyle = FontStyle::Italic; //az új betűstílus beállítása mainfrm->richTextBox1->SelectionFont = gcnew Font(currentFont->FontFamily, currentFont->Size, newFontStyle); } } catch (Exception^ ex) { MessageBox::Show(ex->Message, "Hiba"); } } //----------------------------------------------------------------------------------- void ToolStripExtras::SelectUnderlineFont() //----------------------------------------------------------------------------------- { try { //amennyiben a kiválasztott betű nem null értékű if (!(mainfrm->richTextBox1->SelectionFont == nullptr)) { //hozzunk létre egy átmeneti betűtípust Font^ currentFont = mainfrm->richTextBox1->SelectionFont; //hozzunk létre egy új betűttípust FontStyle newFontStyle; //ha a kiválasztott betűtípus dőlt if(mainfrm->richTextBox1->SelectionFont->Underline == true) newFontStyle = FontStyle::Regular; else newFontStyle = FontStyle::Underline; //az új betűstílus beállítása mainfrm->richTextBox1->SelectionFont = gcnew Font(currentFont->FontFamily, currentFont->Size, newFontStyle); } } catch (Exception^ ex) { MessageBox::Show(ex->Message, "Hiba"); } } }

frmMain osztály deklarációi, defíniciói és eseménykezelései (frmMain.h)

/***************************************************************************************************** * frmMain osztály deklarálációi és eseménykezelései * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> mesterséges intelligencia alkalmazása 3x3 amőbában * * *

240

* Katona József <katona.jozsef.duf@freemail.hu> * ******************************************************************************************************/ #pragma once //előfordító direktíva (nem szabványos!) #include "Mod1.h" //Mod1 osztály deklarációi #include "Mod2.h" //Mod2 osztály deklarációi #include "Mod3.h" //Mod3 osztály deklarációi #include "Rule.h" //Rule ablak deklarációi #include "Nevjegy.h" //Nevjegy ablak deklarációi //=================================================================================================== namespace WFA_12 { //=================================================================================================== using namespace System; using namespace System::ComponentModel; using namespace System::Collections; using namespace System::Windows::Forms; using namespace System::Data; using namespace System::Drawing; /// <summary> /// Summary for Form1 /// </summary> public ref class frmMain : public System::Windows::Forms::Form { public: frmMain(void) { InitializeComponent(); // //TODO: Add the constructor code here // } protected: /// <summary> /// Clean up any resources being used. /// </summary> ~frmMain() { if (components) { delete components; } } public: System::Windows::Forms::MenuStrip^ menuStrip1; public: System::Windows::Forms::ToolStripMenuItem^ fájlToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ újJátákToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ nehézségiSzintToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ könnyűToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ normálToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ ellenfélToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ számítógépToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ emberToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ kilépésToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ helpToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ játékszabályToolStripMenuItem; public: System::Windows::Forms::Panel^ panel1; public: System::Windows::Forms::Button^ btnBottomRight; public: System::Windows::Forms::Button^ btnMiddleRight; public: System::Windows::Forms::Button^ btnTopRight; public: System::Windows::Forms::Button^ btnBottomMiddle; public: System::Windows::Forms::Button^ btnMiddleMiddle; public: System::Windows::Forms::Button^ btnTopMiddle; public: System::Windows::Forms::Button^ btnBottomLeft; public: System::Windows::Forms::Button^ btnMiddleLeft; public: System::Windows::Forms::Button^ btnTopLeft; public: System::Windows::Forms::Button^ btnExit;

241

public: System::Windows::Forms::Button^ btnNewGame; public: System::Windows::Forms::GroupBox^ groupBox1; public: System::Windows::Forms::RadioButton^ rbtnEmber; public: System::Windows::Forms::RadioButton^ rbtnSzamitogep; public: System::Windows::Forms::GroupBox^ groupBox2; public: System::Windows::Forms::RadioButton^ rbtnNormal; public: System::Windows::Forms::RadioButton^ rbtnKönnyű; public: System::Windows::Forms::Label^ label1; public: System::Windows::Forms::GroupBox^ groupBox3; public: System::Windows::Forms::Label^ lblOPontszam; public: System::Windows::Forms::Label^ lblXPontszam; public: System::Windows::Forms::Label^ label3; public: System::Windows::Forms::Label^ label2; public: System::Windows::Forms::Button^ btnKövetkező; public: System::Windows::Forms::ToolTip^ toolTip1; private: System::Windows::Forms::ToolStripMenuItem^ névjegyToolStripMenuItem; private: System::ComponentModel::IContainer^ components; /// <summary> /// Required designer variable. /// </summary> #pragma region Windows Form Designer generated code /// <summary> /// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// </summary> void InitializeComponent(void) { this->components = (gcnew System::ComponentModel::Container()); System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(frmMain::typeid)); this->menuStrip1 = (gcnew System::Windows::Forms::MenuStrip()); this->fájlToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->újJátákToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->nehézségiSzintToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->könnyűToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->normálToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->ellenfélToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->számítógépToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->emberToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->kilépésToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->helpToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->játékszabályToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->névjegyToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->panel1 = (gcnew System::Windows::Forms::Panel()); this->btnBottomRight = (gcnew System::Windows::Forms::Button()); this->btnMiddleRight = (gcnew System::Windows::Forms::Button()); this->btnTopRight = (gcnew System::Windows::Forms::Button()); this->btnBottomMiddle = (gcnew System::Windows::Forms::Button()); this->btnMiddleMiddle = (gcnew System::Windows::Forms::Button()); this->btnTopMiddle = (gcnew System::Windows::Forms::Button()); this->btnBottomLeft = (gcnew System::Windows::Forms::Button()); this->btnMiddleLeft = (gcnew System::Windows::Forms::Button()); this->btnTopLeft = (gcnew System::Windows::Forms::Button()); this->btnExit = (gcnew System::Windows::Forms::Button()); this->btnNewGame = (gcnew System::Windows::Forms::Button()); this->groupBox1 = (gcnew System::Windows::Forms::GroupBox()); this->rbtnEmber = (gcnew System::Windows::Forms::RadioButton()); this->rbtnSzamitogep = (gcnew System::Windows::Forms::RadioButton()); this->groupBox2 = (gcnew System::Windows::Forms::GroupBox()); this->rbtnNormal = (gcnew System::Windows::Forms::RadioButton()); this->rbtnKönnyű = (gcnew System::Windows::Forms::RadioButton()); this->label1 = (gcnew System::Windows::Forms::Label()); this->groupBox3 = (gcnew System::Windows::Forms::GroupBox()); this->btnKövetkező = (gcnew System::Windows::Forms::Button()); this->lblOPontszam = (gcnew System::Windows::Forms::Label()); this->lblXPontszam = (gcnew System::Windows::Forms::Label()); this->label3 = (gcnew System::Windows::Forms::Label());

242

this->label2 = (gcnew System::Windows::Forms::Label()); this->toolTip1 = (gcnew System::Windows::Forms::ToolTip(this->components)); this->menuStrip1->SuspendLayout(); this->panel1->SuspendLayout(); this->groupBox1->SuspendLayout(); this->groupBox2->SuspendLayout(); this->groupBox3->SuspendLayout(); this->SuspendLayout(); // // menuStrip1 // this->menuStrip1->Items->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) {this->fájlToolStripMenuItem, this->helpToolStripMenuItem}); this->menuStrip1->Location = System::Drawing::Point(0, 0); this->menuStrip1->Name = L"menuStrip1"; this->menuStrip1->Size = System::Drawing::Size(444, 24); this->menuStrip1->TabIndex = 0; this->menuStrip1->Text = L"menuStrip1"; // // fájlToolStripMenuItem // this->fájlToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(4) {this->újJátákToolStripMenuItem, this->nehézségiSzintToolStripMenuItem, this->ellenfélToolStripMenuItem, this->kilépésToolStripMenuItem}); this->fájlToolStripMenuItem->Name = L"fájlToolStripMenuItem"; this->fájlToolStripMenuItem->Size = System::Drawing::Size(37, 20); this->fájlToolStripMenuItem->Text = L"Fájl"; // // újJátákToolStripMenuItem // this->újJátákToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"újJátákToolStripMenuItem.Image"))); this->újJátákToolStripMenuItem->Name = L"újJátákToolStripMenuItem"; this->újJátákToolStripMenuItem->Size = System::Drawing::Size(155, 22); this->újJátákToolStripMenuItem->Text = L"Új játék"; this->újJátákToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::újJátákToolStripMenuItem_Click); // // nehézségiSzintToolStripMenuItem // this->nehézségiSzintToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) {this->könnyűToolStripMenuItem, this->normálToolStripMenuItem}); this->nehézségiSzintToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"nehézségiSzintToolStripMenuItem.Image"))); this->nehézségiSzintToolStripMenuItem->Name = L"nehézségiSzintToolStripMenuItem"; this->nehézségiSzintToolStripMenuItem->Size = System::Drawing::Size(155, 22); this->nehézségiSzintToolStripMenuItem->Text = L"Nehézségi szint"; // // könnyűToolStripMenuItem // this->könnyűToolStripMenuItem->Name = L"könnyűToolStripMenuItem"; this->könnyűToolStripMenuItem->Size = System::Drawing::Size(115, 22); this->könnyűToolStripMenuItem->Text = L"Könnyű"; this->könnyűToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::könnyűToolStripMenuItem_Click); // // normálToolStripMenuItem // this->normálToolStripMenuItem->Checked = true; this->normálToolStripMenuItem->CheckState = System::Windows::Forms::CheckState::Checked; this->normálToolStripMenuItem->Name = L"normálToolStripMenuItem"; this->normálToolStripMenuItem->Size = System::Drawing::Size(115, 22); this->normálToolStripMenuItem->Text = L"Normál"; this->normálToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::normálToolStripMenuItem_Click); //

243

// ellenfélToolStripMenuItem // this->ellenfélToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) {this->számítógépToolStripMenuItem, this->emberToolStripMenuItem}); this->ellenfélToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"ellenfélToolStripMenuItem.Image"))); this->ellenfélToolStripMenuItem->Name = L"ellenfélToolStripMenuItem"; this->ellenfélToolStripMenuItem->Size = System::Drawing::Size(155, 22); this->ellenfélToolStripMenuItem->Text = L"Ellenfél"; // // számítógépToolStripMenuItem // this->számítógépToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"számítógépToolStripMenuItem.Image"))); this->számítógépToolStripMenuItem->Name = L"számítógépToolStripMenuItem"; this->számítógépToolStripMenuItem->Size = System::Drawing::Size(136, 22); this->számítógépToolStripMenuItem->Text = L"Számítógép"; this->számítógépToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::számítógépToolStripMenuItem_Click); // // emberToolStripMenuItem // this->emberToolStripMenuItem->Checked = true; this->emberToolStripMenuItem->CheckState = System::Windows::Forms::CheckState::Checked; this->emberToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"emberToolStripMenuItem.Image"))); this->emberToolStripMenuItem->Name = L"emberToolStripMenuItem"; this->emberToolStripMenuItem->Size = System::Drawing::Size(136, 22); this->emberToolStripMenuItem->Text = L"Ember"; this->emberToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::emberToolStripMenuItem_Click); // // kilépésToolStripMenuItem // this->kilépésToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"kilépésToolStripMenuItem.Image"))); this->kilépésToolStripMenuItem->Name = L"kilépésToolStripMenuItem"; this->kilépésToolStripMenuItem->Size = System::Drawing::Size(155, 22); this->kilépésToolStripMenuItem->Text = L"Kilépés"; this->kilépésToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::kilépésToolStripMenuItem_Click); // // helpToolStripMenuItem // this->helpToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) {this->játékszabályToolStripMenuItem, this->névjegyToolStripMenuItem}); this->helpToolStripMenuItem->Name = L"helpToolStripMenuItem"; this->helpToolStripMenuItem->Size = System::Drawing::Size(46, 20); this->helpToolStripMenuItem->Text = L"Súgó"; // // játékszabályToolStripMenuItem // this->játékszabályToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"játékszabályToolStripMenuItem.Image"))); this->játékszabályToolStripMenuItem->Name = L"játékszabályToolStripMenuItem"; this->játékszabályToolStripMenuItem->Size = System::Drawing::Size(138, 22); this->játékszabályToolStripMenuItem->Text = L"Játékszabály"; this->játékszabályToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::játékszabályToolStripMenuItem_Click); // // névjegyToolStripMenuItem // this->névjegyToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"névjegyToolStripMenuItem.Image"))); this->névjegyToolStripMenuItem->Name = L"névjegyToolStripMenuItem"; this->névjegyToolStripMenuItem->Size = System::Drawing::Size(138, 22); this->névjegyToolStripMenuItem->Text = L"Névjegy";

244

this->névjegyToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::névjegyToolStripMenuItem_Click); // // panel1 // this->panel1->BackColor = System::Drawing::Color::Black; this->panel1->Controls->Add(this->btnBottomRight); this->panel1->Controls->Add(this->btnMiddleRight); this->panel1->Controls->Add(this->btnTopRight); this->panel1->Controls->Add(this->btnBottomMiddle); this->panel1->Controls->Add(this->btnMiddleMiddle); this->panel1->Controls->Add(this->btnTopMiddle); this->panel1->Controls->Add(this->btnBottomLeft); this->panel1->Controls->Add(this->btnMiddleLeft); this->panel1->Controls->Add(this->btnTopLeft); this->panel1->Location = System::Drawing::Point(12, 78); this->panel1->Name = L"panel1"; this->panel1->Size = System::Drawing::Size(291, 291); this->panel1->TabIndex = 1; // // btnBottomRight // this->btnBottomRight->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnBottomRight->Location = System::Drawing::Point(196, 196); this->btnBottomRight->Name = L"btnBottomRight"; this->btnBottomRight->Size = System::Drawing::Size(90, 90); this->btnBottomRight->TabIndex = 8; this->btnBottomRight->UseVisualStyleBackColor = true; this->btnBottomRight->Click += gcnew System::EventHandler(this, &frmMain::btnBottomRight_Click); // // btnMiddleRight // this->btnMiddleRight->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnMiddleRight->Location = System::Drawing::Point(196, 100); this->btnMiddleRight->Name = L"btnMiddleRight"; this->btnMiddleRight->Size = System::Drawing::Size(90, 90); this->btnMiddleRight->TabIndex = 7; this->btnMiddleRight->UseVisualStyleBackColor = true; this->btnMiddleRight->Click += gcnew System::EventHandler(this, &frmMain::btnMiddleRight_Click); // // btnTopRight // this->btnTopRight->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnTopRight->Location = System::Drawing::Point(196, 4); this->btnTopRight->Name = L"btnTopRight"; this->btnTopRight->Size = System::Drawing::Size(90, 90); this->btnTopRight->TabIndex = 6; this->btnTopRight->UseVisualStyleBackColor = true; this->btnTopRight->Click += gcnew System::EventHandler(this, &frmMain::btnTopRight_Click); // // btnBottomMiddle // this->btnBottomMiddle->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnBottomMiddle->Location = System::Drawing::Point(100, 196); this->btnBottomMiddle->Name = L"btnBottomMiddle"; this->btnBottomMiddle->Size = System::Drawing::Size(90, 90); this->btnBottomMiddle->TabIndex = 5; this->btnBottomMiddle->UseVisualStyleBackColor = true;

245

this->btnBottomMiddle->Click += gcnew System::EventHandler(this, &frmMain::btnBottomMiddle_Click); // // btnMiddleMiddle // this->btnMiddleMiddle->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnMiddleMiddle->Location = System::Drawing::Point(100, 100); this->btnMiddleMiddle->Name = L"btnMiddleMiddle"; this->btnMiddleMiddle->Size = System::Drawing::Size(90, 90); this->btnMiddleMiddle->TabIndex = 4; this->btnMiddleMiddle->UseVisualStyleBackColor = true; this->btnMiddleMiddle->Click += gcnew System::EventHandler(this, &frmMain::btnMiddleMiddle_Click); // // btnTopMiddle // this->btnTopMiddle->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnTopMiddle->Location = System::Drawing::Point(100, 4); this->btnTopMiddle->Name = L"btnTopMiddle"; this->btnTopMiddle->Size = System::Drawing::Size(90, 90); this->btnTopMiddle->TabIndex = 3; this->btnTopMiddle->UseVisualStyleBackColor = true; this->btnTopMiddle->Click += gcnew System::EventHandler(this, &frmMain::btnTopMiddle_Click); // // btnBottomLeft // this->btnBottomLeft->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnBottomLeft->Location = System::Drawing::Point(4, 196); this->btnBottomLeft->Name = L"btnBottomLeft"; this->btnBottomLeft->Size = System::Drawing::Size(90, 90); this->btnBottomLeft->TabIndex = 2; this->btnBottomLeft->UseVisualStyleBackColor = true; this->btnBottomLeft->Click += gcnew System::EventHandler(this, &frmMain::btnBottomLeft_Click); // // btnMiddleLeft // this->btnMiddleLeft->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnMiddleLeft->Location = System::Drawing::Point(4, 100); this->btnMiddleLeft->Name = L"btnMiddleLeft"; this->btnMiddleLeft->Size = System::Drawing::Size(90, 90); this->btnMiddleLeft->TabIndex = 1; this->btnMiddleLeft->UseVisualStyleBackColor = true; this->btnMiddleLeft->Click += gcnew System::EventHandler(this, &frmMain::btnMiddleLeft_Click); // // btnTopLeft // this->btnTopLeft->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnTopLeft->Location = System::Drawing::Point(4, 4); this->btnTopLeft->Name = L"btnTopLeft"; this->btnTopLeft->Size = System::Drawing::Size(90, 90); this->btnTopLeft->TabIndex = 0; this->btnTopLeft->UseVisualStyleBackColor = true; this->btnTopLeft->Click += gcnew System::EventHandler(this, &frmMain::btnTopLeft_Click); // // btnExit //

246

this->btnExit->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 8.25F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->btnExit->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"btnExit.Image"))); this->btnExit->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft; this->btnExit->Location = System::Drawing::Point(309, 336); this->btnExit->Name = L"btnExit"; this->btnExit->Size = System::Drawing::Size(126, 47); this->btnExit->TabIndex = 2; this->btnExit->Text = L"Kilépés "; this->btnExit->TextAlign = System::Drawing::ContentAlignment::MiddleRight; this->btnExit->UseVisualStyleBackColor = true; this->btnExit->Click += gcnew System::EventHandler(this, &frmMain::btnExit_Click); // // btnNewGame // this->btnNewGame->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 8.25F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->btnNewGame->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"btnNewGame.Image"))); this-btnNewGame->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft; this->btnNewGame->Location = System::Drawing::Point(309, 285); this->btnNewGame->Name = L"btnNewGame"; this->btnNewGame->Size = System::Drawing::Size(126, 47); this->btnNewGame->TabIndex = 3; this->btnNewGame->Text = L"Új Játék "; this->btnNewGame->TextAlign = System::Drawing::ContentAlignment::MiddleRight; this->btnNewGame->UseVisualStyleBackColor = true; this->btnNewGame->Click += gcnew System::EventHandler(this, &frmMain::btnNewGame_Click); // // groupBox1 // this->groupBox1->Controls->Add(this->rbtnEmber); this->groupBox1->Controls->Add(this->rbtnSzamitogep); this->groupBox1->ForeColor = System::Drawing::Color::Blue; this->groupBox1->Location = System::Drawing::Point(309, 209); this->groupBox1->Name = L"groupBox1"; this->groupBox1->Size = System::Drawing::Size(126, 67); this->groupBox1->TabIndex = 4; this->groupBox1->TabStop = false; this->groupBox1->Text = L"Ellenfél"; // // rbtnEmber // this->rbtnEmber->AutoSize = true; this->rbtnEmber->Checked = true; this->rbtnEmber->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->rbtnEmber->ForeColor = System::Drawing::SystemColors::InfoText; this->rbtnEmber->Location = System::Drawing::Point(6, 42); this->rbtnEmber->Name = L"rbtnEmber"; this->rbtnEmber->Size = System::Drawing::Size(61, 23); this->rbtnEmber->TabIndex = 1; this->rbtnEmber->TabStop = true; this->rbtnEmber->Text = L"Ember"; this->rbtnEmber->UseVisualStyleBackColor = true; this->rbtnEmber->CheckedChanged += gcnew System::EventHandler(this, &frmMain::rbtnEmber_CheckedChanged); // // rbtnSzamitogep // this->rbtnSzamitogep->AutoSize = true; this->rbtnSzamitogep->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->rbtnSzamitogep->ForeColor = System::Drawing::SystemColors::InfoText;

247

this->rbtnSzamitogep->Location = System::Drawing::Point(6, 19); this->rbtnSzamitogep->Name = L"rbtnSzamitogep"; this->rbtnSzamitogep->Size = System::Drawing::Size(91, 23); this->rbtnSzamitogep->TabIndex = 0; this->rbtnSzamitogep->Text = L"Számítógép"; this->rbtnSzamitogep->UseVisualStyleBackColor = true; // // groupBox2 // this->groupBox2->Controls->Add(this->rbtnNormal); this->groupBox2->Controls->Add(this->rbtnKönnyű); this->groupBox2->ForeColor = System::Drawing::Color::Blue; this->groupBox2->Location = System::Drawing::Point(309, 129); this->groupBox2->Name = L"groupBox2"; this->groupBox2->Size = System::Drawing::Size(126, 67); this->groupBox2->TabIndex = 5; this->groupBox2->TabStop = false; this->groupBox2->Text = L"Nehézségi szint"; // // rbtnNormal // this->rbtnNormal->AutoSize = true; this->rbtnNormal->Checked = true; this->rbtnNormal->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->rbtnNormal->ForeColor = System::Drawing::SystemColors::InfoText; this->rbtnNormal->Location = System::Drawing::Point(6, 42); this->rbtnNormal->Name = L"rbtnNormal"; this->rbtnNormal->Size = System::Drawing::Size(70, 23); this->rbtnNormal->TabIndex = 1; this->rbtnNormal->TabStop = true; this->rbtnNormal->Text = L"Normál"; this->rbtnNormal->UseVisualStyleBackColor = true; // // rbtnKönnyű // this->rbtnKönnyű->AutoSize = true; this->rbtnKönnyű->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 9, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->rbtnKönnyű->ForeColor = System::Drawing::SystemColors::InfoText; this->rbtnKönnyű->Location = System::Drawing::Point(6, 19); this->rbtnKönnyű->Name = L"rbtnKönnyű"; this->rbtnKönnyű->Size = System::Drawing::Size(74, 23); this->rbtnKönnyű->TabIndex = 0; this->rbtnKönnyű->Text = L"Könnyű"; this->rbtnKönnyű->UseVisualStyleBackColor = true; this->rbtnKönnyű->CheckedChanged += gcnew System::EventHandler(this, &frmMain::rbtnKönnyű_CheckedChanged); // // label1 // this->label1->AutoSize = true; this->label1->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 21.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->label1->Location = System::Drawing::Point(71, 31); this->label1->Name = L"label1"; this->label1->Size = System::Drawing::Size(186, 47); this->label1->TabIndex = 6; this->label1->Text = L"Tic-Tac-Toe"; // // groupBox3 // this->groupBox3->Controls->Add(this->btnKövetkező); this->groupBox3->Controls->Add(this->lblOPontszam); this->groupBox3->Controls->Add(this->lblXPontszam); this->groupBox3->Controls->Add(this->label3);

248

this->groupBox3->Controls->Add(this->label2); this->groupBox3->ForeColor = System::Drawing::Color::Blue; this->groupBox3->Location = System::Drawing::Point(309, 55); this->groupBox3->Name = L"groupBox3"; this->groupBox3->Size = System::Drawing::Size(126, 67); this->groupBox3->TabIndex = 6; this->groupBox3->TabStop = false; this->groupBox3->Text = L"Pontszámok"; // // btnKövetkező // this->btnKövetkező->FlatStyle = System::Windows::Forms::FlatStyle::Flat; this->btnKövetkező->Font = (gcnew System::Drawing::Font(L"Microsoft Sans Serif", 20.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->btnKövetkező->ForeColor = System::Drawing::Color::Black; this->btnKövetkező->Location = System::Drawing::Point(82, 16); this->btnKövetkező->Name = L"btnKövetkező"; this->btnKövetkező->Size = System::Drawing::Size(38, 38); this->btnKövetkező->TabIndex = 7; this->btnKövetkező->TabStop = false; this->btnKövetkező->Text = L"X"; this->btnKövetkező->UseVisualStyleBackColor = true; // // lblOPontszam // this->lblOPontszam->AutoSize = true; this->lblOPontszam->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 9.75F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->lblOPontszam->ForeColor = System::Drawing::SystemColors::ControlText; this->lblOPontszam->Location = System::Drawing::Point(31, 40); this->lblOPontszam->Name = L"lblOPontszam"; this->lblOPontszam->Size = System::Drawing::Size(16, 21); this->lblOPontszam->TabIndex = 3; this->lblOPontszam->Text = L"0"; // // lblXPontszam // this->lblXPontszam->AutoSize = true; this->lblXPontszam->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 9.75F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->lblXPontszam->ForeColor = System::Drawing::SystemColors::ControlText; this->lblXPontszam->Location = System::Drawing::Point(31, 20); this->lblXPontszam->Name = L"lblXPontszam"; this->lblXPontszam->Size = System::Drawing::Size(16, 21); this->lblXPontszam->TabIndex = 2; this->lblXPontszam->Text = L"0"; // // label3 // this->label3->AutoSize = true; this->label3->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 9.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->label3->ForeColor = System::Drawing::SystemColors::ControlText; this->label3->Location = System::Drawing::Point(7, 40); this->label3->Name = L"label3"; this->label3->Size = System::Drawing::Size(22, 21); this->label3->TabIndex = 1; this->label3->Text = L"O:"; // // label2 // this->label2->AutoSize = true; this->label2->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 9.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0)));

249

this->label2->ForeColor = System::Drawing::SystemColors::ControlText; this->label2->Location = System::Drawing::Point(7, 20); this->label2->Name = L"label2"; this->label2->Size = System::Drawing::Size(24, 21); this->label2->TabIndex = 0; this->label2->Text = L"X:"; // // toolTip1 // this->toolTip1->ShowAlways = true; this->toolTip1->ToolTipIcon = System::Windows::Forms::ToolTipIcon::Info; // // frmMain // this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; this->ClientSize = System::Drawing::Size(444, 385); this->Controls->Add(this->groupBox3); this->Controls->Add(this->label1); this->Controls->Add(this->groupBox2); this->Controls->Add(this->groupBox1); this->Controls->Add(this->btnNewGame); this->Controls->Add(this->btnExit); this->Controls->Add(this->panel1); this->Controls->Add(this->menuStrip1); this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::Fixed3D; this->Icon = (cli::safe_cast<System::Drawing::Icon^ >(resources->GetObject(L"$this.Icon"))); this->MainMenuStrip = this->menuStrip1; this->MaximizeBox = false; this->Name = L"frmMain"; this->StartPosition = System::Windows::Forms::FormStartPosition::CenterScreen; this->Text = L"WFA_12"; this->Load += gcnew System::EventHandler(this, &frmMain::frmMain_Load); this->menuStrip1->ResumeLayout(false); this->menuStrip1->PerformLayout(); this->panel1->ResumeLayout(false); this->groupBox1->ResumeLayout(false); this->groupBox1->PerformLayout(); this->groupBox2->ResumeLayout(false); this->groupBox2->PerformLayout(); this->groupBox3->ResumeLayout(false); this->groupBox3->PerformLayout(); this->ResumeLayout(false); this->PerformLayout(); } #pragma endregion Mod1^ mod1Obj; //Mod1 osztály példány deklarálása Mod2^ mod2Obj; //Mod2 osztály példány deklarálása Mod3^ mod3Obj; //Mod3 osztály példány deklarálása #pragma region Windows Ablak betöltődésének az eseménykezelése //-------------------------------------------------------------------------------------------------- private: System::Void frmMain_Load(System::Object^ sender, System::EventArgs^ e) //-------------------------------------------------------------------------------------------------- { //a súgó vezérlő beállítása toolTip1->SetToolTip(btnKövetkező, "Aktuális játékos lép!"); mod1Obj = gcnew Mod1(this); //a Mod1 osztály objektumpéldány inicializálása mod2Obj = gcnew Mod2(this); //a Mod2 osztály objektumpéldány inicializálása mod3Obj = gcnew Mod3(this); //a Mod3 osztály objektumpéldány inicializálása //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { mod1Obj->SetVezerlo();

250

mod1Obj->SetAdatok(); } //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { mod2Obj->SetVezerlo(); mod2Obj->SetAdatok(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { mod3Obj->SetVezerlo(); mod3Obj->SetAdatok(); } } } #pragma endregion #pragma region A játék újraindításának az eseménykezelése //------------------------------------------------------------------------------------------------- private: System::Void btnNewGame_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) mod1Obj->ResetGame(); //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) mod2Obj->ResetGame(); //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) mod3Obj->ResetGame(); } } //------------------------------------------------------------------------------------------------ private: System::Void újJátákToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------ { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) mod1Obj->ResetGame(); //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) mod2Obj->ResetGame(); //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) mod3Obj->ResetGame(); } } #pragma endregion

251

#pragma region A gombok kattintásainak az esemény kezelése //------------------------------------------------------------------------------------------------- private: System::Void btnTopLeft_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnTopLeft->Text = mod1Obj->SetText(btnTopLeft->Text); //ha már egy gombot egyszer kiválasztottak, akkor letiltjuk btnTopLeft->Enabled = false; //a játék végének ellenőrzése mod1Obj->CheckEndGame(btnTopLeft->Text); } //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnTopLeft->Text = mod2Obj->SetText(btnTopLeft->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnTopLeft->Enabled = false; //a játék végének ellenőrzése mod2Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod2Obj->ArrayFeltolt(btnTopLeft->Text,1); //a gép által kiválaszott gomb beállítása mod2Obj->SetGomb(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnTopLeft->Text = mod3Obj->SetText(btnTopLeft->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnTopLeft->Enabled = false; //a játék végének ellenőrzése mod3Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod3Obj->ArrayFeltolt(btnTopLeft->Text,1); //a gép által kiválaszott gomb beállítása mod3Obj->SetGomb(); } } } //------------------------------------------------------------------------------------------------- private: System::Void btnTopMiddle_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnTopMiddle->Text = mod1Obj->SetText(btnTopMiddle->Text); //ha már egy gombot egyszer kiválasztottak, akkor letiltjuk btnTopMiddle->Enabled = false; //a játék végének ellenőrzése mod1Obj->CheckEndGame(btnTopMiddle->Text); } //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) {

252

//ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnTopMiddle->Text = mod2Obj->SetText(btnTopMiddle->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnTopMiddle->Enabled = false; //a játék végének ellenőrzése mod2Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod2Obj->ArrayFeltolt(btnTopMiddle->Text,2); //a gép által kiválaszott gomb beállítása mod2Obj->SetGomb(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnTopMiddle->Text = mod3Obj->SetText(btnTopMiddle->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnTopMiddle->Enabled = false; //a játék végének ellenőrzése mod3Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod3Obj->ArrayFeltolt(btnTopMiddle->Text,2); //a gép által kiválaszott gomb beállítása mod3Obj->SetGomb(); } } } //------------------------------------------------------------------------------------------------- private: System::Void btnTopRight_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnTopRight->Text = mod1Obj->SetText(btnTopRight->Text); //ha már egy gombot egyszer kiválasztottak, akkor letiltjuk btnTopRight->Enabled = false; //a játék végének ellenőrzése mod1Obj->CheckEndGame(btnTopRight->Text); } //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnTopRight->Text = mod2Obj->SetText(btnTopRight->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnTopRight->Enabled = false; //a játék végének ellenőrzése mod2Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod2Obj->ArrayFeltolt(btnTopRight->Text,3); //a gép által kiválaszott gomb beállítása mod2Obj->SetGomb(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) {

253

//a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnTopRight->Text = mod3Obj->SetText(btnTopRight->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnTopRight->Enabled = false; //a játék végének ellenőrzése mod3Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod3Obj->ArrayFeltolt(btnTopRight->Text,3); //a gép által kiválaszott gomb beállítása mod3Obj->SetGomb(); } } } //-------------------------------------------------------------------------------------------------- private: System::Void btnMiddleLeft_Click(System::Object^ sender, System::EventArgs^ e) //-------------------------------------------------------------------------------------------------- { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnMiddleLeft->Text = mod1Obj->SetText(btnMiddleLeft->Text); //ha már egy gombot egyszer kiválasztottak, akkor letiltjuk btnMiddleLeft->Enabled = false; //a játék végének ellenőrzése mod1Obj->CheckEndGame(btnMiddleLeft->Text); } //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnMiddleLeft->Text = mod2Obj->SetText(btnMiddleLeft->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnMiddleLeft->Enabled = false; //a játék végének ellenőrzése mod2Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod2Obj->ArrayFeltolt(btnMiddleLeft->Text,4); //a gép által kiválaszott gomb beállítása mod2Obj->SetGomb(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnMiddleLeft->Text = mod3Obj->SetText(btnMiddleLeft->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnMiddleLeft->Enabled = false; //a játék végének ellenőrzése mod3Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod3Obj->ArrayFeltolt(btnMiddleLeft->Text,4); //a gép által kiválaszott gomb beállítása mod3Obj->SetGomb(); } } } //------------------------------------------------------------------------------------------------- private: System::Void btnMiddleMiddle_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true)

254

{ //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnMiddleMiddle->Text = mod1Obj->SetText(btnMiddleMiddle->Text); //ha már egy gombot egyszer kiválasztottak, akkor letiltjuk btnMiddleMiddle->Enabled = false; //a játék végének ellenőrzése mod1Obj->CheckEndGame(btnMiddleMiddle->Text); } //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnMiddleMiddle->Text = mod2Obj->SetText(btnMiddleMiddle->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnMiddleMiddle->Enabled = false; //a játék végének ellenőrzése mod2Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod2Obj->ArrayFeltolt(btnMiddleMiddle->Text,5); //a gép által kiválaszott gomb beállítása mod2Obj->SetGomb(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnMiddleMiddle->Text = mod3Obj->SetText(btnMiddleMiddle->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnMiddleMiddle->Enabled = false; //a játék végének ellenőrzése mod3Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod3Obj->ArrayFeltolt(btnMiddleMiddle->Text,5); //a gép által kiválaszott gomb beállítása mod3Obj->SetGomb(); } } } //------------------------------------------------------------------------------------------------ private: System::Void btnMiddleRight_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------ { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnMiddleRight->Text = mod1Obj->SetText(btnMiddleRight->Text); //ha már egy gombot egyszer kiválasztottak, akkor letiltjuk btnMiddleRight->Enabled = false; //a játék végének ellenőrzése mod1Obj->CheckEndGame(btnMiddleRight->Text); } //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnMiddleRight->Text = mod2Obj->SetText(btnMiddleRight->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk

255

btnMiddleRight->Enabled = false; //a játék végének ellenőrzése mod2Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod2Obj->ArrayFeltolt(btnMiddleRight->Text,6); //a gép által kiválaszott gomb beállítása mod2Obj->SetGomb(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnMiddleRight->Text = mod3Obj->SetText(btnMiddleRight->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnMiddleRight->Enabled = false; //a játék végének ellenőrzése mod3Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod3Obj->ArrayFeltolt(btnMiddleRight->Text,6); //a gép által kiválaszott gomb beállítása mod3Obj->SetGomb(); } } } //------------------------------------------------------------------------------------------------ private: System::Void btnBottomLeft_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------ { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnBottomLeft->Text = mod1Obj->SetText(btnBottomLeft->Text); //ha már egy gombot egyszer kiválasztottak, akkor letiltjuk btnBottomLeft->Enabled = false; //a játék végének ellenőrzése mod1Obj->CheckEndGame(btnBottomLeft->Text); } //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnBottomLeft->Text = mod2Obj->SetText(btnBottomLeft->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnBottomLeft->Enabled = false; //a játék végének ellenőrzése mod2Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod2Obj->ArrayFeltolt(btnBottomLeft->Text,7); //a gép által kiválaszott gomb beállítása mod2Obj->SetGomb(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnBottomLeft->Text = mod3Obj->SetText(btnBottomLeft->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnBottomLeft->Enabled = false; //a játék végének ellenőrzése mod3Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre

256

mod3Obj->ArrayFeltolt(btnBottomLeft->Text,7); //a gép által kiválaszott gomb beállítása mod3Obj->SetGomb(); } } } //------------------------------------------------------------------------------------------------- private: System::Void btnBottomMiddle_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnBottomMiddle->Text = mod1Obj->SetText(btnBottomMiddle->Text); //ha már egy gombot egyszer kiválasztottak, akkor letiltjuk btnBottomMiddle->Enabled = false; //a játék végének ellenőrzése mod1Obj->CheckEndGame(btnBottomMiddle->Text); } //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnBottomMiddle->Text = mod2Obj->SetText(btnBottomMiddle->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnBottomMiddle->Enabled = false; //a játék végének ellenőrzése mod2Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod2Obj->ArrayFeltolt(btnBottomMiddle->Text,8); //a gép által kiválaszott gomb beállítása mod2Obj->SetGomb(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnBottomMiddle->Text = mod3Obj->SetText(btnBottomMiddle->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnBottomMiddle->Enabled = false; //a játék végének ellenőrzése mod3Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod3Obj->ArrayFeltolt(btnBottomMiddle->Text,8); //a gép által kiválaszott gomb beállítása mod3Obj->SetGomb(); } } } //------------------------------------------------------------------------------------------------- private: System::Void btnBottomRight_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { //ha két játékos ember if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnBottomRight->Text = mod1Obj->SetText(btnBottomRight->Text); //ha már egy gombot egyszer kiválasztottak, akkor letiltjuk btnBottomRight->Enabled = false; //a játék végének ellenőrzése mod1Obj->CheckEndGame(btnBottomRight->Text);

257

} //ha az egyik játékos a számítógép else if(rbtnSzamitogep->Checked == true || számítógépToolStripMenuItem->Checked == true) { //ha a normál üzemmód van kiválasztva if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnBottomRight->Text = mod2Obj->SetText(btnBottomRight->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnBottomRight->Enabled = false; //a játék végének ellenőrzése mod2Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod2Obj->ArrayFeltolt(btnBottomRight->Text,9); //a gép által kiválaszott gomb beállítása mod2Obj->SetGomb(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { //a gomb szöveg tulajdonságának beállítása az adott játékos jelére btnBottomRight->Text = mod3Obj->SetText(btnBottomRight->Text); //ha már egy gombot egyszer kiválaszotttak, akkor letiltjuk btnBottomRight->Enabled = false; //a játék végének ellenőrzése mod3Obj->CheckEndGame("X"); //a jelek tároló tömb feltöltésem adott indexre mod3Obj->ArrayFeltolt(btnBottomRight->Text,9); //a gép által kiválaszott gomb beállítása mod3Obj->SetGomb(); } } } #pragma endregion #pragma region A játékból való kilépés esemény kezelése //------------------------------------------------------------------------------------------------ private: System::Void kilépésToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { Application::Exit(); } //------------------------------------------------------------------------------------------------ private: System::Void btnExit_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { Application::Exit(); } #pragma endregion #pragma region A játékmód váltására bekövetkezett események kezelése //------------------------------------------------------------------------------------------------- private: System::Void rbtnEmber_CheckedChanged(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { //ha a kiválaszott játékos az ember, akkor az ember játkoshoz //kapcsolódó vezérlők tulajdonságait kell beállítani if(rbtnEmber->Checked == true) { //játék újraindítása mod1Obj->ResetGame(); //pontszámok lenullázása mod1Obj->PontszamReset(); //vezérlők beállítása mod1Obj->SetVezerlo();

258

//adatok beállítása mod1Obj->SetAdatok(); } //ha a kiválaszott játékos nem ember, akkor a gép ellenfélhez kapcsolódó //vezérlők tulajdonságait kell beállítani else { //ha a normál üzemmód van kiválasztva, akkor a hozzá tartozó //vezérlők tulajdonságait be kell állítani if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true && rbtnNormal->Enabled == true) { //a játék újraindítása mod2Obj->ResetGame(); //pontszámok kinullázása mod2Obj->PontszamReset(); //a vezérlők beállítása mod2Obj->SetVezerlo(); //az adatok beállítása mod2Obj->SetAdatok(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true && rbtnKönnyű->Enabled == true) { //a játék újraindítása mod3Obj->ResetGame(); //pontszámok kinullázása mod3Obj->PontszamReset(); //a vezérlők beállítása mod3Obj->SetVezerlo(); //az adatok beállítása mod3Obj->SetAdatok(); } } } //------------------------------------------------------------------------------------------------ private: System::Void számítógépToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------ { emberToolStripMenuItem->Checked = false; számítógépToolStripMenuItem->Checked = true; if(rbtnNormal->Checked == true || normálToolStripMenuItem->Checked == true) { //a játék újraindítása mod2Obj->ResetGame(); //pontszámok kinullázása mod2Obj->PontszamReset(); //a vezérlők beállítása mod2Obj->SetVezerlo(); //az adatok beállítása mod2Obj->SetAdatok(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true || könnyűToolStripMenuItem->Checked == true) { //a játék újraindítása mod3Obj->ResetGame(); //pontszámok kinullázása mod3Obj->PontszamReset(); //a vezérlők beállítása mod3Obj->SetVezerlo(); //az adatok beállítása mod3Obj->SetAdatok(); }

259

} //------------------------------------------------------------------------------------------------- private: System::Void emberToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { emberToolStripMenuItem->Checked = true; számítógépToolStripMenuItem->Checked = false; if(rbtnEmber->Checked == true || emberToolStripMenuItem->Checked == true) { //játék újraindítása mod1Obj->ResetGame(); //pontszámok lenullázása mod1Obj->PontszamReset(); //vezérlők beállítása mod1Obj->SetVezerlo(); //adatok beállítása mod1Obj->SetAdatok(); } } //------------------------------------------------------------------------------------------------- private: System::Void könnyűToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------- { könnyűToolStripMenuItem->Checked = true; normálToolStripMenuItem->Checked = false; //a játék újraindítása mod3Obj->ResetGame(); //pontszámok kinullázása mod3Obj->PontszamReset(); //a vezérlők beállítása mod3Obj->SetVezerlo(); //az adatok beállítása mod3Obj->SetAdatok(); } //------------------------------------------------------------------------------------------------ private: System::Void normálToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------ { könnyűToolStripMenuItem->Checked = false; normálToolStripMenuItem->Checked = true; //a játék újraindítása mod2Obj->ResetGame(); //pontszámok kinullázása mod2Obj->PontszamReset(); //a vezérlők beállítása mod2Obj->SetVezerlo(); //az adatok beállítása mod2Obj->SetAdatok(); } //------------------------------------------------------------------------------------------------ private: System::Void rbtnKönnyű_CheckedChanged(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------------------ { //ha a kiválaszott játékos az ember, akkor az ember játkoshoz //kapcsolódó vezérlők tulajdonságait kell beállítani if(rbtnEmber->Checked == true) { //játék újraindítása mod1Obj->ResetGame(); //pontszámok lenullázása mod1Obj->PontszamReset(); //vezérlők beállítása mod1Obj->SetVezerlo(); //adatok beállítása mod1Obj->SetAdatok(); } //ha a normál üzemmód van kiválasztva, akkor a hozzá tartozó //vezérlők tulajdonságait be kell állítani if(rbtnNormal->Checked == true && rbtnNormal->Enabled == true)

260

{ könnyűToolStripMenuItem->Checked = false; normálToolStripMenuItem->Checked = true; //a játék újraindítása mod2Obj->ResetGame(); //pontszámok kinullázása mod2Obj->PontszamReset(); //a vezérlők beállítása mod2Obj->SetVezerlo(); //az adatok beállítása mod2Obj->SetAdatok(); } //ha a könnyű üzemmód van kiválasztva else if(rbtnKönnyű->Checked == true && rbtnKönnyű->Checked == true) { könnyűToolStripMenuItem->Checked = true; normálToolStripMenuItem->Checked = false; //a játék újraindítása mod3Obj->ResetGame(); //pontszámok kinullázása mod3Obj->PontszamReset(); //a vezérlők beállítása mod3Obj->SetVezerlo(); //az adatok beállítása mod3Obj->SetAdatok(); } } #pragma endregion #pragma region A különböző ablakokért felelős osztályok példányosítása és aktiválása //------------------------------------------------------------------------------------------------ private: System::Void játékszabályToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //-------------------------------------------------------------------------------------------------- { Rule^ ruleForm = gcnew Rule; ruleForm->Show(); } //------------------------------------------------------------------------------------------------ private: System::Void névjegyToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //-------------------------------------------------------------------------------------------------- { Nevjegy^ nevjegyForm = gcnew Nevjegy; nevjegyForm->Show(); } #pragma endregion }; }

Mod1 osztály deklarációi (Mod1.h)

/************************************************************************************ * Mod1 osztály deklarálációi * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> mesterséges intelligencia alkalmazása 3x3 amőbában * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #ifndef MOD1_H //if not define egy szimbólum nemlétét ellenőrzi #define MOD1_H //egy szimbólum definiálása és értékének megadása //=================================================================================== namespace WFA_12 { //===================================================================================

261

using namespace System; //String típust tartalmaző névtér using namespace System::Windows::Forms; //Windows ablak típust tartalmazó névtér ref class frmMain; //referencia hivatkozás a frmMain osztályra //=================================================================================== ref class Mod1 { //=================================================================================== protected: frmMain^ mainfrm; //Windows ablak változója protected: int turn; //lépések számon tartása protected: bool gameover; //játék végének ellenőrzése protected: int xPontszam; //x játékos pontszámának tárolása protected: int oPontszam; //o játékos pontszámának tárolása protected: bool jatek_vege; //játék állásának a tárolása public: Mod1(frmMain^ frm); //paraméteres konstruktor public: virtual void SetVezerlo(); //vezérlők beállítása, ha ember-ember módban public: virtual void SetAdatok(); //kezdő adatok beállítása //az aktuális játékos jelének (O vagy X) beállítása a szükséges vezérlőknek public: String^ SetText(String^ origText); //játék végének ellenőrzése public: void CheckEndGame(String^ val); public: virtual void ResetGame(); //játék újraindítása public: void PontszamReset(); //a pontszámok nullázása }; } #endif

Mod2 osztály deklarációi (Mod2.h)

/************************************************************************************ * Mod2 osztály deklarálációi * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> mesterséges intelligencia alkalmazása 3x3 amőbában * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #ifndef MOD2_H //if not define egy szimbólum nemlétét ellenőrzi #define MOD2_H //egy szimbólum definiálása és értékének megadása #include "Mod1.h" //A Mod1 osztály deklarációi //=================================================================================== namespace WFA_12 { //=================================================================================== using namespace System; //String típust tartalmaző névtér using namespace System::Windows::Forms; //Windows ablak típust tartalmazó névtér //=================================================================================== ref class Mod2 : Mod1 { //=================================================================================== protected: array<String^> ^strArray; //a gombok karaktereinek tárolása protected: array<char> ^dup; //segéd tömb deklarálása protected: int value; //a kiértékeléshez szükséges változó

262

public: Mod2(frmMain^ frm); //paraméteres konstruktor public: virtual void SetVezerlo() override;//vezérlők beállíátásnak átdefiniálása public: virtual void SetAdatok() override;//adatok beállításának átdefiniálása public: virtual void ResetGame() override;//játék újraindításának átdefiniálása //a gombok karaktereinek tárolására szolgáló tömb feltöltése public: void ArrayFeltolt(String ^ch, int index); public: virtual int Kiertekel(char ch, int i); //legjobb mező kiválasztása public: int MinMove(); //pozíció kiválasztása public: void SetGomb(); //kiválasztott mező beállítása } } #endif

Mod3 osztály deklarációi (Mod3.h)

/************************************************************************************ * Mod3 osztály deklarálációi * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> mesterséges intelligencia alkalmazása 3x3 amőbában * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #ifndef MOD3_H //if not define egy szimbólum nemlétét ellenőrzi #define MOD3_H //egy szimbólum definiálása és értékének megadása #include "Mod2.h" //A Mod1 osztály deklarációi //=================================================================================== namespace WFA_12 { //=================================================================================== using namespace System; //String típust tartalmaző névtér using namespace System::Windows::Forms; //Windows ablak típust tartalmazó névtér //=================================================================================== ref class Mod3 : Mod2 { //=================================================================================== public: Mod3(frmMain^ frm); //paraméteres konstruktor); public: virtual int Kiertekel(char ch, int i) override; //pozíció kiválasztása }; } #endif

Mod1 osztály implementálása (Mod1.cpp)

/************************************************************************************ * Mod1 osztály implementálása * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> mesterséges intelligencia alkalmazása 3x3 amőbában * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/

263

#include "stdafx.h" //precompiled header #include "Mod1.h" //Mod1 osztály deklarációi #include "frmMain.h" //frmMain deklarációi //==================================================================================== namespace WFA_12 { //==================================================================================== using namespace System::Windows::Forms; //Windows ablak típust tartalmazó névtér //------------------------------------------------------------------------------------ Mod1::Mod1(frmMain^ frm) //------------------------------------------------------------------------------------ { this->mainfrm = frm; //az osztály adattagjának az inicializálása } //------------------------------------------------------------------------------------ void Mod1::SetVezerlo() //------------------------------------------------------------------------------------ { //ember-ember játéknál az ember rádiógomb aktiválása mainfrm->rbtnEmber->Checked = true; //ember-ember játéknál a könnyű rádiógomb aktiválása mainfrm->rbtnNormal->Checked = true; mainfrm->rbtnKönnyű->Checked = false; //ember-ember játéknál a számítógép rádiógomb inaktivitása mainfrm->rbtnSzamitogep->Checked = false; //ember-ember játéknál a könnyű rádiógomb elérésének tiltása mainfrm->rbtnKönnyű->Enabled = false; //ember-ember játéknál a normál rádiógomb elérésének tiltása mainfrm->rbtnNormal->Enabled = false; //ember-ember játéknál a könnyű menüpont elérésének tiltása mainfrm->könnyűToolStripMenuItem->Enabled = false; //ember-ember játéknál a könnyű menüpont inaktiválása mainfrm->könnyűToolStripMenuItem->Checked = false; //ember-ember játéknál a normál menüpont aktiválása mainfrm->normálToolStripMenuItem->Checked = true; //ember-ember játéknál a nehézségi szint menüpont elérésének tiltása mainfrm->nehézségiSzintToolStripMenuItem->Enabled = false; //ember-ember játéknál a számítógép menüpont kiválasztásának inaktiválása mainfrm->számítógépToolStripMenuItem->Checked = false; //ha a válaszott játék ember-ember ellen, akkor a kiválaszott menü elem is az (mainfrm->emberToolStripMenuItem->Checked == false) ? //az ember menüpontot ellenőrzötté kell állítanunk mainfrm->emberToolStripMenuItem->Checked = true //az ember rádiógomb elérésének engedélyezése : mainfrm->rbtnEmber->Enabled = true; } //------------------------------------------------------------------------------------ void Mod1::SetAdatok() //----------------------------------------------------------------------------------- { //a játék kezdésnél beállítjuk a játék végét tároló változó értékét hamisra this->gameover = false; //a játék kezdésnél lépések számának kinullázása this->turn = 0; //a játék kezdésnél az o játékos pontszámának kinullázása

264

this->oPontszam = 0; //a játék kezdésnél az o játékos pontszámának kinullázása this->xPontszam = 0; } //------------------------------------------------------------------------------------ String^ Mod1::SetText(String^ origText) //------------------------------------------------------------------------------------ { //a játékos jelének tárolása String^ tmpText = origText; //ha a kiválszott helyen még nincs egyik //játékos jele sem if (origText != "X" && origText != "O") { //az akutális játékos jelének beállítása tmpText = mainfrm->btnKövetkező->Text; //ha az előbb az X lépett, akkor most O jön if (mainfrm->btnKövetkező->Text == "X") mainfrm->btnKövetkező->Text = "O"; //egyébként pedig X else mainfrm->btnKövetkező->Text = "X"; //a lépések számának növelése this->turn++; } return tmpText; } //----------------------------------------------------------------------------------- void Mod1::CheckEndGame(String^ val) //----------------------------------------------------------------------------------- { //játék végének hamisra állítása jatek_vege = false; //az ellenőrzés kezdése a balfelső saroktól if (mainfrm->btnTopLeft->Text == val) { //ha a felső sarokban van jel, akkor megnézzük, hogy abban a //sorban van-e további 2 azonos jel, ha van akkor a játéknak vége if (mainfrm->btnTopMiddle->Text == val && mainfrm->btnTopRight->Text == val) { gameover = true; if(gameover == true) { mainfrm->btnTopLeft->BackColor = Color::Red; mainfrm->btnTopMiddle->BackColor = Color::Red; mainfrm->btnTopRight->BackColor = Color::Red; } } //ha a felső sarokban van jel, akkor megnézzük az első oszlopot //és ha a jelek egyformák, akkor a játéknak vége if (mainfrm->btnMiddleLeft->Text == val && mainfrm->btnBottomLeft->Text == val) { gameover = true; if(gameover == true) { mainfrm->btnTopLeft->BackColor = Color::Red; mainfrm->btnMiddleLeft->BackColor = Color::Red;

265

mainfrm->btnBottomLeft->BackColor = Color::Red; } } //ha a felső sarokban van jel, akkor megnézzük a főátló többi elemét //és ha a jelek egyformák, akkor a játéknak vége if (mainfrm->btnMiddleMiddle->Text == val && mainfrm->btnBottomRight->Text == val) { gameover = true; if(gameover == true) { mainfrm->btnTopLeft->BackColor = Color::Red; mainfrm->btnMiddleMiddle->BackColor = Color::Red; mainfrm->btnBottomRight->BackColor = Color::Red; } } } //ha a felső középső elem tartalmaz egy jelet if (mainfrm->btnTopMiddle->Text == val) { //akkor megvizsgáljuk azt, hogy a középső oszlop //jelei megegyeznek, akkor vége a játéknak if(mainfrm->btnMiddleMiddle->Text == val && mainfrm->btnBottomMiddle->Text == val) { gameover = true; if(gameover == true) { mainfrm->btnTopMiddle->BackColor = Color::Red; mainfrm->btnMiddleMiddle->BackColor = Color::Red; mainfrm->btnBottomMiddle->BackColor = Color::Red; } } } //ha a középső sor bal eleme tartalmaz egy jelet if (mainfrm->btnMiddleLeft->Text == val) { //akkor megvizsgáljuk, hogy a középső sor jelei megegyeznek, //ha igen akkor a játéknak vége if (mainfrm->btnMiddleMiddle->Text == val && mainfrm->btnMiddleRight->Text == val) { gameover = true; if(gameover == true) { mainfrm->btnMiddleLeft->BackColor = Color::Red; mainfrm->btnMiddleMiddle->BackColor = Color::Red; mainfrm->btnMiddleRight->BackColor = Color::Red; } } } //ha az alsó sor bal széle tartalmaz egy jelet if (mainfrm->btnBottomLeft->Text == val) { //megnézzük, hogy az alsó sor megegyezik-e, //ha igen, akkor a játéknak vége if (mainfrm->btnBottomMiddle->Text == val && mainfrm->btnBottomRight->Text == val) {

266

gameover = true; if(gameover == true) { mainfrm->btnBottomLeft->BackColor = Color::Red; mainfrm->btnBottomMiddle->BackColor = Color::Red; mainfrm->btnBottomRight->BackColor = Color::Red; } } //megnézzük, hogy a mellékátló megegyezik-e, //ha igen, akkor a játéknak vége if (mainfrm->btnMiddleMiddle->Text == val && mainfrm->btnTopRight->Text == val) { gameover = true; if(gameover == true) { mainfrm->btnBottomLeft->BackColor = Color::Red; mainfrm->btnMiddleMiddle->BackColor = Color::Red; mainfrm->btnTopRight->BackColor = Color::Red; } } } //a bal felső saroktól indulva vizsgáljuk az egyforma jeleket if (mainfrm->btnTopRight->Text == val) { //ha az utolsó oszlop elemei megegyeznek, akkor vége a játéknak if (mainfrm->btnMiddleRight->Text == val && mainfrm->btnBottomRight->Text == val) { gameover = true; if(gameover == true) { mainfrm->btnTopRight->BackColor = Color::Red; mainfrm->btnMiddleRight->BackColor = Color::Red; mainfrm->btnBottomRight->BackColor = Color::Red; } } } //ha a játéknak vége if (gameover == true) { //ha az X nyert if (val == "X") { //x pontszámának növelése xPontszam++; MessageBox::Show("Vége a játéknak! - Gratulálok az X nyert!", "Játék vége", MessageBoxButtons::OK, MessageBoxIcon::Information); mainfrm->lblXPontszam->Text = xPontszam.ToString(); //játék újraindítása ResetGame(); //játék vége jelzése a Mod2 osztálynak jatek_vege = true; } else { //o pontszámának növelése oPontszam++; MessageBox::Show("Vége a játéknak! - Gratulálok az O nyert!", "Játék vége", MessageBoxButtons::OK, MessageBoxIcon::Information);

267

mainfrm->lblOPontszam->Text = oPontszam.ToString(); //játék újraindítása ResetGame(); //a játék vége jelzése a Mod2 osztálynak jatek_vege = true; } } else { //ha a lépés szám elére a 9-et //és nincs nyertes if (turn >= 9) { MessageBox::Show("Vége a játéknak! - Az eredmény döntetlen!", "Játék vége", MessageBoxButtons::OK, MessageBoxIcon::Information); gameover = true; //játék újraindítása ResetGame(); //a játék vée jelzése a Mod2 osztálynak jatek_vege = true; } } } //----------------------------------------------------------------------------------- void Mod1::PontszamReset() //----------------------------------------------------------------------------------- { //az O játékos pontszámának nullázása this->oPontszam = 0; //az X játékos pontszámának nullázása this->xPontszam = 0; } //----------------------------------------------------------------------------------- void Mod1::ResetGame() //----------------------------------------------------------------------------------- { //a lépések számának kinullázása this->turn = 0; //játék végének beállítása false-ra this->gameover = false; //a gombok szöveg tulajdonságainak kinullázása mainfrm->btnTopLeft ->Text = " "; mainfrm->btnTopMiddle ->Text = " "; mainfrm->btnTopRight ->Text = " "; mainfrm->btnMiddleLeft ->Text = " "; mainfrm->btnMiddleMiddle->Text = " "; mainfrm->btnMiddleRight ->Text = " "; mainfrm->btnBottomLeft ->Text = " "; mainfrm->btnBottomMiddle->Text = " "; mainfrm->btnBottomRight ->Text = " "; //a gombok elérhetővé tétele mainfrm->btnTopLeft-> Enabled = true; mainfrm->btnTopMiddle-> Enabled = true; mainfrm->btnTopRight-> Enabled = true; mainfrm->btnMiddleLeft-> Enabled = true; mainfrm->btnMiddleMiddle->Enabled = true;

268

mainfrm->btnMiddleRight-> Enabled = true; mainfrm->btnBottomLeft-> Enabled = true; mainfrm->btnBottomMiddle->Enabled = true; mainfrm->btnBottomRight-> Enabled = true; //a gombok színének default értékre állítása mainfrm->btnTopLeft-> BackColor = Color::Transparent; mainfrm->btnTopMiddle-> BackColor = Color::Transparent; mainfrm->btnTopRight-> BackColor = Color::Transparent; mainfrm->btnMiddleLeft-> BackColor = Color::Transparent; mainfrm->btnMiddleMiddle->BackColor = Color::Transparent; mainfrm->btnMiddleRight-> BackColor = Color::Transparent; mainfrm->btnBottomLeft-> BackColor = Color::Transparent; mainfrm->btnBottomMiddle->BackColor = Color::Transparent; mainfrm->btnBottomRight-> BackColor = Color::Transparent; //a kezdő játékos jelének megadása mainfrm->btnKövetkező->Text = "X"; } }

Mod2 osztály implementálálsa (Mod2.cpp)

/************************************************************************************ * Mod2 osztály implementálása * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> mesterséges intelligencia alkalmazása 3x3 amőbában * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #include "stdafx.h" //precompiled header #include "Mod2.h" //Mod2 osztály deklarációi #include "frmMain.h" //frmMain deklarációi //==================================================================================== namespace WFA_12 { //==================================================================================== using namespace System::Windows::Forms; //Windows ablak típust tartalmazó névtér //------------------------------------------------------------------------------------ Mod2::Mod2(frmMain^ frm) : Mod1(frm) //------------------------------------------------------------------------------------ { this->strArray = gcnew array<String^>(9); //strArray inicializálása this->dup = gcnew array<char>(9); //dup incializálása this->value = 0; //value inicializálása } //------------------------------------------------------------------------------------ void Mod2::SetVezerlo() //------------------------------------------------------------------------------------ { //ember-gép játéknál a számítógép rádiógomb kiválasztása mainfrm->rbtnSzamitogep->Checked = true; //ember-gép játéknál a normál rádiógomb elérésének engedélyezése mainfrm->rbtnNormal->Enabled = true; //ember-gép játéknál a könnyű rádiógomb elérésének engedélyezése

269

mainfrm->rbtnKönnyű->Enabled = true; //ember-gép játéknál a normál menüpont elérésének engedélyezése mainfrm->normálToolStripMenuItem->Enabled = true; //ember-gép játéknál a könnyű menüpont elérésének engedélyezése mainfrm->könnyűToolStripMenuItem->Enabled = true; //ember-gép játéknál a könnyű menüpont tiltása (mainfrm->könnyűToolStripMenuItem->Checked == true) ? mainfrm->rbtnKönnyű->Checked = true : mainfrm->rbtnKönnyű->Checked = false; //ember-gép játéknál a nehézségi szint menüpont elérésének engedélyezése mainfrm->nehézségiSzintToolStripMenuItem->Enabled = true; //ember-gép játéknál a normál menüpont engedélyezése (mainfrm->normálToolStripMenuItem->Checked == true) ? mainfrm->rbtnNormal->Checked = true : mainfrm->rbtnNormal->Checked = false; //ember-gép játéknál a számítógép menüpont kiválasztásának aktiválása mainfrm->számítógépToolStripMenuItem->Checked = true; //ha a válaszott játék ember-gép ellen, akkor a kiválaszott menü elem a gép (mainfrm->emberToolStripMenuItem->Checked == true) ? //a gép menüpontot ellenőrzötté kell állítanunk mainfrm->emberToolStripMenuItem->Checked = false : //az ember rádiógomb elérésének engedélyezése mainfrm->rbtnEmber->Enabled = true; } //----------------------------------------------------------------------------------- void Mod2::SetAdatok() //----------------------------------------------------------------------------------- { //a játék kezdésnél beállítjuk a játék végét tároló változó értékét hamisra this->gameover = false; //a játék kezdésnél lépések számának kinullázása Mod1::turn = 0; //a játék kezdésnél az o játékos pontszámának kinullázása this->oPontszam = 0; //a játék kezdésnél az o játékos pontszámának kinullázása this->xPontszam = 0; for(int i=1; i<=9; i++) { strArray[i-1]=" "; //a jeleket tároló tömb feltöltése üres karakterekkel dup[i-1]=' '; //a segéd tömb feltöltése üres karakterekkel. } } //---------------------------------------------------------------------------------- void Mod2::ArrayFeltolt(String ^ch, int index) //---------------------------------------------------------------------------------- { //ha még nincs vége a játéknak if(Mod1::jatek_vege==false) //az adott jellel való tömb feltöltés strArray[index-1] = ch; } //----------------------------------------------------------------------------------- int Mod2::Kiertekel(char ch, int i) //----------------------------------------------------------------------------------- { //a mező értéknek tárolása int VAL=0;

270

//ha a vizsgált karakter ASCII kódja 79 (O) if(ch == 79) { //először megvizsgáljuk, hogy a táblázat közepe szabad-e if(i == 4 && mainfrm->btnMiddleMiddle->Enabled == true) //ha szabad, akkor értelemszerűen ő kapja a legkisebb értéket, mert //a középső pozícióból a legnagyobb az esély a nyerésre //(maximalizáljuk az esélyeket) VAL-=10; //második szempont annak a vizsgálata, hogy valamelyik sarok szabad-e if((i == 0 && mainfrm->btnTopLeft->Enabled == true) || (i == 2 && mainfrm->btnTopRight->Enabled == true) || (i == 6 && mainfrm->btnBottomLeft->Enabled == true) || (i == 8 && mainfrm->btnBottomRight->Enabled == true)) //amennyiben szabad a sarok és a középső gomb már nem akkor ő //kapja a legkisebb értéket, mert innen van a második legnagyobb //esély a nyerésre (maximalizáljuk az esélyeket) VAL-=8; //a harmadik szempont annak vizsgálata, hogy a maradék mezők közül valamelyik szabad-e if((i == 1 && mainfrm->btnTopMiddle->Enabled == true) || (i == 3 && mainfrm->btnMiddleLeft->Enabled == true) || (i == 5 && mainfrm->btnMiddleRight->Enabled == true) || (i == 7 && mainfrm->btnBottomMiddle->Enabled == true)) //amennyiben szabad a maradék mezők közül valamelyik és a középső gomb //illetve a sarkok nem szabadak akkor ő kapja a legkisebb értéket, //mert innen van a harmadik legnagyobb esély a nyerésre //(maximalizáljuk az esélyeket) VAL-=6; //sor ellenőrzés for(int j=0; j<7; j++) { //Ha van olyan sor, ahol legalább két jelem van, akkor a győzelemre //törekedve a harmadik helyre is leteszem a jelem és ekkor a mezők //pontozása háttérbe szorul if(strArray[j] == "O" && strArray[j+1] == "O" && strArray[j+2] == " ") return j+2; if(strArray[j] == " " && strArray[j+2] == "O" && strArray[j+1] == "O") return j; if(strArray[j] == "O" && strArray[j+2] == "O" && strArray[j+1] == " ") return j+1; j+=2; } //oszlop ellenőrzés for(int j=0; j<3; j++) { //Ha van olyan oszlop, ahol legalább két jelem van, akkor a győzelemre //törekedve a harmadik helyre is leteszem a jelem és ekkor a mezők //pontozása háttérbe szorul if(strArray[j] == "O" && strArray[j+3] == "O" && strArray[j+6] == " ") return j+6; if(strArray[j] == " " && strArray[j+3] == "O" && strArray[j+6] == "O") return j; if(strArray[j] == "O" && strArray[j+6] == "O" && strArray[j+3] == " ") return j+3; }

271

//főátló ellenőrzés //Ha a főátlóban legalább két jelem van, akkor a győzelemre //törekedve a harmadik helyre is leteszem a jelem és ekkor a mezők //pontozása háttérbe szorul if(strArray[0] == "O" && strArray[4] == "O" && strArray[8] == " ") return 8; if(strArray[4] == "O" && strArray[8] == "O" && strArray[0] == " ") return 0; if(strArray[0] == "O" && strArray[8] == "O" && strArray[4] == " ") return 4; //mellékátló ellenőrzés //Ha a mellékátlóban legalább két jelem van, akkor a győzelemre //törekedve a harmadik helyre is leteszem a jelem és ekkor a mezők //pontozása háttérbe szorul if(strArray[2] == "O" && strArray[4] == "O" && strArray[6] == " ") return 6; if(strArray[4] == "O" && strArray[6] == "O" && strArray[2] == " ") return 2; if(strArray[2] == "O" && strArray[6] == "O" && strArray[4] == " ") return 4; } //sor ellenőrzés for(int j=0; j<7; j++) { //Ha van olyan sor, ahol legalább két jele van az ellenségnek, //akkor a védekezés kerül előtérbe és minden más háttérbe szorul //arra törekszem, hogy a harmadik helyre én tegyem le a jelem if(strArray[j] == "X" && strArray[j+1] == "X" && strArray[j+2] == " ") return j+2; if(strArray[j] == " " && strArray[j+2] == "X" && strArray[j+1] == "X") return j; if(strArray[j] == "X" && strArray[j+2] == "X" && strArray[j+1] == " ") return j+1; j+=2; } //oszlop ellenőrzés for(int j=0; j<3; j++) { //Ha van olyan oszlop, ahol legalább két jele van az ellenségnek, //akkor a védekezés kerül előtérbe és minden más háttérbe szorul //arra törekszem, hogy a harmadik helyre én tegyem le a jelem if(strArray[j] == "X" && strArray[j+3] == "X" && strArray[j+6] == " ") return j+6; if(strArray[j] == " " && strArray[j+3] == "X" && strArray[j+6] == "X") return j; if(strArray[j] == "X" && strArray[j+6] == "X" && strArray[j+3] == " ") return j+3; } //főátló ellenőrzés //Ha a főátlóban legalább két jele van az ellenségnek, //akkor a védekezés kerül előtérbe és minden más háttérbe szorul //arra törekszem, hogy a harmadik helyre én tegyem le a jelem if(strArray[0] == "X" && strArray[4] == "X" && strArray[8] == " ") return 8; if(strArray[4] == "X" && strArray[8] == "X" && strArray[0] == " ")

272

return 0; if(strArray[0] == "X" && strArray[8] == "X" && strArray[4] == " ") return 4; //mellékátló ellenőrzés //Ha a mellékátlóban legalább két jele van az ellenségnek, //akkor a védekezés kerül előtérbe és minden más háttérbe szorul //arra törekszem, hogy a harmadik helyre én tegyem le a jelem if(strArray[2] == "X" && strArray[4] == "X" && strArray[6] == " ") return 6; if(strArray[4] == "X" && strArray[6] == "X" && strArray[2] == " ") return 2; if(strArray[4] == "X" && strArray[6] == "X" && strArray[2] == " ") return 4; return VAL; } //----------------------------------------------------------------------------------- int Mod2::MinMove() //----------------------------------------------------------------------------------- { //pozíció tárolása int POS; //ha a játéknak még nincs vége if(Mod1::jatek_vege==false) { //végig megyünk az eddig eltárolt jeleken for(int i=0; i<9; i++) { //ha találtunk üres helyet if(strArray[i]==" ") { //akkor megpróbáljuk letenni az O-t dup[i]='O'; //ha ez a mező a legjobb választás if(Kiertekel(dup[i],i)<value) { //az érték eltárolása value=Kiertekel(dup[i], i); //a pozíció eltárolása POS=i; } //ha kezdvezőbb a helyezet (van nyerési mező) vagy //az ellenség áll nyerésre (van nyerési mezeje) if(Kiertekel(dup[i],i)>0) { //az érték tárolása value=Kiertekel(dup[i], i); //a pozíció tárolása POS=value; } //egyébként a segéd tömbnek értékül adunk egy üres helyet dup[i]=' '; } } } //aktuális érték kinullázása value=0;

273

return POS; } //----------------------------------------------------------------------------------- void Mod2::SetGomb() //----------------------------------------------------------------------------------- { //ha a játéknak még nincs vége if(Mod1::jatek_vege==false) { //a pozíció kiszámolása int POS = MinMove(); //a kiszámolt pozícióra helyezzük a jelet strArray[POS]="O"; //ha a kiválasztott pozíció nulla if (POS==0) { //a gomb szöveg tulajdonságának beállítása mainfrm->btnTopLeft->Text = "O"; //a gomb elérhetőségének inaktívvá tétele mainfrm->btnTopLeft->Enabled = false; //a lépsek számának növelése Mod1::turn++; //játék végének ellenőrzése CheckEndGame("O"); } //ha a kiválasztott pozíció egy else if(POS==1) { //a gomb szöveg tulajdonságának beállítása mainfrm->btnTopMiddle->Text = "O"; //a gomb elérhetőségének inaktívvá tétele mainfrm->btnTopMiddle->Enabled = false; //a lépsek számának növelése Mod1::turn++; //játék végének ellenőrzése CheckEndGame("O"); } //ha a kiválasztott pozíció kettő else if (POS==2) { //a gomb szöveg tulajdonságának beállítása mainfrm->btnTopRight->Text = "O"; //a gomb elérhetőségének inaktívvá tétele mainfrm->btnTopRight->Enabled = false; //a lépsek számának növelése Mod1::turn++; //játék végének ellenőrzése CheckEndGame("O"); } //ha a kiválasztott pozíció három else if (POS==3) { //a gomb szöveg tulajdonságának beállítása mainfrm->btnMiddleLeft->Text = "O"; //a gomb elérhetőségének inaktívvá tétele mainfrm->btnMiddleLeft->Enabled = false; //a lépsek számának növelése Mod1::turn++; //játék végének ellenőrzése

274

CheckEndGame("O"); } //ha a kiválasztott pozíció négy else if (POS==4) { //a gomb szöveg tulajdonságának beállítása mainfrm->btnMiddleMiddle->Text = "O"; //a gomb elérhetőségének inaktívvá tétele mainfrm->btnMiddleMiddle->Enabled = false; //a lépsek számának növelése Mod1::turn++; //játék végének ellenőrzése CheckEndGame("O"); } //ha a kiválasztott pozíció öt else if(POS==5) { //a gomb szöveg tulajdonságának beállítása mainfrm->btnMiddleRight->Text = "O"; //a gomb elérhetőségének inaktívvá tétele mainfrm->btnMiddleRight->Enabled = false; //a lépsek számának növelése Mod1::turn++; //játék végének ellenőrzése CheckEndGame("O"); } //ha a kiválasztott pozíció hat else if (POS==6) { //a gomb szöveg tulajdonságának beállítása mainfrm->btnBottomLeft->Text = "O"; //a gomb elérhetőségének inaktívvá tétele mainfrm->btnBottomLeft->Enabled = false; //a lépsek számának növelése Mod1::turn++; //játék végének ellenőrzése CheckEndGame("O"); } //ha a kiválasztott pozíció hét else if (POS==7) { //a gomb szöveg tulajdonságának beállítása mainfrm->btnBottomMiddle->Text = "O"; //a gomb elérhetőségének inaktívvá tétele mainfrm->btnBottomMiddle->Enabled = false; //a lépsek számának növelése Mod1::turn++; //játék végének ellenőrzése CheckEndGame("O"); } else if (POS==8) { //a gomb szöveg tulajdonságának beállítása mainfrm->btnBottomRight->Text = "O"; //a gomb elérhetőségének inaktívvá tétele mainfrm->btnBottomRight->Enabled = false; //a lépsek számának növelése Mod1::turn++; //játék végének ellenőrzése

275

CheckEndGame("O"); } mainfrm->btnKövetkező->Text="X"; } } //----------------------------------------------------------------------------------- void Mod2::ResetGame() //----------------------------------------------------------------------------------- { //végig megyünk a jeleket tároló tömbökön for(int i=1; i<=9; i++) { //a jeleket tároló tömb kinullázása strArray[i-1]=" "; //a segéd tömb kinullázása dup[i-1]=' '; } //az ősosztály játék újraindításáért felelős függvény hívása Mod1::ResetGame(); } }

Mod3 osztály implementálása (Mod3.cpp)

/************************************************************************************ * Mod3 osztály implementálása * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> mesterséges intelligencia alkalmazása 3x3 amőbában * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #include "stdafx.h" //precompiled header #include "Mod3.h" //Mod2 osztály deklarációi #include "frmMain.h" //frmMain deklarációi //==================================================================================== namespace WFA_12 { //==================================================================================== using namespace System::Windows::Forms; //Windows ablak típust tartalmazó névtér //------------------------------------------------------------------------------------ Mod3::Mod3(frmMain^ frm) : Mod2(frm) //----------------------------------------------------------------------------------- { Mod2::strArray = gcnew array<String^>(9); //strArray inicializálása Mod2::dup = gcnew array<char>(9); //dup incializálása Mod2::value = 0; //value inicializálása } //------------------------------------------------------------------------------------ int Mod3::Kiertekel(char ch, int i) //------------------------------------------------------------------------------------ { //a mező értéknek tárolása int VAL=0;

276

//ha a vizsgált karakter ASCII kódja 79 (O) if(ch == 79) { //először megvizsgáljuk, hogy a táblázat közepe szabad-e if(i == 4 && mainfrm->btnMiddleMiddle->Enabled == true) //ha szabad, akkor értelemszerűen ő kapja a legkisebb értéket, mert //a középső pozícióból a legnagyobb az esély a nyerésre //(maximalizáljuk az esélyeket) VAL-=10; //második szempont annak a vizsgálata, hogy valamelyik sarok szabad-e if((i == 0 && mainfrm->btnTopLeft->Enabled == true) || (i == 2 && mainfrm->btnTopRight->Enabled == true) || (i == 6 && mainfrm->btnBottomLeft->Enabled == true) || (i == 8 && mainfrm->btnBottomRight->Enabled == true)) //amennyiben szabad a sarok és a középső gomb már nem akkor ő //kapja a legkisebb értéket, mert innen van a második legnagyobb //esély a nyerésre (maximalizáljuk az esélyeket) VAL-=8; //a harmadik szempont annak vizsgálata, hogy a maradék mezők közül valamelyik szabad-e if((i == 1 && mainfrm->btnTopMiddle->Enabled == true) || (i == 3 && mainfrm->btnMiddleLeft->Enabled == true) || (i == 5 && mainfrm->btnMiddleRight->Enabled == true) || (i == 7 && mainfrm->btnBottomMiddle->Enabled == true)) //amennyiben szabad a maradék mezők közül valamelyik és a középső gomb //illetve a sarkok nem szabadak akkor ő kapja a legkisebb értéket, //mert innen van a harmadik legnagyobb esély a nyerésre //(maximalizáljuk az esélyeket) VAL-=6; } return VAL; } }

frmMain osztály deklarációi, defíniciói és eseménykezelései (frmMain.h)

/************************************************************************************ * frmMain osztály deklarációi és eseménykezelései * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> Tili-Toli probléma megoldása legjobbat először algoritmussal * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #pragma once //előfordító direktíva (nem szabványos!) #include "Player.h" //Player osztály deklarációi #include "Computer.h" //Computer osztály deklarációi #include "Nevjegy.h" //Névjegy osztály deklarációi #include "Rules.h" //Játékszabály osztály deklarációi //=================================================================================== namespace WFA_13 { //=================================================================================== using namespace System; using namespace System::ComponentModel; using namespace System::Collections; using namespace System::Windows::Forms; using namespace System::Data;

277

using namespace System::Drawing; /// <summary> /// Summary for Form1 /// </summary> public ref class frmMain : public System::Windows::Forms::Form { public: frmMain(void) { InitializeComponent(); // //TODO: Add the constructor code here // } protected: /// <summary> /// Clean up any resources being used. /// </summary> ~frmMain() { if (components) { delete components; } } public: System::Windows::Forms::GroupBox^ groupBox3; public: System::Windows::Forms::Label^ lbl_MILepesSzam; public: System::Windows::Forms::Label^ lbl_HLepesSzam; public: System::Windows::Forms::Label^ label1; public: System::Windows::Forms::Button^ btnNewGame; public: System::Windows::Forms::Button^ btnExit; public: System::Windows::Forms::ToolTip^ toolTip1; public: System::Windows::Forms::MenuStrip^ menuStrip1; public: System::Windows::Forms::ToolStripMenuItem^ fájlToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ újJátákToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ kilépésToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ helpToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ játékszabályToolStripMenuItem; public: System::Windows::Forms::ToolStripMenuItem^ névjegyToolStripMenuItem; public: System::Windows::Forms::Panel^ panel1; public: System::Windows::Forms::Panel^ panel2; public: System::Windows::Forms::PictureBox^ pictureBox2; public: System::Windows::Forms::PictureBox^ pictureBox1; public: System::Windows::Forms::PictureBox^ pictureBox3; public: System::Windows::Forms::PictureBox^ pictureBox4; public: System::Windows::Forms::Label^ lbl_MIPontSzam; public: System::Windows::Forms::Label^ lbl_HPontSzam; public: System::Windows::Forms::Label^ label3; public: System::Windows::Forms::Label^ HaktHeurisztika; public: System::Windows::Forms::Label^ MIaktHeurisztika; public: System::Windows::Forms::Label^ label4; public: System::Windows::Forms::Label^ label2; public: System::Windows::Forms::Label^ label5; public: System::Windows::Forms::Label^ label6; public: System::Windows::Forms::Label^ label7; private: System::ComponentModel::IContainer^ components; private: /// <summary> /// Required designer variable. /// </summary> #pragma region Windows Form Designer generated code /// <summary> /// Required method for Designer support - do not modify /// the contents of this method with the code editor.

278

/// </summary> void InitializeComponent(void) { this->components = (gcnew System::ComponentModel::Container()); System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(frmMain::typeid)); this->groupBox3 = (gcnew System::Windows::Forms::GroupBox()); this->pictureBox2 = (gcnew System::Windows::Forms::PictureBox()); this->pictureBox1 = (gcnew System::Windows::Forms::PictureBox()); this->lbl_MILepesSzam = (gcnew System::Windows::Forms::Label()); this->lbl_HLepesSzam = (gcnew System::Windows::Forms::Label()); this->label1 = (gcnew System::Windows::Forms::Label()); this->btnNewGame = (gcnew System::Windows::Forms::Button()); this->btnExit = (gcnew System::Windows::Forms::Button()); this->toolTip1 = (gcnew System::Windows::Forms::ToolTip(this->components)); this->menuStrip1 = (gcnew System::Windows::Forms::MenuStrip()); this->fájlToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->újJátákToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->kilépésToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->helpToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->játékszabályToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->névjegyToolStripMenuItem = (gcnew System::Windows::Forms::ToolStripMenuItem()); this->panel1 = (gcnew System::Windows::Forms::Panel()); this->panel2 = (gcnew System::Windows::Forms::Panel()); this->pictureBox3 = (gcnew System::Windows::Forms::PictureBox()); this->pictureBox4 = (gcnew System::Windows::Forms::PictureBox()); this->lbl_MIPontSzam = (gcnew System::Windows::Forms::Label()); this->lbl_HPontSzam = (gcnew System::Windows::Forms::Label()); this->label3 = (gcnew System::Windows::Forms::Label()); this->HaktHeurisztika = (gcnew System::Windows::Forms::Label()); this->MIaktHeurisztika = (gcnew System::Windows::Forms::Label()); this->label4 = (gcnew System::Windows::Forms::Label()); this->label2 = (gcnew System::Windows::Forms::Label()); this->label5 = (gcnew System::Windows::Forms::Label()); this->label6 = (gcnew System::Windows::Forms::Label()); this->label7 = (gcnew System::Windows::Forms::Label()); this->groupBox3->SuspendLayout(); (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->pictureBox2))->BeginInit(); (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->pictureBox1))->BeginInit(); this->menuStrip1->SuspendLayout(); (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->pictureBox3))->BeginInit(); (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->pictureBox4))->BeginInit(); this->SuspendLayout(); // // groupBox3 // this->groupBox3->Controls->Add(this->pictureBox2); this->groupBox3->Controls->Add(this->pictureBox1); this->groupBox3->Controls->Add(this->lbl_MILepesSzam); this->groupBox3->Controls->Add(this->lbl_HLepesSzam); this->groupBox3->ForeColor = System::Drawing::Color::Blue; this->groupBox3->Location = System::Drawing::Point(218, 79); this->groupBox3->Name = L"groupBox3"; this->groupBox3->Size = System::Drawing::Size(100, 107); this->groupBox3->TabIndex = 13; this->groupBox3->TabStop = false; this->groupBox3->Text = L"Lépések száma"; // // pictureBox2 // this->pictureBox2->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"pictureBox2.Image"))); this->pictureBox2->Location = System::Drawing::Point(55, 19); this->pictureBox2->Name = L"pictureBox2"; this->pictureBox2->Size = System::Drawing::Size(42, 42);

279

this->pictureBox2->SizeMode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->pictureBox2->TabIndex = 5; this->pictureBox2->TabStop = false; // // pictureBox1 // this->pictureBox1->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"pictureBox1.Image"))); this->pictureBox1->Location = System::Drawing::Point(7, 19); this->pictureBox1->Name = L"pictureBox1"; this->pictureBox1->Size = System::Drawing::Size(42, 42); this->pictureBox1->SizeMode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->pictureBox1->TabIndex = 4; this->pictureBox1->TabStop = false; // // lbl_MILepesSzam // this->lbl_MILepesSzam->AutoSize = true; this->lbl_MILepesSzam->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 12, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->lbl_MILepesSzam->ForeColor = System::Drawing::SystemColors::ControlText; this->lbl_MILepesSzam->Location = System::Drawing::Point(64, 67); this->lbl_MILepesSzam->Name = L"lbl_MILepesSzam"; this->lbl_MILepesSzam->Size = System::Drawing::Size(19, 26); this->lbl_MILepesSzam->TabIndex = 3; this->lbl_MILepesSzam->Text = L"0"; // // lbl_HLepesSzam // this->lbl_HLepesSzam->AutoSize = true; this->lbl_HLepesSzam->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 12, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->lbl_HLepesSzam->ForeColor = System::Drawing::SystemColors::ControlText; this->lbl_HLepesSzam->Location = System::Drawing::Point(18, 66); this->lbl_HLepesSzam->Name = L"lbl_HLepesSzam"; this->lbl_HLepesSzam->Size = System::Drawing::Size(19, 26); this->lbl_HLepesSzam->TabIndex = 2; this->lbl_HLepesSzam->Text = L"0"; // // label1 // this->label1->AutoSize = true; this->label1->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 21.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->label1->Location = System::Drawing::Point(54, 36); this->label1->Name = L"label1"; this->label1->Size = System::Drawing::Size(114, 33); this->label1->TabIndex = 14; this->label1->Text = L"T i l i"; // // btnNewGame // this->btnNewGame->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 8.25F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->btnNewGame->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft; this->btnNewGame->Location = System::Drawing::Point(216, 214); this->btnNewGame->Name = L"btnNewGame"; this->btnNewGame->Size = System::Drawing::Size(103, 30); this->btnNewGame->TabIndex = 10; this->btnNewGame->Text = L"Keverés"; this->btnNewGame->UseVisualStyleBackColor = true; this->btnNewGame->Click += gcnew System::EventHandler(this, &frmMain::btnNewGame_Click); // // btnExit //

280

this->btnExit->Font = (gcnew System::Drawing::Font(L"Viner Hand ITC", 8.25F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->btnExit->ImageAlign = System::Drawing::ContentAlignment::MiddleLeft; this->btnExit->Location = System::Drawing::Point(216, 249); this->btnExit->Name = L"btnExit"; this->btnExit->Size = System::Drawing::Size(103, 30); this->btnExit->TabIndex = 9; this->btnExit->Text = L"Kilépés"; this->btnExit->UseVisualStyleBackColor = true; this->btnExit->Click += gcnew System::EventHandler(this, &frmMain::btnExit_Click); // // toolTip1 // this->toolTip1->ShowAlways = true; this->toolTip1->ToolTipIcon = System::Windows::Forms::ToolTipIcon::Info; // // menuStrip1 // this->menuStrip1->Items->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) {this->fájlToolStripMenuItem, this->helpToolStripMenuItem}); this->menuStrip1->Location = System::Drawing::Point(0, 0); this->menuStrip1->Name = L"menuStrip1"; this->menuStrip1->Size = System::Drawing::Size(549, 24); this->menuStrip1->TabIndex = 7; this->menuStrip1->Text = L"menuStrip1"; // // fájlToolStripMenuItem // this->fájlToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) {this->újJátákToolStripMenuItem, this->kilépésToolStripMenuItem}); this->fájlToolStripMenuItem->Name = L"fájlToolStripMenuItem"; this->fájlToolStripMenuItem->Size = System::Drawing::Size(37, 20); this->fájlToolStripMenuItem->Text = L"Fájl"; // // újJátákToolStripMenuItem // this->újJátákToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"újJátákToolStripMenuItem.Image"))); this->újJátákToolStripMenuItem->Name = L"újJátákToolStripMenuItem"; this->újJátákToolStripMenuItem->Size = System::Drawing::Size(114, 22); this->újJátákToolStripMenuItem->Text = L"Keverés"; this->újJátákToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::újJátákToolStripMenuItem_Click); // // kilépésToolStripMenuItem // this->kilépésToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"kilépésToolStripMenuItem.Image"))); this->kilépésToolStripMenuItem->Name = L"kilépésToolStripMenuItem"; this->kilépésToolStripMenuItem->Size = System::Drawing::Size(114, 22); this->kilépésToolStripMenuItem->Text = L"Kilépés"; this->kilépésToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::kilépésToolStripMenuItem_Click); // // helpToolStripMenuItem // this->helpToolStripMenuItem->DropDownItems->AddRange(gcnew cli::array< System::Windows::Forms::ToolStripItem^ >(2) {this->játékszabályToolStripMenuItem, this->névjegyToolStripMenuItem}); this->helpToolStripMenuItem->Name = L"helpToolStripMenuItem"; this->helpToolStripMenuItem->Size = System::Drawing::Size(46, 20); this->helpToolStripMenuItem->Text = L"Súgó"; // // játékszabályToolStripMenuItem //

281

this->játékszabályToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"játékszabályToolStripMenuItem.Image"))); this->játékszabályToolStripMenuItem->Name = L"játékszabályToolStripMenuItem"; this->játékszabályToolStripMenuItem->Size = System::Drawing::Size(138, 22); this->játékszabályToolStripMenuItem->Text = L"Játékszabály"; this->játékszabályToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::játékszabályToolStripMenuItem_Click); // // névjegyToolStripMenuItem // this->névjegyToolStripMenuItem->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"névjegyToolStripMenuItem.Image"))); this->névjegyToolStripMenuItem->Name = L"névjegyToolStripMenuItem"; this->névjegyToolStripMenuItem->Size = System::Drawing::Size(138, 22); this->névjegyToolStripMenuItem->Text = L"Névjegy"; this->névjegyToolStripMenuItem->Click += gcnew System::EventHandler(this, &frmMain::névjegyToolStripMenuItem_Click); // // panel1 // this->panel1->BackColor = System::Drawing::Color::Black; this->panel1->Location = System::Drawing::Point(12, 79); this->panel1->Name = L"panel1"; this->panel1->Size = System::Drawing::Size(200, 200); this->panel1->TabIndex = 8; // // panel2 // this->panel2->BackColor = System::Drawing::Color::Black; this->panel2->Location = System::Drawing::Point(325, 83); this->panel2->Name = L"panel2"; this->panel2->Size = System::Drawing::Size(200, 200); this->panel2->TabIndex = 9; // // pictureBox3 // this->pictureBox3->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"pictureBox3.Image"))); this->pictureBox3->Location = System::Drawing::Point(325, 288); this->pictureBox3->Name = L"pictureBox3"; this->pictureBox3->Size = System::Drawing::Size(42, 42); this->pictureBox3->SizeMode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->pictureBox3->TabIndex = 5; this->pictureBox3->TabStop = false; // // pictureBox4 // this->pictureBox4->Image = (cli::safe_cast<System::Drawing::Image^ >(resources->GetObject(L"pictureBox4.Image"))); this->pictureBox4->Location = System::Drawing::Point(12, 282); this->pictureBox4->Name = L"pictureBox4"; this->pictureBox4->Size = System::Drawing::Size(42, 42); this->pictureBox4->SizeMode = System::Windows::Forms::PictureBoxSizeMode::StretchImage; this->pictureBox4->TabIndex = 4; this->pictureBox4->TabStop = false; // // lbl_MIPontSzam // this->lbl_MIPontSzam->AutoSize = true; this->lbl_MIPontSzam->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 11.25F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->lbl_MIPontSzam->ForeColor = System::Drawing::SystemColors::ControlText; this->lbl_MIPontSzam->Location = System::Drawing::Point(489, 309); this->lbl_MIPontSzam->Name = L"lbl_MIPontSzam"; this->lbl_MIPontSzam->Size = System::Drawing::Size(16, 20); this->lbl_MIPontSzam->TabIndex = 3; this->lbl_MIPontSzam->Text = L"0"; //

282

// lbl_HPontSzam // this->lbl_HPontSzam->AutoSize = true; this->lbl_HPontSzam->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 11.25F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->lbl_HPontSzam->ForeColor = System::Drawing::SystemColors::ControlText; this->lbl_HPontSzam->Location = System::Drawing::Point(173, 303); this->lbl_HPontSzam->Name = L"lbl_HPontSzam"; this->lbl_HPontSzam->Size = System::Drawing::Size(16, 20); this->lbl_HPontSzam->TabIndex = 2; this->lbl_HPontSzam->Text = L"0"; // // label3 // this->label3->AutoSize = true; this->label3->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->label3->Location = System::Drawing::Point(56, 282); this->label3->Name = L"label3"; this->label3->Size = System::Drawing::Size(116, 20); this->label3->TabIndex = 16; this->label3->Text = L"Távolság a céltól:"; // // HaktHeurisztika // this->HaktHeurisztika->AutoSize = true; this->HaktHeurisztika->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 11.25F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->HaktHeurisztika->Location = System::Drawing::Point(173, 282); this->HaktHeurisztika->Name = L"HaktHeurisztika"; this->HaktHeurisztika->Size = System::Drawing::Size(16, 20); this->HaktHeurisztika->TabIndex = 17; this->HaktHeurisztika->Text = L"0"; // // MIaktHeurisztika // this->MIaktHeurisztika->AutoSize = true; this->MIaktHeurisztika->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 11.25F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->MIaktHeurisztika->Location = System::Drawing::Point(489, 286); this->MIaktHeurisztika->Name = L"MIaktHeurisztika"; this->MIaktHeurisztika->Size = System::Drawing::Size(16, 20); this->MIaktHeurisztika->TabIndex = 18; this->MIaktHeurisztika->Text = L"0"; // // label4 // this->label4->AutoSize = true; this->label4->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 21.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->label4->Location = System::Drawing::Point(368, 36); this->label4->Name = L"label4"; this->label4->Size = System::Drawing::Size(108, 33); this->label4->TabIndex = 19; this->label4->Text = L"T o l i"; // // label2 // this->label2->AutoSize = true; this->label2->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->label2->Location = System::Drawing::Point(370, 287); this->label2->Name = L"label2";

283

this->label2->Size = System::Drawing::Size(116, 20); this->label2->TabIndex = 20; this->label2->Text = L"Távolság a céltól:"; // // label5 // this->label5->AutoSize = true; this->label5->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->label5->Location = System::Drawing::Point(56, 303); this->label5->Name = L"label5"; this->label5->Size = System::Drawing::Size(72, 20); this->label5->TabIndex = 21; this->label5->Text = L"Pontszám:"; // // label6 // this->label6->AutoSize = true; this->label6->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 11.25F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(238))); this->label6->Location = System::Drawing::Point(370, 309); this->label6->Name = L"label6"; this->label6->Size = System::Drawing::Size(72, 20); this->label6->TabIndex = 22; this->label6->Text = L"Pontszám:"; // // label7 // this->label7->AutoSize = true; this->label7->Font = (gcnew System::Drawing::Font(L"Arial Narrow", 21.75F, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0))); this->label7->Location = System::Drawing::Point(257, 36); this->label7->Name = L"label7"; this->label7->Size = System::Drawing::Size(23, 33); this->label7->TabIndex = 23; this->label7->Text = L"-"; // // frmMain // this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; this->ClientSize = System::Drawing::Size(549, 342); this->Controls->Add(this->label7); this->Controls->Add(this->label6); this->Controls->Add(this->label5); this->Controls->Add(this->label2); this->Controls->Add(this->label4); this->Controls->Add(this->pictureBox4); this->Controls->Add(this->pictureBox3); this->Controls->Add(this->MIaktHeurisztika); this->Controls->Add(this->HaktHeurisztika); this->Controls->Add(this->lbl_MIPontSzam); this->Controls->Add(this->label3); this->Controls->Add(this->lbl_HPontSzam); this->Controls->Add(this->panel2); this->Controls->Add(this->groupBox3); this->Controls->Add(this->label1); this->Controls->Add(this->btnNewGame); this->Controls->Add(this->btnExit); this->Controls->Add(this->menuStrip1); this->Controls->Add(this->panel1); this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::Fixed3D; this->Icon = (cli::safe_cast<System::Drawing::Icon^ >(resources->GetObject(L"$this.Icon"))); this->MaximizeBox = false; this->Name = L"frmMain"; this->StartPosition = System::Windows::Forms::FormStartPosition::CenterScreen;

284

this->Text = L"WFA_13"; this->Load += gcnew System::EventHandler(this, &frmMain::frmMain_Load); this->groupBox3->ResumeLayout(false); this->groupBox3->PerformLayout(); (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->pictureBox2))->EndInit(); (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->pictureBox1))->EndInit(); this->menuStrip1->ResumeLayout(false); this->menuStrip1->PerformLayout(); (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->pictureBox3))->EndInit(); (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->pictureBox4))->EndInit(); this->ResumeLayout(false); this->PerformLayout(); } #pragma endregion Player^ pObj; //Player osztály példány deklarálása Computer^ cObj; //Computer osztály példány deklarálása #pragma region Windows Ablak betöltődésének az eseménykezelése //------------------------------------------------------------------------------------ private: System::Void frmMain_Load(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------ { //Player osztály obejktumpéldány inicializálása pObj = gcnew Player(this); //Computer osztály obejktumpéldány inicializálása cObj = gcnew Computer(this); //A játékos gombjainak inicializálása pObj->GombokInicial(); //A mesterséges intelligencia gombjainak inicializálása cObj->GombokInicial(); } #pragma endregion #pragma region Új játék indításának az eseményei //------------------------------------------------------------------------------------ private: System::Void btnNewGame_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------ { pObj->GombokStart(cObj); } //------------------------------------------------------------------------------------ private: System::Void újJátákToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------ { pObj->GombokStart(cObj); } #pragma endregion #pragma region Névjegy menüpont kiválasztása //------------------------------------------------------------------------------------ private: System::Void névjegyToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------ { Nevjegy^ nevjegyForm = gcnew Nevjegy; nevjegyForm->Show(); } #pragma endregion #pragma region Játékszabály menüpont kiválasztása //------------------------------------------------------------------------------------ private: System::Void játékszabályToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------ {

285

Rules^ ruleForm = gcnew Rules; ruleForm->Show(); } #pragma endregion #pragma region Kilépés eseménye //------------------------------------------------------------------------------------ private: System::Void btnExit_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------ { Application::Exit(); } //------------------------------------------------------------------------------------ private: System::Void kilépésToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) //------------------------------------------------------------------------------------ { Application::Exit(); } #pragma endregion }; }

Player osztály deklarációi (Player.h)

/************************************************************************************ * Player osztály deklarálációi * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> Tili-Toli probléma megoldása legjobbat először algoritmussal * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #ifndef Player_H //if not define egy szimbólum nemlétét ellenőrzi #define Player_H //egy szimbólum definiálása és értékének megadása #define N 3 //sor méret #define M 3 //oszlop méret //=================================================================================== namespace WFA_13 { //=================================================================================== using namespace System; using namespace System::Windows::Forms; //=================================================================================== ref class frmMain; //referencia hivtakozás a frmMain osztályra ref class Computer; //referencia hivatkozás a Computer osztályra //=================================================================================== ref class Player //=================================================================================== { //játékos gombjainak deklarálása private: array<Button^,2>^ H_Gombok; //játékos számok vektor deklarálása private: array<int>^ H_Szamok; //játékos üres indexének tárolása private: int H_Lyukx, H_Lyuky; //játékos által megtett lépések változó deklarálása private: int H_LepesSzam;

286

//játékos pontszámainak tárolásához private: int H_PontSzam; //Windows ablak változója private: frmMain^ mainfrm; //Random objektum dekralálása private: Random^ randObj; //a mesterséges intelligencia osztály objektumpéldányának deklarálása private: Computer ^ cObj; //az összekevert gombok tárolásához szükséges vektor létrehozása private: array<int> ^ kevert; //segéd tömb deklarálása private: array<String ^,2> ^strs; //konstruktor public: Player(frmMain^ mainfrm); //a számokat összekeverő metódus public: array<int> ^ Kever(array<int> ^ cel); //a gombokat incializáló függvény és a célállapot megjelenítése public: void GombokInicial(); //gombok keverése public: void GombokStart(Computer ^ cObj); //nulla gomb elérésnek beállítása public: void NullaBeallit(); //gomb kattintás eseményének létrehozása public: void GombClick(Object^ sender, EventArgs^ e); //gombok szomszédjainak vizsgálata public: bool H_Szomszed(Button^ Gomb); //a játék végének vizsgálata public: void Vizsgal(Button^ Gomb); //heurisztika kiszámolása public: int Heuristic(array<String ^,2> ^ start, array<int,2> ^ goal); //pontszámot növelő függvény számolása public: void IncPontszam(); }; } #endif

Computer osztály deklarációi (Computer.h)

/************************************************************************************ * Computer osztály deklarálása * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> Tili-Toli probléma megoldása legjobbat először algoritmussal * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #ifndef Computer_H //if not define egy szimbólum nemlétét ellenőrzi #define Computer_H //egy szimbólum definiálása és értékének megadása #define N 3 //sor méret #define M 3 //oszlop méret //=================================================================================== namespace WFA_13 { //=================================================================================== using namespace System; //generikus gyűjteményeket tartalmazó névtér

287

using namespace System::Collections::Generic; //=================================================================================== ref class frmMain; //referencia hivtakozás a frmMain osztályra ref class Player; //referencia hivatkozás a Player osztályra //=================================================================================== ref class Computer //=================================================================================== { //Windows ablak változója private: frmMain^ mainfrm; //mesterséges intelligencia gombjainak deklarálása private: array<System::Windows::Forms::Button^,2>^ MI_Gombok; //mesterséges intelligencia által megtett lépések változó deklarálása private: int MI_LepesSzam; //Random objektum dekralálása private: Random^ randObj; //a játékos osztály objektumpéldányának deklarálása private: Player ^ pObj; //a mesterséges intelligencia pontszámainak tárolására private: int MI_PontSzam; //konstruktor public: Computer(frmMain^ mainfrm); //mesterséges intelligencia gombok inicializálása public: void GombokInicial(); //nulla érték beállítása public: void NullaBeallit(); //MI_Gombok értékeinek keverése public: bool MI_GombokStart(Player ^ pParam, array<int> ^ start); //legjobbat először algoritmus vizsgálat public: bool getBestFirst(array<int> ^ start); //legjobbat először algoritmus public: void BestFirst(array<int> ^ start); //heurisztikát számol public: int Heuristic(array<int,2> ^ start, array<int,2> ^ goal); //üres gomb cserélése felfelé public: array<int,2> ^ CsereFel(array<int,2> ^ aktMatrix); //üres gomb cserélése lefelé public: array<int,2> ^ CsereLe(array<int,2> ^ aktMatrix); //üres gomb cserélése balra public: array<int,2> ^ CsereBalra(array<int,2> ^ aktMatrix); //üres gomb cserélése jobbra public: array<int,2> ^ CsereJobbra(array<int,2> ^ aktMatrix); //ellenőrizzük, hogy a vizsgált állapot benne van-e az OpenList-ben public: bool InOpenList(array<int,2> ^ aktMatrix, List <array<int,2>^> ^ OpenList); //ellenőrizzük, hogy a vizsgált állapot benne van-e a CloseList-ben public: bool InCloseList(array<int,2> ^ aktMatrix, List <array<int,2>^> ^ CloseList); //gombok helyének frissítése public: void GombokFrissit(array<int,2> ^ aktMatrix); //pontszám növelésért felelős függvény public: void IncPontszam(); }; } #endif

Player osztály implementálása (Player.cpp)

/************************************************************************************

288

* Player osztály implementáció * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> Tili-Toli probléma megoldása legjobbat először algoritmussal * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #include "stdafx.h" //precomplied header #include "frmMain.h" //frmMain deklarációi #include "Computer.h" //Computer osztály deklarációi //=================================================================================== namespace WFA_13 { //=================================================================================== //------------------------------------------------------------------------------------ Player::Player(frmMain^ frm) //------------------------------------------------------------------------------------ { //az ablak tulajdonságainak beállítása this->mainfrm = frm; //nulla pozíció inicializálása H_Lyukx = H_Lyuky = 0; //a játékos játékterület gombjainak inicializálása (3x3=9) this->H_Gombok = gcnew array<System::Windows::Forms::Button^,2>(N,M); //véletlenszám generátor inicializálása this->randObj = gcnew Random; //a kevert számokat tároló vektor inicializálása kevert = gcnew array<int>(N*M); } //------------------------------------------------------------------------------------ void Player::GombokInicial() //------------------------------------------------------------------------------------ { //a lokális célvektor array<int,2> ^ celAllapot = gcnew array<int,2>{ {1,8,7}, {2,0,6}, {3,4,5} }; for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { //játékos gombok inicializálása this->H_Gombok[i,j] = gcnew Button(); //játékos gombjainak szélesség beállítása this->H_Gombok[i,j]->Width = mainfrm->panel1->Width/3; //játékos gombjainak magasság beállítása this->H_Gombok[i,j]->Height = mainfrm->panel1->Height/3; //játékos gombjainak bal szélének pozíciója this->H_Gombok[i,j]->Left = i * H_Gombok[i,j]->Width; //játékos gombjainak felső szélének pozíciója this->H_Gombok[i,j]->Top = j * H_Gombok[i,j]->Height; //játékos gombjainak betűtípus beállítása this->H_Gombok[i,j]->Font = gcnew Font("Viner Hand ITC", 36, FontStyle::Bold); //játékos gombjainak kattintás eseménye

289

this->H_Gombok[i,j]->Click += gcnew System::EventHandler(this, &Player::GombClick); //játékos gombjainak háttérszín beállítása this->H_Gombok[i,j]->BackColor = Color::Transparent; //játékos gombok szöveg tulajdonságainak beállítása this->H_Gombok[i,j]->Text = celAllapot[i,j].ToString(); //gombok felhelyezése a panel-ra this->mainfrm->panel1->Controls->Add(this->H_Gombok[i,j]); } } //A nulla helyének beállítása NullaBeallit(); } //----------------------------------------------------------------------------------- void Player::NullaBeallit() //----------------------------------------------------------------------------------- { for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { //ha megtaláltuk a nulla helyét if(H_Gombok[i,j] -> Text == "0") { //a játékos gombját tegyük láthatatlanná H_Gombok[i,j] -> Visible = false; //frissítsük a mezőt H_Gombok[i,j] -> Update(); //állítsuk be az üres hely x pozícióját a globális tárolónak H_Lyukx = i; //állítsuk be az üres hely y pozícióját a globális tárolónak H_Lyuky = j; } //ha a vizsgált elem nem nulla, akkor else { //a gomb látható H_Gombok[i,j] -> Visible = true; //frissítsük a mezőt H_Gombok[i,j] -> Update(); } } } } //------------------------------------------------------------------------------------ void Player::GombokStart(Computer ^ cParam) //------------------------------------------------------------------------------------ { //cObj objektumpéldány inicializálása this->cObj = cParam; //a lokális célvektor létrehozása array<int> ^ celAllapot = gcnew array<int>(N*M) {1,2,3,8,0,4,7,6,5}; //segédtömb incializálása strs = gcnew array<String ^,2>(N,M); //a gombok összekeverése kevert = Kever(celAllapot); //játékos pontszámainak kinullázása

290

H_LepesSzam=0; //lépésszámot megjelenítő tisztítása mainfrm->lbl_HLepesSzam->Text = " "; //lépésszámot megjelenítő frissítése mainfrm->lbl_HLepesSzam->Refresh(); //ha a hegymászó algoritmus elboldogul az összekevert számokkal if(cObj->MI_GombokStart(this, kevert)) { for(int i = 0; i < N; i++) for(int j = 0; j < M; j++) { //gombok eltávolítása a panelról this->mainfrm->panel1->Controls->Remove(this->H_Gombok[i,j]); //memória felszabadítás delete H_Gombok[i,j]; } int index = 0; for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { //játékos gombok inicializálása this->H_Gombok[i,j] = gcnew Button(); //a segéd tömb incializálása this->strs[i,j] = Convert::ToString(kevert[index]); //játékos gombjainak szélesség beállítása this->H_Gombok[i,j]->Width = mainfrm->panel1->Width/3; //játékos gombjainak magasság beállítása this->H_Gombok[i,j]->Height = mainfrm->panel1->Height/3; //játékos gombjainak bal szélének pozíciója this->H_Gombok[i,j]->Left = i * H_Gombok[i,j]->Width; //játékos gombjainak felső szélének pozíciója this->H_Gombok[i,j]->Top = j * H_Gombok[i,j]->Height; //játékos gombjainak betűtípus beállítása this->H_Gombok[i,j]->Font = gcnew Font("Viner Hand ITC", 36, FontStyle::Bold); //a játékos gombjainak kattintás eseménye this->H_Gombok[i,j]->Click += gcnew System::EventHandler(this, &Player::GombClick); //játékos gombjainak háttérszín beállítása this->H_Gombok[i,j]->BackColor = Color::Transparent; //az összekevert gombok értékeinek átadása a gomb szöveg tulajdonságainak this->H_Gombok[i,j]->Text = Convert::ToString(kevert[index]); //gombok felhelyezése a panel-ra this->mainfrm->panel1->Controls->Add(this->H_Gombok[i,j]); //a játékos gombjainak frissítése this->H_Gombok[i,j]->Update(); index++; } } //A nulla helyének beállítása NullaBeallit(); //játékos megkérdezése, arról, hogy ki kezdje a játékot if(MessageBox::Show("Kezdhetek én?", "Aktuális játékos kiválasztása", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == DialogResult::Yes) //ha a gépet választja, akkor hívjuk meg a hegymászó algoritmust

291

cObj->BestFirst(kevert); else //egyébként a játékos elkezdheti a játékot return; } //ellenkező esetben újra hívjuk a függvényt else { int index = 0; for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { //az összekevert gombok értékeinek átadása a gomb szöveg tulajdonságainak this->H_Gombok[i,j]->Text = Convert::ToString(kevert[index]); //a játékos gombjainak frissítése this->H_Gombok[i,j]->Update(); index++; } } //A nulla helyének beállítása NullaBeallit(); //rekurzív hívás GombokStart(cObj); } } //------------------------------------------------------------------------------------ array<int> ^ Player::Kever(array<int> ^ cel) //------------------------------------------------------------------------------------ { for(int i=0; i<100; i++) { //vektor koordináta generálása int x = randObj->Next(0,9); //y érték generálása int y = randObj->Next(0,9); //a két koordinátán található érték felcserélése int temp = cel[x]; cel[x] = cel[y]; cel[y] = temp; } //adjuk vissza az összekevert mezőt return cel; } //------------------------------------------------------------------------------------ bool Player::H_Szomszed(Button^ Gomb) //------------------------------------------------------------------------------------ { Button^ Lyuk; //a lyuk gomb inicializálása Lyuk = H_Gombok[H_Lyukx, H_Lyuky]; //visszaadjuk, hogy a szomszédos gomb üres hely-e vagy sem return ((Gomb->Left == Lyuk->Left) && (Math::Abs(Gomb->Top - Lyuk->Top) == Gomb->Height)) || ((Gomb->Top == Lyuk->Top) && (Math::Abs(Gomb->Left - Lyuk->Left) == Gomb->Width));

292

} //----------------------------------------------------------------------------------- void Player::GombClick(Object^ sender, EventArgs^ e) //----------------------------------------------------------------------------------- { //segéd koordináta a cseréléshez int seged; //ha a kiválasztott gomb mellett található lyuk, akkor megcseréljük őket if(H_Szomszed(dynamic_cast<Button^>(sender))) { //futásidejű ellenőrzött típus-átalakítás segítségével a //kattintott gomb bal koordinátájának eltárolása seged = (dynamic_cast<Button^>(sender))->Left; //futásidejű ellenőrzött típus-átalakítás segítségével a //kattintott gomb bal koordinátájának felcserélése a rés bal koodinátájával (dynamic_cast<Button^>(sender))->Left = H_Gombok[H_Lyukx, H_Lyuky]->Left; //az üres hely bal koordinátájának értékadása H_Gombok[H_Lyukx, H_Lyuky]->Left = seged; //futásidejű ellenőrzött típus-átalakítás segítségével a //kattintott gomb felső koordinátájának eltárolása seged = (dynamic_cast<Button^>(sender))->Top; //futásidejű ellenőrzött típus-átalakítás segítségével a //kattintott gomb felső koordinátájának felcserélése a rés bal koodinátájával (dynamic_cast<Button^>(sender))->Top = H_Gombok[H_Lyukx, H_Lyuky]->Top; //az üres hely felső koordinátájának értékadása H_Gombok[H_Lyukx, H_Lyuky]->Top = seged; //játékos lépésszámának növelése egyel mainfrm->lbl_HLepesSzam->Text = (++H_LepesSzam).ToString(); //lépésszámkijelző frissítése mainfrm->lbl_HLepesSzam->Refresh(); //a játék végének ellenőrzése Vizsgal(dynamic_cast<Button^>(sender)); } } //---------------------------------------------------------------------------------- void Player::Vizsgal(Button^ Gomb) //---------------------------------------------------------------------------------- { bool kesz = false; //a lokális célvektor létrehozása array<int,2> ^ celAllapot = gcnew array<int,2>(N,M) { {1,8,7}, {2,0,6}, {3,4,5} }; //aktuális költség kiszámolása int koltseg = Heuristic(strs,celAllapot)-1; //a költséget kijelző címke értékadása mainfrm->HaktHeurisztika->Text = koltseg.ToString(); //a költésget kijelző címke frissítése mainfrm->HaktHeurisztika->Refresh(); //segéd koordináták incializálása int xVal = 0, yVal = 0, xVal2 = 0, yVal2 = 0; for (int i = 0; i < N; i++) { for (int j = 0; j < M; j++) { //ha az aktuális gomb szövege 0 (tehát rés van ott) akkor

293

if (Convert::ToInt32(strs[i, j]) == 0) { //az x koordináta eltárolása xVal = i; //az y koordináta eltárolása yVal = j; } //futásidejő típusátalakítással összehasonlítjuk a gomb szöveg tulajdonságát a segéd tömbével if (Convert::ToInt32(strs[i, j]) == Convert::ToInt32(dynamic_cast<Button^>(Gomb)->Text)) { //az x koordináta eltárolása xVal2 = i; //az y koordináta eltárolása yVal2 = j; } } } //a segédtömb elemeinek cseréje String^ temp = strs[xVal2, yVal2]; strs[xVal2, yVal2]= strs[xVal, yVal]; strs[xVal, yVal] = temp; //a játék végének ellenőrzése int db = 0; for(int i = 0; i < N; i++) for(int j = 0; j < M; j++) if (strs[i,j] == celAllapot[i,j].ToString()) db++; if(db==9) { //ha a mesterséges intelligencia már játszott if(mainfrm->lbl_MILepesSzam->Text != " ") { //ha a mesterséges intelligencia lépésszámai nagyobbak, akkor vesztett if(Convert::ToInt32(mainfrm->lbl_HLepesSzam->Text) < Convert::ToInt32(mainfrm->lbl_MILepesSzam->Text)) { //játékos pontszámainak növelése H_PontSzam++; mainfrm->lbl_HPontSzam->Text = H_PontSzam.ToString(); mainfrm->lbl_HPontSzam->Refresh(); MessageBox::Show("Nyertél! Gratulálok! Köszönöm a játékot.", "Játék vége!", MessageBoxButtons::OK, MessageBoxIcon::Information); } //ha döntetlen else if(Convert::ToInt32(mainfrm->lbl_HLepesSzam->Text) == Convert::ToInt32(mainfrm->lbl_MILepesSzam->Text)) { MessageBox::Show("Az eredmény döntetlen!", "Játék vége!", MessageBoxButtons::OK, MessageBoxIcon::Information); } //egyébként a játékos vesztett else {

294

MessageBox::Show("A mesterséges intelligencia nyert!", "Játék vége!", MessageBoxButtons::OK, MessageBoxIcon::Information); //a mesterséges intelligencia pontjainak növelése cObj->IncPontszam(); } } //egyébként a vezérlés átadása a mesterséges intelligenciának else kesz = true; if (kesz) cObj->BestFirst(kevert); } } //---------------------------------------------------------------------------------- void Player::IncPontszam() //---------------------------------------------------------------------------------- { //játékos pontszámának növelése H_PontSzam++; //lépésszámot kijelző címke értékadása mainfrm->lbl_HPontSzam->Text = H_PontSzam.ToString(); //lépésszámot kijelző frissítése mainfrm->lbl_HPontSzam->Refresh(); } //---------------------------------------------------------------------------------- int Player::Heuristic(array<String ^,2> ^ start, array<int,2> ^ goal) //---------------------------------------------------------------------------------- { //heurisztika kinullázása int koltseg = 0; for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) //ha a célállapot és az aktuális állapot eleme megegyezik if (Convert::ToInt32(start[i,j]) != goal[i,j] && Convert::ToInt32(start[i,j])!=0) //növeljük a költséget koltseg++; } //aktuális költség visszaadása return koltseg; } }

Computer osztály implementálálsa (Computer.cpp)

/************************************************************************************ * Computer osztály implementálása * * Demonstrációs célok: * * -> OOP hasznosítása Windows Forms Application alkalmazásokban * * -> vezérlők eseményeinek összehangolása * * -> Tili-Toli probléma megoldása legjobbat először algoritmussal * * * * Katona József <katona.jozsef.duf@freemail.hu> * *************************************************************************************/ #include "stdafx.h" //precompiled header

295

#include "Computer.h" //Computer osztály deklarációi #include "frmMain.h" //frmMain osztály deklarációi #include "Player.h" //Player osztály deklarációi //=================================================================================== namespace WFA_13 { //=================================================================================== //generikus gyűjteményeket tartalmazó névtér using namespace System::Collections::Generic; using namespace std; //------------------------------------------------------------------------------------ Computer::Computer(frmMain^ frm) //------------------------------------------------------------------------------------ { //az ablak tulajdonságainak beállítása this->mainfrm = frm; //a játékos játékterület gombjainak inicializálása (3x3=9) this->MI_Gombok = gcnew array<System::Windows::Forms::Button^,2>(N,M); //véletlenszám generátor inicializálása this->randObj = gcnew Random; } //------------------------------------------------------------------------------------ void Computer::GombokInicial() //------------------------------------------------------------------------------------ { //a lokális célvektor array<int,2> ^ celAllapot = gcnew array<int,2> { {1,8,7}, {2,0,6}, {3,4,5} }; for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { //mesterséges intelligencia gombjainak inicializálása this->MI_Gombok[i,j] = gcnew System::Windows::Forms::Button(); //mesterséges intelligencia gombjainak szélesség beállítása this->MI_Gombok[i,j]->Width = mainfrm->panel2->Width/3; //mesterséges intelligencia gombjainak magasság beállítása this->MI_Gombok[i,j]->Height = mainfrm->panel2->Height/3; //mesterséges intelligencia gombjainak bal szélének pozíciója this->MI_Gombok[i,j]->Left = i * MI_Gombok[i,j]->Width; //mesterséges intelligencia gombjainak felső szélének pozíciója this->MI_Gombok[i,j]->Top = j * MI_Gombok[i,j]->Height; //mesterséges intelligencia gombjainak betűtípus beállítása this->MI_Gombok[i,j]->Font = gcnew Font("Viner Hand ITC", 36, FontStyle::Bold); //mesterséges intelligencia gombjainak háttérszín beállítása this->MI_Gombok[i,j]->BackColor = Color::Transparent; //mesterséges intelligencia gombok szöveg tulajdonságainak beállítása this->MI_Gombok[i,j]->Text = celAllapot[i,j].ToString(); //a mesterséges intelligencia gombjainak elérésének tiltása this->MI_Gombok[i,j]->Enabled = false; //gombok felhelyezése a panel-ra this->mainfrm->panel2->Controls->Add(this->MI_Gombok[i,j]); } }

296

NullaBeallit(); } //----------------------------------------------------------------------------------- void Computer::NullaBeallit() //----------------------------------------------------------------------------------- { for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { //ha megtaláltuk a nulla helyét if(MI_Gombok[i,j] -> Text == "0") { //a mesterséges intelligencia gombját tegyük láthatatlanná MI_Gombok[i,j] -> Visible = false; //frissítsük a mezőt MI_Gombok[i,j] -> Update(); } //ha a vizsgált elem nem nulla, akkor else { //a gomb látható MI_Gombok[i,j] -> Visible = true; //frissítsük a mezőt MI_Gombok[i,j] -> Update(); } } } } //---------------------------------------------------------------------------------- bool Computer::MI_GombokStart(Player ^ pParam, array<int> ^ start) //---------------------------------------------------------------------------------- { //a játékos osztály objektumpéldányának inicializálása this->pObj = pParam; //az összekevert gombok tárolásához szükséges vektor létrehozása array<int> ^ kevert = start; //ha a legjobbat először algoritmus elboldogul, akkor kezhetjük a játékot MI_LepesSzam = 0; mainfrm->lbl_MILepesSzam->Text = " "; mainfrm->lbl_MILepesSzam->Refresh(); //ha a legjobbat először algoritmus igazzal tér vissza if(getBestFirst(kevert)) { int index = 0; for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { //az összekevert gombok értékeinek átadása a gomb szöveg tulajdonságainak this->MI_Gombok[i,j]->Text = Convert::ToString(kevert[index]); //a játékos gombjainak frissítése this->MI_Gombok[i,j]->Update(); index++; } }

297

NullaBeallit(); return true; } //ellenkező esetben új játékteret generálunk else { int index = 0; for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { //az összekevert gombok értékeinek átadása a gomb szöveg tulajdonságainak this->MI_Gombok[i,j]->Text = Convert::ToString(kevert[index]); //a játékos gombjainak frissítése this->MI_Gombok[i,j]->Update(); index++; } } NullaBeallit(); return false; } } //---------------------------------------------------------------------------------- bool Computer::getBestFirst(array<int> ^ start) //---------------------------------------------------------------------------------- { //a lokális célvektor létrehozása array<int,2> ^ celAllapot = gcnew array<int,2>(N,M) { {1,8,7}, {2,0,6}, {3,4,5} }; //az összekevert gombok tárolásához szükséges vektor létrehozása array<int,2> ^ kevert = gcnew array<int,2>(N,M); int index = 0; for(int i=0; i<N; i++) { for(int j=0; j<M; j++) { kevert[i,j] = start[index]; index++; } } //gráfunk egy csomópontja array<int,2> ^ csomopont; //nyitott gráfcsomópontok (kifejtésre váró) List <array<int,2>^> ^ OpenList = gcnew List <array<int,2>^>(); //már megvizsgált csomópontok (kezdetben a start csomópontot tartalmazza) List <array<int,2>^> ^ CloseList = gcnew List <array<int,2>^>(); //az első kifejtésre váró gráfcsomópontot (gyökér) //hozzáadása a nyitott gráfok listájához OpenList->Add(kevert); bool kesz = false; //a minimum kereséshez inicializálunk egy változót int min = 100; //a zárt (kifejtett) csomópontok darabszámának nyílvántartása

298

int closeSum = 0; //amíg van nyitott gráfcsomópont do { //elkezdjük kipakolni az elemeket a nyitott listából for each (array<int,2> ^ aktElem in OpenList) { //ha a heurisztikát számoló függvény azt mondja, //hogy kisebb költségű, mint az eddig legkisebb if ((Heuristic(aktElem, celAllapot)) <= min) { if((InOpenList(aktElem,OpenList))) { //akkor a minimális költségnek ezt az értéket állítjuk be min = (Heuristic(aktElem, celAllapot)); //ha elértük a célt, akkor visszaadjuk azt, hogy van megoldás //új gráfcsomópont inicializálása csomopont = gcnew array <int,2>(N,M); //a legkisebb költségű elemet veszem ki az OpenListből csomopont = aktElem; } } } //majd átteszük a kifejtett csomópontok közé if(InCloseList((csomopont),CloseList)) { CloseList->Add(csomopont); closeSum++; } else closeSum = 0; //az openlist tiszítása az újabb szinthez OpenList->Clear(); //ha tudok fellépni if(CsereFel(csomopont)!=nullptr) { //ha még nem szerepelt a csomópont a kifejtések között, //tehát nem található a már kifejtettek között if(InCloseList((CsereFel(csomopont)),CloseList)) //akkor adjuk hozzá a nyitott csomópontok listájához OpenList->Add(CsereFel(csomopont)); } //ha tudok le lépni if(CsereLe(csomopont)!=nullptr) { //ha még nem szerepelt a csomópont a kifejtések között, //tehát nem található a már kifejtettek között if(InCloseList((CsereLe(csomopont)),CloseList)) { //akkor adjuk hozzá a nyitott csomópontok listájához OpenList->Add(CsereLe(csomopont)); } } //ha tudok balra lépni if(CsereBalra(csomopont)!=nullptr) { //ha még nem szerepelt a csomópont a kifejtések között, //tehát nem található a már kifejtettek között

299

if(InCloseList((CsereBalra(csomopont)),CloseList)) { //akkor adjuk hozzá a nyitott csomópontok listájához OpenList->Add(CsereBalra(csomopont)); } } //ha tudok jobbra lépni if(CsereJobbra(csomopont)!=nullptr) { //ha még nem szerepelt a csomópont a kifejtések között, //tehát nem található a már kifejtettek között if(InCloseList((CsereJobbra(csomopont)),CloseList)) { //akkor adjuk hozzá a nyitott csomópontok listájához OpenList->Add(CsereJobbra(csomopont)); } } int db = 0; for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if (csomopont[i,j] == celAllapot[i,j]) db++; if(db==9) kesz = true; if(closeSum == 0) return false; }while (!kesz); //ha végig vizsgáltuk az összes legjobb költségű //csomópontot, de nincs meg a cél, akkor újra keverünk return kesz; } //---------------------------------------------------------------------------------- void Computer::BestFirst(array<int> ^ start) //---------------------------------------------------------------------------------- { //a lokális célvektor létrehozása array<int,2> ^ celAllapot = gcnew array<int,2>(N,M) { {1,8,7}, {2,0,6}, {3,4,5} }; //az összekevert gombok tárolásához szükséges vektor létrehozása array<int,2> ^ kevert = gcnew array<int,2>(N,M); int index = 0; for(int i=0; i<N; i++) { for(int j=0; j<M; j++) { kevert[i,j] = start[index]; index++; } } //gráfunk egy csomópontja array<int,2> ^ csomopont; //nyitott gráfcsomópontok (kifejtésre váró) List <array<int,2>^> ^ OpenList = gcnew List <array<int,2>^>(); //már megvizsgált csomópontok (kezdetben a start csomópontot tartalmazza) List <array<int,2>^> ^ CloseList = gcnew List <array<int,2>^>(); //az első kifejtésre váró gráfcsomópontot (gyökér)

300

//hozzáadása a nyitott gráfok listájához OpenList->Add(kevert); GombokFrissit(kevert); bool kesz = false; //amíg van nyitott gráfcsomópont //a minimum kereséshez inicializálunk egy változót int min = 100; do { //elkezdjük kipakolni az elemeket a nyitott listából for each (array<int,2> ^ aktElem in OpenList) { //ha a heurisztikát számoló függvény azt mondja, //hogy kisebb költségű, mint az eddig legkisebb if ((Heuristic(aktElem, celAllapot) <= min)) { //ha az aktuális elem benne van a nyitott gráfok listájában if(InOpenList(aktElem,OpenList)) { min = (Heuristic(aktElem, celAllapot)); //a heurisztikát kiíró cimke aktualizálása mainfrm->MIaktHeurisztika->Text = min.ToString(); mainfrm->MIaktHeurisztika->Refresh(); //új gráfcsomópont inicializálása csomopont = gcnew array <int,2>(N,M); //a legkisebb költségű elemet veszem ki az OpenListből csomopont = aktElem; } } } GombokFrissit(csomopont); System::Threading::Thread::Sleep(200); mainfrm->lbl_MILepesSzam->Text = (MI_LepesSzam++).ToString(); mainfrm->lbl_MILepesSzam->Refresh(); //majd átteszük a kifejtett csomópontok közé CloseList->Add(csomopont); //az openlist tiszítása az újabb szinthez OpenList->Clear(); //ha tudok fellépni if(CsereFel(csomopont)!=nullptr) { //ha még nem szerepelt a csomópont a kifejtések között, //tehát nem található a már kifejtettek között if(InCloseList((CsereFel(csomopont)),CloseList)) //akkor adjuk hozzá a nyitott csomópontok listájához OpenList->Add(CsereFel(csomopont)); } //ha tudok le lépni if(CsereLe(csomopont)!=nullptr) { //ha még nem szerepelt a csomópont a kifejtések között, //tehát nem található a már kifejtettek között if(InCloseList((CsereLe(csomopont)),CloseList)) //akkor adjuk hozzá a nyitott csomópontok listájához OpenList->Add(CsereLe(csomopont)); } //ha tudok balra lépni

301

if(CsereBalra(csomopont)!=nullptr) { //ha még nem szerepelt a csomópont a kifejtések között, //tehát nem található a már kifejtettek között if(InCloseList((CsereBalra(csomopont)),CloseList)) //akkor adjuk hozzá a nyitott csomópontok listájához OpenList->Add(CsereBalra(csomopont)); } //ha tudok jobbra lépni if(CsereJobbra(csomopont)!=nullptr) { //ha még nem szerepelt a csomópont a kifejtések között, //tehát nem található a már kifejtettek között if(InCloseList((CsereJobbra(csomopont)),CloseList)) //akkor adjuk hozzá a nyitott csomópontok listájához OpenList->Add(CsereJobbra(csomopont)); } //eredmény végének ellenőrzése int db = 0; for(int i = 0; i < N; i++) for(int j = 0; j < M; j++) if (csomopont[i,j] == celAllapot[i,j]) db++; //ha célállapot if(db==9) { //akkor készen vagyunk kesz = true; //amennyiben a játékos kezdett if(mainfrm->lbl_HLepesSzam->Text != " ") { //ha a játékos lépésszáma nagyobb, mint a mesterséges //intelligencia lépésszáma, akkor a számítógép nyert if(Convert::ToInt32(mainfrm->lbl_HLepesSzam->Text) > Convert::ToInt32(mainfrm->lbl_MILepesSzam->Text)) { MI_PontSzam++; mainfrm->lbl_MIPontSzam->Text = MI_PontSzam.ToString(); mainfrm->lbl_MIPontSzam->Refresh(); MessageBox::Show("A mesterséges intelligencia nyert!", "Játék vége!", MessageBoxButtons::OK, MessageBoxIcon::Information); } //ha döntetlen az eredmény, akkor senki nem kap pontot else if(Convert::ToInt32(mainfrm->lbl_HLepesSzam->Text) == Convert::ToInt32(mainfrm->lbl_MILepesSzam->Text)) { MessageBox::Show("Az eredmény döntetlen!", "Játék vége!", MessageBoxButtons::OK, MessageBoxIcon::Information); } //ha a játékos nyert else { MessageBox::Show("Nyertél! Gratulálok! Köszönöm a játékot.", "Játék vége!", MessageBoxButtons::OK, MessageBoxIcon::Information); pObj->IncPontszam(); }

302

} else MessageBox::Show("A mesterséges intelligencia elkészült, most Te jössz!", "Információ", MessageBoxButtons::OK, MessageBoxIcon::Information); } }while (!kesz); } //--------------------------------------------------------------------------------- void Computer::IncPontszam() //--------------------------------------------------------------------------------- { //mesterséges intelligencia pontszámainak növelése MI_PontSzam++; //a pontszám érték megjelenítése mainfrm->lbl_MIPontSzam->Text = MI_PontSzam.ToString(); mainfrm->lbl_MIPontSzam->Refresh(); } //---------------------------------------------------------------------------------- int Computer::Heuristic(array<int,2> ^ start, array<int,2> ^ goal) //---------------------------------------------------------------------------------- { //a költséges nulláról indítjuk int koltseg = 0; for(int i = 0; i < N; i++) for(int j = 0; j < M; j++) //ha az aktuális állás nem egyenlő a célállapottal //és a vizsgált elem nem nulla if (start[i,j] != goal[i,j] && start[i,j]!=0) //a koltséget növeljük egy egységgel koltseg++; //adjuk vissza a vizsgált állapot költségét return koltseg; } //--------------------------------------------------------------------------------- array<int,2> ^ Computer::CsereFel(array<int,2> ^ aktMatrix) //--------------------------------------------------------------------------------- { //segéd mátrix definiálása array<int,2> ^ matrix = gcnew array <int,2>(N,M); //segéd mátrix inicializálása for(int i=0; i<N; i++) for(int j=0; j<M; j++) matrix[i,j] = aktMatrix[i,j]; for(int i=0; i < N; i++) { for(int j=0; j < M; j++) { //ha a vizsgált elem lyuk és nem //megyünk ki a pályáról if(matrix[i,j] == 0 && j > 0) {

303

//cseréljük meg a lenti elemet //a felső lyukkal int temp = matrix[i,j-1]; matrix[i,j-1] = matrix[i,j]; matrix[i,j] = temp; //a felcserélt mátrix visszaadása return matrix; } } } //ha a vizsgált állapot nem jöhet létre //adjunk vissza null értékre mutató pointer-t return nullptr; } //--------------------------------------------------------------------------------- array<int,2> ^ Computer::CsereLe(array<int,2> ^ aktMatrix) //--------------------------------------------------------------------------------- { //segéd mátrix definiálása array<int,2> ^ matrix = gcnew array <int,2>(N,M); //segéd mátrix inicializálása for(int i=0; i<N; i++) for(int j=0; j<M; j++) matrix[i,j] = aktMatrix[i,j]; for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { //ha a vizsgált elem lyuk és nem //megyünk ki a pályáról if(matrix[i,j] == 0 && j < 2) { //cseréljük meg a fenti elemet //az alsó lyukkal int temp = matrix[i,j+1]; matrix[i,j+1] = matrix[i,j]; matrix[i,j] = temp; //a felcserélt mátrix visszaadása return matrix; } } } //ha a vizsgált állapot nem jöhet létre //adjunk vissza null értékre mutató pointer-t return nullptr; } //--------------------------------------------------------------------------------- array<int,2> ^ Computer::CsereBalra(array<int,2> ^ aktMatrix) //--------------------------------------------------------------------------------- { //segéd mátrix definiálása array<int,2> ^ matrix = gcnew array <int,2>(N,M); //segéd mátrix inicializálása for(int i=0; i<N; i++)

304

for(int j=0; j<M; j++) matrix[i,j] = aktMatrix[i,j]; for(int i=0; i<N; i++) { for(int j=0; j<M; j++) { //ha a vizsgált elem lyuk és nem //megyünk ki a pályáról if(matrix[i,j] == 0 && i > 0) { //cseréljük meg a jobb elemet //a baloldali lyukkal int temp = matrix[i-1,j]; matrix[i-1,j] = matrix[i,j]; matrix[i,j] = temp; //a felcserélt mátrix visszaadása return matrix; } } } //ha a vizsgált állapot nem jöhet létre //adjunk vissza null értékre mutató pointer-t return nullptr; } //--------------------------------------------------------------------------------- array<int,2> ^ Computer::CsereJobbra(array<int,2> ^ aktMatrix) //--------------------------------------------------------------------------------- { //segéd mátrix definiálása array<int,2> ^ matrix = gcnew array <int,2>(N,M); //segéd mátrix inicializálása for(int i=0; i<N; i++) for(int j=0; j<M; j++) matrix[i,j] = aktMatrix[i,j]; for(int i=0; i<N; i++) { for(int j=0; j<M; j++) { //ha a vizsgált elem lyuk és nem //megyünk ki a pályáról if(matrix[i,j] == 0 && i < 2) { //cseréljük meg a bal elemet //a jobboldali lyukkal int temp = matrix[i+1,j]; matrix[i+1,j] = matrix[i,j]; matrix[i,j] = temp; //a felcserélt mátrix visszaadása return matrix; } } } //ha a vizsgált állapot nem jöhet létre //adjunk vissza null értékre mutató pointer-t return nullptr;

305

} //--------------------------------------------------------------------------------- bool Computer::InOpenList(array<int,2> ^ aktMatrix, List <array<int,2>^> ^ OpenList) //--------------------------------------------------------------------------------- { bool open_ok = false; //segéd mátrix definiálása array<int,2> ^ x = gcnew array <int,2>(N,M); //segéd mátrix inicializálása for(int i=0; i<N; i++) for(int j=0; j<M; j++) x[i,j] = aktMatrix[i,j]; //kivesszük a nyitott gráf listának az elemeit for each (array<int,2> ^ element in OpenList) { int db = 0; for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) //ha a nyitott gráf megyezik az aktuálsian //vizsgált mátrixxal, növeljük a darabszámot if (element[i,j] == x[i,j]) db++; //ha darab eléri a kilencet, akkor benne van a listában //egyébként hamissal térünk vissza if(db==9) open_ok = true; } //adjuk vissza annak értékét, hogy a vizsgált //csomópont benne van-e a nyitott gráfok listájában return open_ok; } //--------------------------------------------------------------------------------- bool Computer::InCloseList(array<int,2> ^ aktMatrix, List <array<int,2>^> ^ CloseList) //--------------------------------------------------------------------------------- { bool close_ok = true; //segéd mátrix definiálása array<int,2> ^ x = gcnew array <int,2>(N,M); //segéd mátrix inicializálása for(int i=0; i<N; i++) for(int j=0; j<M; j++) x[i,j] = aktMatrix[i,j]; //kivesszük a lezárt gráfok elemeit for each (array<int,2> ^ element in CloseList) { int db = 0; for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) //ha a már vizsgált gráf megyezik az aktuálsian //vizsgált mátrixxal, növeljük a darabszámot if (element[i,j] == x[i,j]) db++; //ha darab eléri a kilencet, akkor benne van a listában //egyébként hamissal térünk vissza if(db==9) close_ok = false; }

306

//adjuk vissza annak értékét, hogy a vizsgált //csomópont benne van-e a már vizsgált gráfok listájában return close_ok; } //---------------------------------------------------------------------------------- void Computer::GombokFrissit(array<int,2> ^ aktMatrix) //---------------------------------------------------------------------------------- { //gombok állapotának frissítése for(int i = 0; i < N; i++) { for(int j = 0; j < M; j++) { MI_Gombok[i,j]->Text = aktMatrix[i,j].ToString(); MI_Gombok[i,j]->Update(); } } //frissítsük a nulla helyét NullaBeallit(); } }