Mine

#include <stdio.h>  /* printf-nek */#include <stdlib.h> /* Memóriakezelésnek */#include <limits.h> /* Az INT_MAX-nak */struct stack{	int elements;	char* pData;};/* Általános megállapodások.1. Ha a stack üres, a pData NULL, az elements 0.2. Az pData mutat az elemek tömbjére, dinamikus memóriafoglalással.3. Az elements jelzi az stackben lévo aktuális elemek számát.4. A függvények karbantartják a dinamikus memóriaterületet5. A stack használata elott a meg kell hívni a void stack_init(struct stack* s)-et.6. A stack használata után meg kell hívni a void stack_cleanUp(struct stack* s)-t.7. A függvények visszatérése hiba esetén nem nulla*///3. feladat fv-e(fv túlterhelés)void stack_init(struct stack &s, struct stack &theOther);void stack_init(struct stack &s){	/* Mivel alapértelmezésben a stack két változójának értékei véletlenszámok,	   inicializálni kell oket. Üres stackkel indulunk.	*/	// 1. Az s.elements beállítása	s.elements=0;		// 2. Az s.pData beállítása	s.pData=NULL;	}void stack_init(struct stack &s, struct stack &theOther){	char *ptrTemp;	int i;	ptrTemp=(char*)malloc(theOther.elements*sizeof(char));	for(i=0;i<theOther.elements;i++)	{		ptrTemp[i]=theOther.pData[i];	}	s.elements=theOther.elements;	s.pData=ptrTemp;}void stack_cleanUp(struct stack &s){	/* Mivel dinamikus adatterülete foglalunk le, a stack használata után	   fel kell szabadítani ezeket*/	// 1. Az s.elements beállítása	s.elements=0;		// 2. Az s.pData felszabadítása, ha nem NULL	if (s.pData) free(s.pData);		// 3. Az s.pData értékének beállítása	s.pData=NULL;	}int stack_push(struct stack &s, char newElement){	/* Itt új elemet fuzünk az s.pData végére. Ehhez lefoglalunk	   eggyel nagyobb méretu helyet egy ideiglenes mutatóval, majd	   átmásoljuk bele a s.pData eddigi tartalmát, hozzáfuzzük az	   új elemet, és felszabadítjuk az eredeti s.pData területét.	   Utána s.pDatat átirányítjuk az ideiglenes pointer által	   mutatott területre.   */	// Az ideiglenes mutató	char *ptrTemp;	// Ciklusváltozó a másoláshoz	int i;	// 1. Ha az s.elements értéke INT_MAX, a stack betelt (különben túlcsordulás lenne)	// Ilyenkor -1 hibával térünk vissza	if (s.elements==INT_MAX) return -1;		// 2. Eggyel nagyobb helyet foglalunk az ideiglenes pointer (ptrTemp) segítségével	ptrTemp=(char*)malloc(((s.elements)+1)*sizeof(char));		// 3. Egy for ciklussal átmásoljuk az s.pData tartalmát a ptrTemp által mutatott	// területre.	for(i=0;i<s.elements;i++)	{		ptrTemp[i]=s.pData[i];	}			// 4. Az újonan foglalt terület végére rakjuk az új elemet (newElement)		ptrTemp[s.elements]= newElement;	// 5. Ha mutatott valahova elozoleg a pData, felszabadítjuk 	if (s.pData) free(s.pData);		// 6. Átállítjuk az s.pData pointert az újonnan lefoglalt területre (ptrTemp)	s.pData=ptrTemp;	// 7. Beállítjuk az elemszám (s.elements) új értékét	s.elements++;	return 0;}int stack_pop(struct stack &s){	/* Ha nem üres a stack, kivesszük az utolsóként berakott elemet	   a tömb végérol. Lefoglalunk eggyel kisebb tárhelyet, átmásoljuk	   az adatokat, felszabadítjuk az eredetit. Ha kiürül a stack, 	   a megállapodásnak megfeleloen állítjuk be az s truktúra adattagjait.*/		// Az ideiglenes mutató és a visszatérési érték	char *ptrTemp, value;	// Ciklusváltozó a másoláshoz	int i;	// 1. Ha a stack üres -1-gyel visszatérünk	if (s.elements==0) return -1;		// 2. A value értéke az utolsóként betett elem, a tömb vége	value=(s.pData[(s.elements)-1]);		// 3. Az s.elements értékét beállítjuk az új szituációnak megfeleloen	s.elements--;	if(s.elements) // 4a. Ha a tömb ezzel nem lesz üres	{		// 4a1. Az ideiglenes pointer segítségével az új méretnek megfelelo		// helyet foglalunk		ptrTemp=(char*)malloc((s.elements)*sizeof(char));			// 4a2. Átmásoljuk az ideiglenes területre a stackben maradt adatokat		for (i=0;i<s.elements;i++)		{			ptrTemp[i]=s.pData[i];		}			// 4a3. Felszabadítjuk a régi memóriaterületet (s.pData)		free(s.pData);			// 4a4. Átállítjuk az s.pData pointert az újonnan lefoglalt területre (ptrTemp)		s.pData=ptrTemp;		}	else // 4b. Ha a tömb ezzel üres lett	{		// 4b1. Felszabadítjuk az eddigi elemet		free(s.pData);			// 4b2. Beállítjuk az s.pData értékét (az elements már be lett állítva) 		s.pData=NULL;	}	// 5. Visszatérünk a kivett elemmel (value)	return value;	}int stack_isEmpty(struct stack &s){	/* Ha üres a stack, nullával tér vissza, egyébként nem. */	if (s.elements==0) return 0;	else return 1;	}int main(void){	struct stack s;	struct stack theOther; //a másik verem	int be; //getchar()-hoz (menü) kell	char i;	printf("STACK\n");	printf("=====\n\n\n");	printf("MENU\n");	printf("----\n\n");	printf("1. Stack inicializalasa(ures stack)\n");	printf("2. Stack inicializalasa(masolas a theOther verembol)\n");	printf("0. Kilepes a programbol\n\n");	printf("A valasztasa: ");	while ((be=getchar()) != 10)	{		if (be==48) return 0;		else if (be==49)		{			printf("\nInitializing stack...\n");			stack_init(s);		}		else if (be==50)		{	//////////////////////////////	//theOther feltöltése az ABC betuivel foraditva//	printf("\nInitializing stack(with 'theOther')...\n");	int ellenoriz;	for (i='Z';i>='A';i--)	{		printf("push: %c\n",i);		ellenoriz=stack_push(theOther,i);	}	//Ellenöriznünk kell, hogy a stach_push rendben lezajlott-e.	//Ha 0-t kapunk vissza, igen, különben nem, tehát kilépünk.	if (ellenoriz!=0) 	{printf("\n\nHiba tortent! A program futasa megszakad.");exit(-1);}	//Ellenörzés vége	printf("\nInitialization completed.\n\n");	//theOther feltöltve//	//////////////////////////////	stack_init(s,theOther); //meghívjuk a túlterhelt init fv-t		}	else 	{		printf("\n\nHelytelen valsztas! A program futasa megszakad.\n");		return 0;	}	} //Menü vége		for(i='A';i<='Z';i++)	{				printf("push: %c\n",i);		// Itt nézzük a s.pData változót debuggerbol, lépjünk bele a függvénybe		stack_push(s,i);			}	while(stack_isEmpty(s))	{		// Itt nézzük a s.pData változót debuggerbol, lépjünk bele a függvénybe		printf("pop: %c\n",(char)stack_pop(s));	}	// Üres stackbol kivétel: hiba (-1)	printf("pop: %d\n",stack_pop(s));		printf("Cleaning up stack...\n");	stack_cleanUp(s);	return 0;}