// fejállományok: <> rendszer, "" saját
// #include "sajat.h"
#include <stdio.h>	// printf(), sizeof()


// definició, előfordításkor behelyettesítődik
// nem szabad ; lezárni
#define PI 3.14159

// Szinonim típusnév
typedef unsigned char byte;

// globális változók helye

// főprogram
int main(void)					// a program belépési pontja
{
	printf("Hello MOGI :)\n");	// kiíratás a konzolra, \n új sor
	
	//lokális változók
	int a;						// egész változó
	const int b = -20;			// konstans, kötelező értéket adni
	unsigned int egesz, Egesz;	// kis/nagy betűk megkülönböztetve

	egesz = 20;		// 20 - decimális
	Egesz = 0xA;	// 10 - hexadecimális
	Egesz = 0111;	// 73 - oktális
	Egesz = 0b111;	// 7 - bináris

	Egesz = b;	// értékadás (signed -> unsigned) ?

	//b = 2;   // b csak olvasható

	a = 30;

	printf("a erteke: %d \n", a);				// %d vagy %i egész
	printf("a erteke oktalisan: 0%o \n", a);		// %o oktális
	printf("a erteke hexadecimalisan: 0x%x \n", a);	// %x vagy %X hexa
	printf("a merete a memoriaban: %i byte\n", sizeof(a));	//sizeof változó vagy típus mérete
	printf("short int merete a memoriaban: %i byte\n", sizeof(short int));
	printf("long long merete a memoriaban: %i byte\n", sizeof(long long));	// szám LL

	printf("a = %d, b = %d\n", a, b);			// annyi változó, ahány a formátumban szerepel

	double tort = 3.14;		// tizedestört mindig .

	printf("tort erteke: %f\n", tort);		// float
	printf("tort erteke: %5.1f\n", tort);	// 1 tizedes, 5 összes
	printf("tort erteke: %.1f\n", tort);	// 1.tizedes
	printf("tort erteke: %e\n", tort);		// normál alak %e vagy %E
	printf("tort erteke: %g\n", tort);		// amelyik rövidebb: %e vagy %f
	printf("double merete: %d byte\n", sizeof(tort));

	float pi = 3.14159f;	// float szám után f!

	printf("a pi erteke: %.4f\n", pi);
	printf("a pi erteke: %.4f\n", PI);		// PI definició behelyettesítődik
	printf("float merete: %d byte\n", sizeof(float));

	char c = 67;			// ASCII karakter 'C'

	printf("c erteke: %d \n", c);
	printf("c ASCII karaktere: %c \n", c);
	printf("char merete: %d byte\n", sizeof(char));

	byte adat = 256;	//0..255

	return 0;
}

// Matematikai konstansok definicióinak használata <math.h> elött
// pl.: M_PI
#define _USE_MATH_DEFINES

#include <stdio.h>	// printf, scanf(_s)
#include <math.h>	// matematikai készlet

#define PI 3.14159
#define DUPLA(x) x*2

typedef unsigned char byte;

//globális változók
int egesz;
double tort = PI;
const unsigned int konstans = 3;

int main(void)
{
	//globális változó akkor is használható, ha nincs kezdeti értéke
	printf("egesz erteke: %i", egesz);

	//lokális változók (printf elött értéket kell adni neki)
	int i = 10;		// értékadás
	double d = i;	// implicit típus-átalakítás (kicsi -> nagy)
	float f = (float)d;	// explicit típus-átalakítások
	f = (float)42.56; // vagy 42.56f
	i = (int)f;		// adatvesztés, eltűnik a törtrész

	// változók hatóköre
	{
		int i = 5;
		int z = 10;	// z változó a hatókörön kívül nem lesz használható
		printf("belso i erteke: %i z = %i\n", i, z);
	}
	//itt már nincs z változó, és i is a külsõ változó lesz
	printf("kulso i erteke: %i\n", i);

	// bal érték, jobb érték fogalma
	tort = (double)1 / 2;	//vagy  1 / 2.0

	// műveletek sorrendisége + típusok
	tort = (5 + 3 * 2 - 6) / ((double)3 / 2) * 5;

	int a = 10;
	int b;
	a = a + 1;  //a=11;
	// összevont alak +=, -= , *=, /=
	a += 2;		//a=13;

	// egy operandusú műveletek
	a++;		//a=14;
	b = a++;	//b=14 a=15
	b = ++a;	//b=16 a=16

	int db = 21 / 5;			// egész osztás
	int maradek = 21 % 5;		// maradék

	// matematikai műveletek <math.h>
	// sin - szinus radiánban!
	// cos - koszinusz radiánban
	// pow - hatványozás pow(alap, kitevõ)
	// sqrt - gyökvonás
	// exp - e^x
	// log - természetes alapú logaritmus
	// log10 - 10-es alapú logaritmus
	double szamolas = pow(sin(M_PI / 3), (double)2 / 3);	//(sin(PI/3))^(2/3)	

	byte szam = 257;	// 0-255
	szam = 10;
	szam = ~szam;

	b = 0b00000110; //6;
	szam = 10;
	szam |= 1 << 2; //2. bit bebillentése
	szam &= ~(1 << 3); // 3. bit törlése

	int szam_egesz;
	printf("Adjon meg egy egesz szamot: ");
	// érték beolvasása a változóba (címet & kell megadni)
	scanf("%i", &szam_egesz);		// Microsoft biztonságos verzió scanf_s
	printf("A megadott szam: %i\n", szam_egesz);

	double szam_tort;
	printf("Adjon meg egy tort szamot: ");
	scanf("%lf", &szam_tort);			// double/float esetén %lf kell
	printf("A megadott szam: %lf\n", szam_tort);	// itt elgendõ a %f is

	// HF próbálja ki, hogy az egész szám helyébe írjon be 12.345-t
	// mi történt ? mi lehet ennek az oka?

	int ora, perc;
	printf("Kerem adja meg a pontos idot ora:perc alakban: ");
	// több elem beolvasása
	scanf("%i:%i", &ora, &perc);
	printf("A pontos ido: %i:%i\n", ora, perc);

	return 0;
}

#include <stdio.h>
#include <math.h>	// matematikai készlet
#include <math.h>
#include <stdlib.h>		//rand, RAND_MAX

int main(void)
{
	int szam = 14;

	//osztható-e 7-el?
	if (szam % 7 == 0) printf("Oszthato\n");
	else printf("Nem oszthato\n");

	if ((szam % 7 == 0) && (szam % 3 == 0))
	{
		printf("A szam oszthato\n");
	}
	else
	{
		printf("A szam nem oszthato\n");
	}

	szam = 10;
	if (szam) printf("igaz\n");
	if (!szam) printf("hamis?\n");

	double pontszam = 56;
	if (pontszam < 40) printf("Elegtelen\n");
	else if (pontszam < 55) printf("Elegseges\n");
	else if (pontszam < 70) printf("Kozepes\n");
	else if (pontszam < 85) printf("Jo\n");
	else printf("Jeles\n");

	int a = 20, b = 30, c;
	c = (a > b) ? a : b;	//melyik a nagyobb
	printf("c = %d\n", c);

	int jegy = 3;
	switch (jegy)
	{
	case 1:
		printf("Elegtelen\n");
		break;
	case 2:
		printf("Elegseges\n");
		break;
	case 3:
		printf("Kozepes\n");
		break;
	case 4:
		printf("Jo\n");
		break;
	case 5:
		printf("Jeles\n");
		break;
	default:
		printf("Erevenytelen jegy\n");
		break;
	case 0:
		printf("Nem teljesitve\n");
		break;
	}
	jegy > 1 ? printf(", Gratulalunk!") : printf(", Majd legkozelebb..");

	// Állapotok (elnevezett egész számú konstansok)
	enum States {ST_INIT, ST_START, ST_WORK=100, ST_END};
	// állapotváltozó
	enum States STATE = ST_INIT; // kezdeti állapot
	switch(STATE)
	{
	case ST_INIT:
		printf("Init allapot\n");
		STATE = ST_START; // állapot átmenet
		break;
	case ST_START:
		printf("Start allapot\n");
		break;
	case ST_WORK:
		printf("Feldolgozat allapot\n");
		break;
	case ST_END:
		printf("Vege allapot\n");
		break;
	default:
		printf("Ismeretlen allapot\n");
		break;
	}

	/*
	Gyakorlo feladat
	- x változó bekérése
	- megfelelő tartomány meghatározása
	- számítás elvégzése
	- eredmény kiíratása
	*/
	double x, eredmeny;
	printf("Feladat:\nx="); scanf_s("%lf", &x);
	if (x  < -1) eredmeny= cos(x);
	else if (x >= 1) eredmeny = sqrt(x);
	else eredmeny = pow(sin(x), 3);
	printf("A feladat megoldasa:\neredmeny=%6.3lf\n", eredmeny);

	//time_t ido;
	//ido = time(NULL); // 1970. jan 1-től eltelt sec
	//printf("%li\n", ido);
	//srand(ido);  // véletlenszám generálása az idővel
	
	// véletlenszám generálása az idővel
	srand((unsigned int)time(NULL));  // egy lépésben

	int szam = rand();

	printf("%i\n", szam);

	int szam2 = rand();

	printf("%i\n", szam2);

	printf("rand tartomanya 0-%i\n", RAND_MAX);

	szam = rand() % 100;  // 0..99

	szam = rand() % 101;  // 0..100

	printf("%i\n", szam);

	szam = (rand() % 101) - 50;    // -50..50

	// -20..20 2 lépésenként
	szam = 2*((rand()%21)-10);
	printf("%i\n", szam);

	double tort = (double)rand() / RAND_MAX ; // 0..1 közötti tört
	printf("%f\n", tort);

	tort = 10* ((double)rand() / RAND_MAX); // 0..10 közötti tört
	printf("%f\n", tort);

	// [0..10] 0.5 lépésközzel
	tort = (double)(rand() % 21) / 2;
	printf("%f\n", tort);

	return 0;
}		
		
		

		
		

#include <stdio.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>		//rand, RAND_MAX

int main(void)
{
	// véletlenszám generálása az idővel
	srand((unsigned int)time(NULL));  // egy lépésben

	int szam = rand();

	printf("%i\n", szam);

	printf("rand tartomanya 0-%i\n", RAND_MAX);

	szam = rand() % 100;  // 0..99

	szam = rand() % 101;  // 0..100

	printf("%i\n", szam);

	szam = (rand() % 101) - 50;    // -50..50

	// -20..20 2 lépésenként
	szam = 2*((rand()%21)-10);
	printf("%i\n", szam);

	double tort = (double)rand() / RAND_MAX ; // 0..1 közötti tört
	printf("%f\n", tort);

	tort = 10* ((double)rand() / RAND_MAX); // 0..10 közötti tört
	printf("%f\n", tort);

	// [0..10] 0.5 lépésközzel
	tort = (double)(rand() % 21) / 2;
	printf("%f\n", tort);

	// A tippek szamlalasahoz szukseges valtozok
	const int MAXTIPP = 10;			// próbálkozások maximális száma
	int tipp, tippszam = 0;

	// A kisorsolt szám: 1 - 100
	szam = rand() % 100 + 1;	// rand() tartománya 0 - RAND_MAX(32767)

	// Játék indul
	do // hátul tesztelt ciklus, 1x biztosan lefut!
	{
		printf("Kerem a tippet: ");
		scanf_s("%d", &tipp);

		tippszam++;

		if (tipp > szam)
			printf("Tul nagy a tipp!\n");
		else if (tipp < szam)
			printf("Tul kicsi a tipp!\n");

	} while (szam != tipp && MAXTIPP>tippszam);	// ; kell
	
	// Értékelés
	if (szam == tipp)
		printf("Gratulalok, kitalaltad %d lepesben\n", tippszam);
	else
		printf("Sajnos nem sikerult kitalalni, hogy mire gondoltam...\n");


	// Intervallum felezés módszere
	// sin(x) gyökének keresése x1, x2 között
	double x1 = 1;	// kezdet
	double x2 = 4;	// vég
	double xk = (x1 + x2) / 2;	// közép 
	double eps = 1E-12;			// hiba nagysága
	int lepes = 0;

	while (fabs(sin(xk)) > eps && lepes < 1e5)	// elöl tesztelt ciklus
	{
		if (sin(xk)*sin(x1) > 0) x1 = xk;
		else x2 = xk;
		xk = (x1 + x2) / 2;
		lepes++;
		printf("%d. fg(%3.14lf)=%.12lf\n", lepes, xk, sin(xk)); // 3,14159265358979
	} 

	// Számjegyek összege
	int sum = 0;
    printf("Adj meg egy szamot: ");
    scanf_s("%i", &szam);

    while (szam > 0) {
        sum += szam % 10; // Utolso szamjegy hozzaadasa
        szam /= 10;       // Utolso szamjegy levagasa
    }
    printf("A szamjegyek osszege: %i\n", sum);

	// Karakter bekérése ciklussal
	// continue, break, return utasítások
	char c;
	do  
	{
		printf("Haza szeretnel menni? [i/n]");
		//scanf_s("%c", &c);			// több karakter + Enter ütés
		c = _getch();				// csak 1 karakter
		if (c == 'c') continue;		// c esetén újrakezdõdik a ciklus
		printf("%c\n", c);
		if (c == 'I') break;		// kilépés a ciklusból
		if (c == 'x') return -223;	// kilépés a fõprogramból
	} while (c != 'i' && c != 'n' );		// while(1) végtelen ciklus 

	if (c == 'i') printf("Ilyen koran?");

	return 0;
}
		
		

#include <stdio.h>	// printf, scanf(_s)
#include <conio.h>	// getch()
#include <math.h>	    // matematikai készlet
#include <stdlib.h>   // malloc

#define TMERET 10

int main(void)
{
	// Mutató használata
	int i = 100, j;  // lokális statikus változó stack-en
	int* p = NULL;   // pointer 
	p = &i;          // változó címét tárolja
	printf("i=%i &i=%i *p=%i p=%i &p=%p\n", i, &i, *p, p, p);

	i++;            // ha változik a statikus változó
	printf("i=%i *p=%i\n", i, *p);

	*p = 20;        // ha értéket adunk a pointer áltat mutatott változónak
	printf("i=%i *p=%i\n", i, *p);

	// precedencia szabály!!!
	*p++;           // (*p)++ *p+1 *(p+1) melyik mit csinál?
	printf("i=%i *p=%i\n", i, *p);

	// dinamikus terület foglalás heap-re
	double* pd = (double*)malloc(sizeof(double));
	*pd = 43.25;
	printf("%f\n", *pd);
	free(pd);
	// felszabadítás után már nem szabad használni!!
	printf("%f\n", *pd);
	
	// típus nélküli általános pointer
	void* pv = malloc(sizeof(double));
	printf("%x\n", pv);
	*(double*)pv = 43.25;
	printf("%lf\n", *(double*)pv);
	free(pv);
	pv = NULL;

	// Tömb és for ciklus
	int ti[TMERET]; //statikus tömb fix méretű lehet csak
	for (i = 0; i < TMERET; i++)
		ti[i] = i * i;

	for (i = 0; i < TMERET;)
		printf("%d ", ti[i++]);		
	printf("\n");

	// inicializálás
	int ti2[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };   // 10 elemű tömb - statikus
	const int tmeret = sizeof(ti2) / sizeof(ti2[0]); // megadja a tömb méretét  //sizeof(ti2)/sizeof(int)
	
	for (i = 0; i < tmeret; i++)
	    printf("%i ", ti2[i]);  //előre
	printf("\n");

	for (i = tmeret - 1; i >= 0; i--)
	    printf("%d ", ti2[i]); //visszafelé
	printf("\n");

	p = ti2;    // végigjárás pointerrel - pointer a tömb elejére irányítva
	for (i = 0; i < tmeret; i++)
	    printf("%i ", *(p++));  // *p++ is elég

	p = &ti2[tmeret - 1];  // visszafelé - pointer a tömb végére irányítva
	for (i = 0; i < tmeret; i++)
		printf("%d ", *(p--));
	printf("\n");

	// dinamikus tömbkezelés
	int* pi = (int*)malloc(tmeret * sizeof(int)); //10 elemű tömb - dinamikus
	for (i = 0, j = tmeret - 1; i < tmeret; i++, j--)
		pi[i] = ti[j]; // pi[i] = *(ti+i)

	for (i = 0; i < tmeret; i++)
		printf("%i ", *(pi + i));
	printf("\n");

	free(pi);    // felszabadítás, pi-t nem szabad elmozdítani

	return 0;
}		
		
	
		
		

#include <stdio.h>   // printf, scanf(_s)
#include <stdlib.h>  // RANAD_MAX, malloc
#include <time.h>	   // time

#define TMERET 10

//Struktúra
struct p2D {
	double x;
	double y;
	//int index;  //további adatok
};

//Állnév
typedef unsigned int byte;

//Stuktúra állnévvel
typedef struct {
	int x, y;
} pixel_t;

int main(void)
{
	int i;
	srand((unsigned int)time(NULL));

	// statikus tömb
	double st[TMERET];
	double * pp = st;		// végigjárás pointerrel
	for (i = 0; i<TMERET; i++)
		*(pp++) = (double)(rand() % 201) / 2 ;		//st[i]
	// a program végéig megmarad!!!!;
	printf("statikus tomb: %x\n", st);

	// dinamikus tömb
	int meret = 1000;
	double * dt = (double *)malloc(meret * sizeof(double));
	printf("dinamikus tomb: %x\n", dt);
	for (i = 0; i<meret; i++)
		dt[i] = (double)rand() / RAND_MAX * 1000;
	// nem marad meg!!!!;
	free(dt);

	// Összegzés
	double osszeg = 0;
	for (i = 0; i < TMERET; i++)
		osszeg += st[i];
	printf("Az osszeg: %lf\n", osszeg);

	// Megszámolás
	int db = 0;
	for (i = 0; i < TMERET; i++)
		if (st[i] < 50) db++;
	printf("A 50-nel kisebb szamok: %d\n", db);

	// HF: tömb elemének megkeresése -> van / nincs
	//     tömb elemének megkeresése -> hely indexe / -1 ha nincs
	//     tömb elemeinek átlaga
	//     tömb legnagobb eleme
	//     tömb legkisebb eleme

	// Buborék rendezés
	int j;
	double tmp;
	for (i = TMERET - 1; i>0; i--){
		for (j = 0; j<i; j++){
			if (st[j] > st[j + 1])
			{
				tmp = st[j];
				st[j] = st[j + 1];
				st[j + 1] = tmp;
			}
		}
	}
	printf("Rendezeve:\n");
	for (i = 0; i<TMERET; i++)
		printf("%.1lf ", st[i]);
	printf("\n");

	// statikus 2d-s tömb
	int tb[3][4] = { { 1, 2, 3, 4 },
	{ 2, 3, 4, 5 },
	{ 3, 4, 5, 6 } };

	// dinamikus 2D -tömb
	int sor = 3;
	int oszlop = 4;
	int** Matrix = (int**)malloc(sizeof(int*) * sor);
	for (int i = 0; i < sor; i++) 
		Matrix[i] = (int*)malloc(sizeof(int) * oszlop);
	// feltöltés
	for (int i = 0; i < sor; i++)
		for (int j = 0; j < oszlop; j++)
			if (i == j) Matrix[i][j] = 1;
			else 		Matrix[i][j] = 0;
	// kiírás
	for (int i = 0; i < sor; i++)
	{
		for (int j = 0; j < oszlop; j++) printf("%5i", Matrix[i][j]);
		printf("\n");
	}
	// felszabadítás fordított sorrendben
	for (int i = 0; i < sor; i++)
		free(Matrix[i]);
	free(Matrix);

	//typedef használata
	byte mask = 1 << 2;

	// statikus struktúra
	struct p2D P;
	// adatok elérése
	P.x = 5;
	P.y = 5;

	// typedef használatával
	pixel_t Origo;
	Origo.x = 5;

	// dinamikus struktúra
	struct p2D * Pont = (struct p2D *) malloc(sizeof(struct p2D));
	
	(*Pont).x = 3;
	Pont->y = 5;

	free(Pont);

	// 2 pontnak foglalok le helyet 
	struct p2D* Szakasz = (struct p2D *) malloc(2*sizeof(struct p2D));

	Szakasz[0].x = 1;
	(Szakasz + 0)->y = 2;
	(Szakasz + 1)->x = 3;
	(*(Szakasz + 1)).x = 4;
	
	// HF: mekkora a két pont távolsága?

	free(Szakasz);

	return 0;
}

#include <stdio.h>   // printf, scanf(_s)
#include <stdlib.h>  // RANAD_MAX, malloc
#include <math.h>    // matematikai készlet
#include <time.h>    // time

//Függvények prototípusa            //.h fájlban a helyük
double szumma(double, double, double);
void haromszoros(double);
void csere_a(int a, int b);
void csere_p(int* a, int* b);
//tömb átadása
double tatlag(double* t, int n); // pointer + méret
void tkiir(double* t, int n); // pointer + méret

//2D-s pont
struct p2D
{
	double x;
	double y;
};

struct p2D felez(struct p2D A, struct  p2D B);
void kiir(struct p2D P);    // érték szerinti paraméter átadás
void torol(struct p2D* P);  // pointeres, hogy meg lehessen változtatni

double szakaszhossz(struct p2D* szakszhossz, int meret);

int main(void)
{
	// véletlen szám generátor
	srand((unsigned int)time(NULL));

	int a = 5;
	int b = 10;

	// függvények hívása
	double c = szumma(a, b, 3);
	
	if (isnan(c)) //értelmes-e a visszakapott adat?
		printf("Nincs megoldas\n");
	else 
		haromszoros(c);

	// nem működik
	csere_a(a, b);                      // csak érték átadás történik
	printf("a: %i b: %i\n", a, b);

	// pointeres verzió
	csere_p(&a, &b);                    // az adatok címét kell megadni
	printf("a: %i b: %i\n", a, b);

	int meret;
	printf("Dinamikus tomb merete:");
	scanf("%d", &meret);                // menet közben derül ki, mennyi elemre is van szükség

	double* t = (double*)malloc(sizeof(double) * meret); // dinamikus tömb

	for (int i = 0; i < meret; i++)
		t[i] = (double)rand() / RAND_MAX * 1000 - 500;  // -500 és 500 közötti

	printf("Atlag: %3.2lf\n", tatlag(t, meret));        // tömb átadása fgv.-nek
								
	// statikus struktúrák
	struct p2D A = { 10,20 };
	struct p2D B, C;

	B.x = 0;
	B.y = 10;

	C = felez(A, B);        // fgv. hívása
	struct p2D* D = &C;     // pointer

	printf("Fele [%.2lf;%.2lf]\n", C.x, C.y);
	printf("Fele [%.2lf;%.2lf]\n", (*D).x, D->y);

	kiir(C);
	kiir(*D);

	torol(&C);
	torol(D);

	// HF szakasz hossza

	// dinamikus tömb
	struct p2D* szakasz = (struct p2D*)malloc(sizeof(struct p2D) * meret);
	for (int i = 0; i < meret; i++)
	{
		szakasz[i].x = i;       // így is lehetne: (*(szakasz + i)).x = i;
		szakasz[i].y = t[i];    // így is lehetne: (szakasz + i)->y = t[i];
	}

	// függvény segítségével határozzuk meg a szakaszok hosszát
	printf("A szakaszok hossza: %.3lf\n", szakaszhossz(szakasz, meret));

	// dinamikus tartalmak felszabadítása
	free(t);
	free(szakasz);

	return 0;
}

// függvény visszatérési értékkel
double szumma(double a, double b, double c)
{
	if (a < 0) return NAN;  // ha nincs értelmes visszatérési érték, akkor Not a Number-el tér vissza
	return a + b + c;
}

// eljárás (nincs visszatérési értéke)
void haromszoros(double szam)
{
	printf("A szam haromszorosa: %lf", szam * 3);
}

// érték szerinti paraméter átadás
void csere_a(int a, int b)        //a és b lokális egész számok
{
	int tmp = a; a = b; b = tmp;
}

// mutató használata
void csere_p(int* a, int* b)        //a és b egészre mutató pointerek
{
	int tmp = *a; *a = *b; *b = tmp;
}

// double tomb átlagát adja
double tatlag(double* t, int n)
{
	double summa = 0;
	for (int i = 0; i < n; i++) summa += t[i];
	return summa / n;
}

// double tomb elemeit írja ki
void tkiir(double* t, int n)
{
	for (int i = 0; i < n; i++) printf("%f\n",t[i]);
}

// 2 pont felezőpontja
struct p2D felez(struct p2D A, struct  p2D B)
{
	struct p2D fele;
	fele.x = (A.x + B.x) / 2;
	fele.y = (A.y + B.y) / 2;
	return fele;
}

// point koordinátáinak kiírása
void kiir(struct p2D P)
{
	printf("[%.2f;%.2f]", P.x, P.y);
}

// point koordinátái 0,0
void torol(struct p2D* P)
{
	P->x = 0;
	(*P).y = 0;
}

// szakaszok hossza
double szakaszhossz(struct p2D* P, int meret)
{
	double hossz = 0;
	for (int i = 0; i < meret - 1; i++)
		hossz += sqrt(pow(P[i].x - P[i + 1].x, 2) + pow(P[i].y - P[i + 1].y, 2));
	return hossz;
}

		

main.c

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include "Sajat.h"

int main()
{
    srand(time(NULL));

    // Struktúra átadása 
    Point pt;
    pt.x = 5;
    pt.y = 8;
    pont_kiiratasa(pt);
    pont_mozgatasa(&pt, 10, -2);
    pont_kiiratasa(pt);

    // 5-ös lotto
    int db = 5;
    int max = 90;
    int* lotto = (int*)malloc(sizeof(int) * db);
    lotto_huzas(lotto, db, max);
    printf("Huzott szamok: ");
    tomb_kiir(lotto, db);
    printf("A mai nyeroszamok: ");
    tomb_rendez(lotto, db);
    tomb_kiir(lotto, db);

    // Rekurzió
    printf("5 faktorialisa: %d\n", faktorialis(5));
    printf("Hivasok szama: %i\n", hivasok_szama);

    printf("Fibonacci elso 8 eleme: ");
    fibonacci_kiiro(8, 0, 1);
    printf("\n");

    // Változó paraméter
    printf("Osszeg (3 elem): %d\n", osszeg(3, 10, 20, 30));
    printf("Osszeg (5 elem): %d\n", osszeg(5, 1, 2, 3, 4, 5));

    // Függvény pointer
    MatekFgv keplet = kob;
    printf("Eredmeny: %f\n",szamit(3, keplet));
    printf("Eredmeny: %f\n",szamit(3, fel));
    printf("Eredmeny: %f\n",szamit(3, sin));

    free(lotto);
    return 0;
}
		

sajat.h

#ifndef SAJAT_H
#define SAJAT_H

#include <stdarg.h>

// Extern változó deklarációja (ígéret, hogy valahol létezik)
extern int hivasok_szama;

typedef struct {
    int x;
    int y;
} Point;

// Függvény prototípusok
void pont_kiiratasa(Point p);                   // Struktúra érték szerint
void pont_mozgatasa(Point* p, int dx, int dy);  // Struktúra pointerrel
void lotto_huzas(int* t, int db, int max);      // lottó
void tomb_kiir(int* t, int db);                 // tömb kiiíratása
void tomb_rendez(int* t, int db);               // tömb rendezése
int faktorialis(int n);                         // Rekurzív
void fibonacci_kiiro(int n, int a, int b);      // Rekurzív
int osszeg(int darab, ...);                     // Változó argumentumszám

// Típusdefiníció matematikai függvényekhez: f(x)
typedef double (*MatekFgv)(double);
// Különböző matematikai függvények prototípusai
double fel(double x);
double kob(double x);
double szamit(double x, MatekFgv* fgv);     // A "callback" függvény: kiszámítja bármilyen MatekFgv-t

#endif
		

sajat.c

#include "sajat.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// Az extern változó tényleges definíciója
int hivasok_szama = 0;

//  Pont kiíratása
void pont_kiiratasa(Point p) {
    printf("Pont: (%d, %d)\n", p.x, p.y);
}

// Pont mozgatása
void pont_mozgatasa(Point* p, int dx, int dy) {
    p->x += dx;
    p->y += dy;
}

// Lottoszámok ismétlés nélküli húzása
void lotto_huzas(int* t, int db, int max)
{
    int kihuzva = 0;
    while (kihuzva < db) {
        int szam = (rand() % max) + 1;

        int van = 0;
        for (int i = 0; i < kihuzva; i++) {
            if (t[i] == szam) {
                van = 1;
                break;
            }
        }

        if (!van) {
            t[kihuzva] = szam;
            kihuzva++;
        }
    }
}

// Tömb kiíratása
void tomb_kiir(int* t, int db)
{
    for (int i = 0; i < db; i++) {
        printf("%d%s", t[i], (i < db - 1) ? ", " : "\n");
    }
}

// Buborék rendezés
void tomb_rendez(int* t, int db)
{
    for (int i = db - 1; i >= 0; i--) {
        for (int j = 0; j < i; j++) {
            if (t[j] > t[j + 1]) {
                int temp = t[j];
                t[j] = t[j + 1];
                t[j + 1] = temp;
            }
        }
    }
}

// Faktoriális számítás (Rekurzív függvény)
int faktorialis(int n) {
    hivasok_szama++;
    if (n <= 1) return 1;          // Kilépés
    return n * faktorialis(n - 1); // Rekurzív hívás
}

// Fibonacci sorozat
void fibonacci_kiiro(int n, int a, int b) {
    if (n <= 0) {
        printf("\n");
        return;
    }
    printf("%i ", a);
    fibonacci_kiiro(n - 1, b, a + b);
}

// Változó argumentumszámú függvény (Összegzés)
int osszeg(int darab, ...) {
    va_list args;
    va_start(args, darab);  // melyik az utolsó argumentum

    int szumma = 0;
    for (int i = 0; i < darab; i++) {
        szumma += va_arg(args, int); // milyen tipusú az argumentum
    }

    va_end(args);
    return szumma;
}

// f(x) = x / 2
double fel(double x)
{
    return x/2;
}

// f(x) = x * x * x
double kob(double x)
{
    return x*x*x;
}

// Ez a függvény nem tudja, melyik fgv(x)-t fogja kapni, de tudja, hogyan kezelje
double szamit(double x, MatekFgv fgv)
{
    return fgv(x);
}

		

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define STR_HOSSZ 101

//kiíratás betűnként
void betuz(char* c);
//kiíratás egyben
void kiir(char* c);

int main(void)
{
    // Programterületen található szövegre mutató pointer
    char* string = "C szoveg";    //a tömböt \0 zárja    (nem módosítható)
    betuz(string);                //kiíratás betűnként
    kiir(string);
    //string[1] = '-';            //nem írható - csak olvasható
    string = "Char *";            //átdefiniálható
    kiir(string);

    //Karaktertömb
    char a[21] = "karakter";     //max 20 betű + \0 (\0 automatikus)
    char b[] = { 't', 'o', 'm', 'b', '\0' };  //4 karakter + \0- t meg kell adni!!!
    //a = "String";              //nem használható pointer művelt
    a[0] = 'K';                  //tömb elemenként módosítható
    a[4] = 'K';
    kiir(a);
    printf("A b string hossza: %i\n", strlen(b));   // hossz \0-ig
    printf("A b memoria merete: %i\n", sizeof(b));

    //dinamikus
    char* cpt = (char*)malloc(STR_HOSSZ);        //100 betű tárolására lesz alkalmas
    cpt[0] = 'a'; cpt[1] = 'b'; cpt[10] = 0;     //ismeretlen tartalom \0-ig
    kiir(cpt);
    memset(cpt, 0, STR_HOSSZ);        //cpt összes eleme 0
                              //lehetne strset(cpt,'\0'); de csak char *-ra működik

    //másolás
    //cpt = a;                //ez nem másolás, csak ugyanoda fog mutatni!!!
    int i = 0;
    while (a[i])              //while(a[i]==0)    - nem tudjuk a hosszát \0-ig kell menni
    {
        cpt[i] = a[i];        //cpt[i] = a[i++];
        i++;
    }
    cpt[i] = NULL;            //záródó \0
    kiir(cpt);

    //hozzáfűzés
    char* tmp = b;            //ugyanoda mutat
    // i = 0;                 //ha i=0 lenne, akkor csak b másolása lenne
    while (*tmp)              //while(*s_tmp!=NULL)
    {
        cpt[i] = *tmp;        //cpt[i++]=*tmp++  léptetéssel eggyütt
        tmp++; i++;           //külön léptetés
    }
    cpt[i] = NULL;
    kiir(cpt);

    // cpt = a  helyett strcpy másolás, _s biztonságos verziónál meg kell adni a cél méretét, hogy ne lehessen túlírni
     strcpy_s(cpt, STR_HOSSZ, a);     //biztonságos verzió(hova, maximum mennyit szabad, miből)
    kiir(cpt);

    memset(cpt, 0, STR_HOSSZ);       //karaketer tömb ürítése
    strncpy_s(cpt, STR_HOSSZ, a, 3); //n db karater átmásolása, biztonságos verzió \0-t is hozzáadja
    kiir(cpt);

    strcpy_s(a, sizeof(a), b);       //a maximum méret statikus tömböknél sizeof()-al megadható
    kiir(a);

    // új érték adására is jó
    strcpy_s(a, sizeof(a), "char ");
    strcpy_s(b, sizeof(b), "*");
  
    //Összefűzés
    strcat_s(a, sizeof(a), b);     //strcat(mihez, max mennyit szabad, mit) az első \0-t cseréli ki a mit-re
    kiir(a);

    //Összefűzés n darab
    strncat_s(a, sizeof(a), " +5 karakter", 5);    //hozzáfűzzünk 5 karaktert ('a' nem lehet nagyobb, mint 20 karakter!!!)
    kiir(a);

    //másoljuk bele 2x az a[]-t cpt-be
	memset(cpt, 0, STR_HOSSZ);       //karaketer tömb ürítése
    strcpy_s(cpt, STR_HOSSZ, a);        //1. strcpy
    strcat_s(cpt, STR_HOSSZ, " ");
    strcat_s(cpt, STR_HOSSZ, a);        //2. strcat
    kiir(cpt);

    //keresés - karaktert
    tmp = strchr(cpt, 'r');        //strchr visszaadja a karakterre mutató pointert vagy NULL-t ha nincs
    kiir(tmp);
    tmp = strrchr(cpt, 'r');       //strrchr visszaadja az utolsó karakterre mutató pointert
    kiir(tmp);

    //betű megszámlálása
    tmp = cpt;
    int db = 0;
    while (tmp)
    {
        tmp = strchr(tmp, 'k');
        if (tmp)
        {
            tmp++;                   //átlépjük a 'k' karaktert
            db++;
        }
    }
    printf("A k betuk szama: %i\n", db);

    //keresés - sztringet
    tmp = strstr(cpt, "ar");           //strstr visszaadja a sztringre mutató pointert
    kiir(tmp);
	//string eleje
    memset(cpt, 0, STR_HOSSZ);         //feltöltés /0-val, de 
    strncpy_s(cpt, STR_HOSSZ, s2, tmp - s2);  //biztonságos n-es verziónál /0 it átmásolva
    kiir(cpt);

    //STRTOK !!!!   az eredeti tartalmat szétszedi úgy, hogy \0-t rak be a szeparáló elem helyére
    char adatok[] = "1.2;24.5;42.6;64";
    char delim[] = ";";
    char* p, * next;
    //strcpy_s(cpt, STR_HOSSZ, adatok);      //ha kell biztonsági másolat
    p = strtok_s(adatok, delim, &next);      //első híváskor
    while (p)
    {
        kiir(p);
        p = strtok_s(NULL, delim, &next);    //további híváskor NULL
    }
    printf("Ez maradt az adatokbol: %s\n", adatok);

    //Adatbevitel
    printf("kerek egy szoveget: ");
    gets_s(cpt, STR_HOSSZ));                         //biztonságos Enter-ig,  Enter-t nem tárolja
    for (i = strlen(cpt) - 1; i >= 0; i--)        //megfordít
        printf("%c", toupper(cpt[i]));            //toupper    
    printf("\n");
    
    free(cpt);

	return 0;
}

//kiíratás betűnként
void betuz(char* c)
{
    while (*c)   //while(*c!=NULL)
    {
        printf("'%c' ", *c++);
    }
    printf("\n");
}

//kiíratás egyben
void kiir(char* c)
{
    if (c) printf("%s\n", c);
}
	
		

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>		//atof-hoz

#define STR_HOSSZ 101
#define adat_nev "szamok.txt"
#define kimenet_nev "szamokuj.txt"

//A ',' cseréje '.'-ra (magyar szövegfájl feldolgozásához)
void decsep(char* c);

int main(void)
{

	//összehasonlítás
	char n1[] = "Attila";
	char n2[] = "Antal";
	int k = strcmp(n1, n2);
	switch (k)
	{
		case 1: printf("%s nagyobb, mint %s\n", n1, n2); break;
		case 0: printf("%s egyenlo %s\n", n1, n2); break;
		case -1: printf("%s kisebb, mint %s\n", n1, n2); break;
	}

	//Konverziók
	double x = 3.14;
	char sx[10];
	sprintf_s(sx, sizeof(sx), "%4.3f", x);         //számból -> szöveg
	printf("%s\n", sx);

	strcpy_s(sx, sizeof(sx) , "6.28");
	sscanf_s(sx, "%lf", &x);           //szövegből -> szám
	printf("%lf\n", x);

	strcpy_s(sx, sizeof(sx), "9.42");
	x = atof(sx) / 3;                //szövegből -> double
	printf("%lf\n", x);

	int y;
	char sy[10] = "1234";
	y = atoi(sy);                    //szövegből -> int
	printf("%i\n", y);

	//Filekezelés
	//SZÖVEGFÁJLOK
	FILE* be, * ki;

	fopen_s(&be, adat_nev, "r");	//megnyitás olvasásra
	if (!be)                        //hiba esetén
	{
		printf("Hiba: a fajl nem talalhato (%s)\n", adat_nev);
		//getchar();
		return -1;                    //vissza a hívóhoz
	}
	    
	fopen_s(&ki, kimenet_nev, "w");		 //létrehoz v. felülír
	if (!ki)
	{
		printf("Hiba: a fajl nem írhato (%s)\n", kimenet_nev);
		//getchar();
		return -1;                    //vissza a hívóhoz
	}
	printf("Fileok kinyitva\n");
	
	char* sor = (char*)malloc(STR_HOSSZ);      //hely a soroknak
	char* s1, * s2, *next;
	
	while (!feof(be))
	{
		memset(sor, 0, STR_HOSSZ);            //előző string törlése
		if (fgets(sor, STR_HOSSZ, be) == NULL)
			continue;						  //sor beolvasása a fájlból Enterig v. STR_HOSSZ db-ig

		//ha sikerült beolvasni valamit -> feldolgozzuk
		if (strlen(sor) > 0 && strchr(sor, '\t') != NULL) //nem üres, van benne elválasztó
		{
			decsep(sor);                    //magyar számok átalakítása

			s1 = strtok_s(sor, "\t", &next);			//szöveg darabolása 
			s2 = strtok_s(NULL, "\t", &next);

			double x = atof(s1);            //darabolt szöveg konvertálása számmá
			double y = atof(s2);

			//sscanf_s(sor, "%lf\t%lf", &x, &y);	// így is lehet

			//kiírtatás képernyőre
			printf("%6.4lf\t%6.4lf\t%6.4lf\n", x, y, x + y);
			
			//kiíratás file-ba
			fprintf(ki, "%6.4lf\t%6.4lf\t%6.4lf\n", x, y, x + y);
			
		} //nem üres, van benne elválasztó
	}

	fclose(be);        //fileok bezárása
	fclose(ki);
	
	free(sor);        //memória felszabadítása

	//Törlés
	char torol;
	do                    //Törlés? csak i,I,n,N fogadható el
	{
		printf("Toroljuk (I/N):");
		torol = toupper(_getch());    //a bekért karakter nagybetűre konvertálása 
		printf("%c\n", torol);
	} while (!((torol == 'I') || (torol == 'N')));

	if (torol == 'I')
	{
		_unlink(adat_nev);                //eredeti törlése, remove könyvtárt is tud törölni
		rename(kimenet_nev, adat_nev);    //új átnevezése az eredeti nevére 
		printf("OK\n");
	}

	return 0;
}

//A ',' cseréje '.'-ra (magyar szövegfájl feldolgozásához)
void decsep(char* c)
{
	int i = 0;
	while (c[i] != NULL)
	{
		if (c[i] == ',') c[i] = '.';
		i++;
	}
}