Programozas alapjai
6. kis ZH megirasa

Dinamikus memoriakezeles:
=========================

malloc.h vagy stdlib.h headerekben

memoria lefoglalasa:
--------------------
void * malloc(size);
A parancs lefoglal size db byte-ot, visszater a lefoglalt memoriara mutato pointerrel.

memoria felszabaditasa:
-----------------------
void free(void *);
A parameterben megadott pointernek lefoglalt memoriat szabaditja fel.

valtozo meretenek lekerese
--------------------------
sizeof parancs

Feladat: Irjunk programot mely beker egy szamot, lefoglal ekkora nagysagu valos vektort es feltolti ertekekkel, majd kiiratja.

/************************************************
	dinamikus helyfoglalas
************************************************/
#include <stdio.h>
#include <malloc.h>

int main(){
	double *vector;
	int i;
	int size;

	printf("Irja be mekkora tombot kell lefoglalni: ");
	scanf("%d", &size);

	vector=(double *)malloc(size*sizeof(double));

	for (i=0; i<size;i++)
		vector[i]=i*i;

	for (i=0; i<size;i++)
		printf("%6.2lf\t", vector[i]);

	free(vector);
	return 0;
}

FA: Irjunk programot, mely lefoglal egy 2 dimenzios tombot melynek meretet futasidoben adhatjuk meg, majd toltsuk fel elemekkel, irassuk ki azokat, es vegul toroljuk a tombot.

/************************************************
	dinamikus helyfoglalas
************************************************/
#include <stdio.h>
#include <malloc.h>

int main(){
	double **matrix;
	int i, j;
	int sizex, sizey;

	printf("Irja be mekkora tombot kell lefoglalni: ");
	scanf("%d %d", &sizex, &sizey);

	matrix=(double **)malloc(sizex*sizeof(double));
	for (i=0; i<sizex;i++)
			matrix[i]=(double *)malloc(sizey*sizeof(double));
	for (i=0; i<sizex;i++){
		for (j=0; j<sizey;j++){
			matrix[i][j] = i*j;
		}
	}

	for (i=0; i<sizex;i++){
		for (j=0; j<sizey;j++){
			printf("%3.3lf\t", matrix[i][j]);
		}
		printf("\n");
	}
	for (i=0; i<sizex;i++)
		free(matrix[i]);

	free(matrix);
	return 0;
}


Mutatok es tombok
-----------------
szoros kapcsolat, minden tombindexeles vegrehajthato mutatokkal is

pl
double tomb[5], *tombpointer, szam;

tombpointer=&tomb[0];
szam=*tombpointer; //szam=tomb[0];

(tombpointer+3) // a tomb 3. elemere mutat
tombpointer++ 	// a tomb kovetkezo elemere


Pointeraritmetika
-----------------
egy t tipusra mutato pointer eseten megengedettek a:

++, -- muveletek, melyek a pointer erteket a sizeof(t)-vel csokkentik vagy novelik, ez egy tomb bejarasanal hasznos lehet.

+=x, -=x muveletek, x*sizeof(t) ertekkel csokkenti/noveli a mutato erteket. 

megengedett meg:"
-a pointerhez egesz szam hozzaadasa
-pointerek osszeadasa, kivonasa
minden mas muvelet TILOS a pointerkkel:
-szorzas, osztas, valos szamokkal torteno muveletek.

Feladat:
Szamoljuk ki egy sztring hosszat pointerek segitsegevel:
/****************************************
*     Sztring hosszanak kiszamitasa
****************************************/

int strlen1(char *s){   
	int n;
    for (n = 0; *s != '\0'; s++, n++);
    return (n);
}

int strlen2(char *s){   
	char *a;
	a=s;
    for (; *s; s++);
    return (s-a);
}


int main(int argc, char* argv[]){
	char a[]="Sziasztok";
	printf("%d\n", strlen2(a));
	return 0;
}


Bitmuveletek
------------

-negalas: ~ 
-es &
-vagy |
-xor

-bitleptetes
	>> - balra 2-vel szorzas
	<< - jobbra 2-vel osztas
	unsigned: meguresedett bitek 0-val feltoltodnek
	signed: ? gepfuggo ?

Maszkolas:
FA: A 4. bitig az osszes bit 0-ra allitasa (int)
	a&~15
Az osszes bit 1-re allitasa a 4. bit-ig
	a|15

FIGYELEM:
	& != &&
	| != ||
pl: 3&12=0, de 3&&12 != 0


Header
------

Olyan fileok, melyekben fuggvenydeklaraciok vagy fuggvenydefiniciok talalhatok. Altalaban csak a fuggvenyek fejlece, es egy c forrasfileban a fuggveny definicioja. A forditonak meg kell mondanunk, hogy mely c fileok legyenek beleforditva a projectbe, melyek kozul egy main fugveny van.

Egy header file altalanos alakja:

#if !defined MY_HEADER_H
#define MY_HEADER_H

fuggvenydeklaraciok...

#endif 

A c-fajlban, ahol a "my_header.h" fuggvenyei vannak definialva, a definicio elott szerepelnie kell az #include "my_header.h" utasitasnak.