BGAFC Vendégkönyv

Σ: 1 post

TCH (statz)

#1, Főfasz (10443)

4185 | #3c8d | ^ | Idézet | Mon, 11 Apr 2016 15:28:41 +02

178.164.*.*

*.pool.digikabel.hu

A cé szar, mer bufferóverfló rovatban két úriember méltó választ adott a bloatnyelvesek picsogására,
az egyik egy tömör egysorossal, a másik kissé bővebben.
Mondjuk most saxusnak is volt valid gondolata

@saxus:
És egyébként is, jobban szeretem, ha a gép szolgál engem és nem én végzem el a gép munkáját.

csak már megint nem mindegy, hogy a felesleges munka megspórolásáról, vagy a döntési jog elvesztéséről beszélünk, nem mindegy, hogy a gép helyettem dolgozik, vagy helyettem dönt!

Az egészben a vicc egyébként, hogy olyanokkal bírnak előjönni, mint a tömbök "túlindexelésének" védelme; bazdmeg, ezt kb. 40 sor lenne megírni C-ben:

#include <stdlib.h>

struct intarray_struct
{
	int *data;
	unsigned long long int count;
};

typedef struct intarray_struct *intarray;

#define new_intarray() (intarray)calloc(sizeof(struct intarray_struct), 1)
#define kill_intarray(ia) { free(ia->data); free(ia); ia = NULL; }

int set_intarray_e(intarray ia, unsigned long long int index, int value)
{
	if (ia == NULL)
	{
		return 1;
	}
	if (index >= ia->count)
	{
		return 2;
	}
	ia->data[index] = value;
	return 0;
}

int get_intarray_e(intarray ia, unsigned long long int index, int *value)
{
	if (ia == NULL)
	{
		return 1;
	}
	if (index >= ia->count)
	{
		return 2;
	}
	*value = ia->data[index];
	return 0;
}

És ennyi! Persze lehet tovább bonyolítani, hogy mi szükséges még, de most itt a tömbindexelés védelméről volt szó, meg a plusz függvények is beleférnek kb. 100 sorba:

int clear_intarray(intarray ia)
{
	if (ia == NULL)
	{
		return 1;
	}
	if (ia->data != NULL && ia->count > 0)
	{
		free(ia->data);
	}
	ia->data = NULL;
	ia->count = 0;
	return 0;
}

int resize_intarray(intarray ia, unsigned long long int count)
{
	int *new_data;

	if (ia == NULL)
	{
		return 1;
	}
	if (count == 0)
	{
		return clear_intarray(ia);
	}
	new_data = (int *)realloc(ia->data, sizeof(int) * count);
	if (new_data == NULL)
	{
		return 2;
	}
	ia->data = new_data;
	ia->count = count;
	return 0;
}

int append_intarray_e(intarray ia, int value)
{
	int e;

	if (ia == NULL)
	{
		return 1;
	}
	e = resize_intarray(ia, ia->count + 1);
	if (e != 0)
	{
		return e;
	}
	ia->data[ia->count - 1] = value;
	return 0;
}

int insert_intarray_e(intarray ia, unsigned long long int index, int value)
{
	int e;
	unsigned long long int lo, hi;

	if (ia == NULL)
	{
		return 1;
	}
	e = resize_intarray(ia, ia->count + 1);
	if (e != 0)
	{
		return e;
	}
	hi = ia->count - 1;
	lo = hi - 1;
	while (lo >= index)
	{
		ia->data[hi--] = ia->data[lo--];
	}
	ia->data[index] = value;
	return 0;
}

int delete_intarray_block(intarray ia, unsigned long long index, unsigned long long count)
{
	unsigned long long int i, lo, hi, limit;

	if (ia == NULL)
	{
		return 1;
	}
	if (count >= ia->count)
	{
		return clear_intarray(ia);
	}
	if (index + count > ia->count)
	{
		count = ia->count - index;
	}
	hi = index + count;
	limit = ia->count - hi;
	lo = index;
	i = 0;
	while (i++ < limit)
	{
		ia->data[lo++] = ia->data[hi++];
	}
	return resize_intarray(ia, lo);
}

És ennyi! Alig 150 sor (és 2-3 kB lefordítva) és van egy olyan integer tömb típusunk, ami fúr, farag, körmöt rág, faszt vakar és segget nyal. És nem lesz benne túlindex, overflow, meg bármilyen segfault, ha nem piszkálják a belsejét, hanem a függvényeket használják hozzá. És ilyet bármilyen típusra lehet írni. Ugyanezen az elven lehet csinálni stream típust is. Vagy akármit. És még mindig kicsi és gyors. Tán még egy "szaros" C64-en is használható lenne. A bloatnyelveknek ugyanezt sikerült úgy megoldani, hogy sok-sok MB és sok-sok GHz kelljen csak ahhoz, hogy megmoccanjon az a monstrum, amit kifosnak magukból! Úgyhogy a kurwa anyját a dzsuvának és a cisztának, de főleg a dzsuvaszkriptnek!