Udv!

Egy kis ellenvetesem hadd legyen, eddigi tapasztalataim alapjan nem szerencses
interrupt szintrol hivogatni olyasmiket, amik idozitessel foglalkoznak.
Tovabba az i valtozo inkrementalasa is olyannak tunik, ami soha nem fog
bekovetkezni...... cikluson belul van.

_tgz irta:

> Es azt mibol gondolod, hogy a file bezarasa es a directory
> bejegyzesek updatelese egyidoben tortenik? (Lehet hogy igy van,
> de akkor sem magatol erthetodo.)
Igazad van, en csak gondolom ezt.
Viszont lattam egy masik programot, ami egy backup keszitese kozben
(ca. 10 mega) allandoan updateoli a file nagysagat. szvsz van valami
hivas, ami ezt mind beallitja.

> Ezt koveteli meg a Single Unix Spec. A Win98 nem tudom mennyit
> valosit meg ebbol (tehat ha valoban ugy van ahogy mondod, akkor
> nincs mas valasztasom azon kivul, hogy hiszek neked), de a valasz
> bizonyosan nem magatol erthetodo; talan egy KB article-ben
> benne van.
Ne higgyel nekem, amit mondtam, azt csak azert mondtam, mert eddig igy
vettem eszre. Nem tudom semmivel alatamasztani.

Viszont, Delphiben a TStream-nek (file kezelest oldja meg) a Write
metodusa a WriteFile-t hivja meg (kernel32) es ezen keresztul irkal a
fileba. Namost, a programom ugy mukodik, hogy egy for ciklusban 256
byteot irkal a fileba. Breakpoint -> Debug, es minden iteraciora berija
a fileba az adatokat, beallitja a file nagysagot, stb. Namost mukodes
kozbe kilottem a programomat, es megmaradt komplett a file eddig leirt
resze. Nem ertek a C-hez, de nem ha Windows alatt mukodsz, nem irhatod
meg ezen API segitsegevel a loggolo programodat? Nem olyan veszesen
komplikalt fuggveny....

-- 
udvozlettel,
 Gergely

Csa!
Hogy lehet a pascal beepitett assemblyjebol pointereket
kezelni? Picit konkretabban:
type T = array[0..64639] of Byte;
var F, S: ^T;
Megprobaltam lds si-vel es les di-vel de nem megy.
Van vkinek otlete? Koszi
thSoft

On Sat, May 02, 1964 at 11:45:00AM +0000,  wrote:
> Egyszerre egyidőben csak 256 féle karakter használható. Ezt figyelembe

Nem igaz. A VGA kartyakon egy kis buveszkedessel (valamilyen
bitet meg kell valtoztatni valamelyik kartyaregiszterben) ra
lehet venni, hogy a szinbyte-bol is vegyen egy bitet figyelembe
a karakterkodhoz, ezzel azt effektive 9 bitesre megnagyitva.
Ha kell, szives oromest elokeresem a reszleteket is, de ha
melyebben is erdekel vkit a tema, akkor meleg szivvel ajanlom
a hires-neves _A_VGA_kartya_programozasa_ cimu konyvet,
egy egesz fejezet szol benne a karakteres mod programozasarol.

_tgz

On 8 Jun 01, at 16:13,  wrote:

> Adott egy N x M tomb.
> Jarjuk be Zig-Zag algoritmussal.
>
> Feltetelek M > N vagy N = M -> NxN.
>
> Ketfelekeppen lehet elindulni:
> 1. Visszintesen:
 ...
> 2. Fuggolegesen:
 ...
>  Irhato olyan program ami 2x2-tol NxM-ig
>  legyartja a megfelelo zigzag bejarasi tombot?

(Nem tudom, itt mit ertettel ezen pontosan, szoval egyetlen NxM-
es bejaras kell, vagy olyan rutin, ami 2x2-tol NxM-ig mindenfele
variaciora megcsinalja a bejarasokat? Ezen utobbihoz rakj ket
egymasba agyazott ciklust a zigzag rutin hivasa kore, ez
gondolom nem problema...)

A programom mindketfele iranyba indulva hajlando generalni a
bejarast. Parancssorbol adhato meg az irany is, meg a tomb
merete is. Arra torekedtem, hogy minel egyszerubb legyen az
algoritmus, ugyhogy a comment tobb benne, mint maga a kod :)

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

// n*m-es matrix cikk-cakk bejarasa
// m >= n, de ez az algoritmus szempontjabol tok mindegy...
//   (Pontosabban ehhez van 'optimalva' az algoritmus)
//   (Az egyszerubb algoritmus kedveert egyebkent nem
//    torekedtem a sebessegre valo optimalizalason...)
// Indexek: sor:0..n-1 oszlop:0..m-1
// irany: ha true, akkor vizszintes lesz az elso lepes,
//   ami ugyanaz, mint hogy az elso 'ferde' (az egy szem
//   bal felso sarok) felfele megy.
// Bejaras: generalunk m+n-1 darab teljes hosszusaga (n magas)
//   ferde vonalat az oszlopokhoz, amiket felvaltva felfele
//   majd lefele jarunk vegig. (Az abran a ++++ ferdeket
//   felfele, a ---- ferdeket lefele.) A vegen a ferdeknek
//   csak azok a helyei erdekesek, amik a matrix belsejebe
//   esnek:
//
//         <    m    > <n-1>
//        |+ - + - + -|+ - +
//       +|- + - + - +|- +
//     + -|+ - + - + -|+
//   + - +|- + - + - +|
//
//   Igy n*(n-1) szamu helyen feleslegesen jarunk, de nem
//   igazan gond... Ez egyebkent akkor kevesebb, ha n <= m,
//   szoval pont jo! Ha forditott lenne a felallas, akkor m
//   szeles vonalakat kellene a *sorokhoz* generalni (szoval
//   nagyjabol az abra 90 fokkal elfordulna). A fentebb
//   emlitett 'optimalizalas' csupan e ket modszer kozotti
//   valasztasra terjed ki.

void zigzag(int irany, int n, int m)
{
	int i,j;
	int felfele = irany;
	for (j=0; j<m+n-1; j++, felfele = !felfele) {
		// j lesz a tomb tetejen a ferde vonal oszlopindexe,
		// vagyis a ferde vonal a felso sort j-nel metszi.
		// j>=m eseten meghosszabitottuk elvben a tetot!
		for (i=0; i<n; i++) {
			// i vegigmegy a sorokon lefele
			int iranyi = felfele ? n-1-i : i; // vagy felfele
			int ferdej = j-iranyi;
			if (ferdej>=0 && ferdej<m) {
				// ez egy letezo index:
				printf("(%d,%d) ", iranyi, ferdej);
			}
		}
	}
}

int main(int argc, char *argv[])
{
	int irany,sor,oszl;
	if (argc != 4) {
hiba:
		fprintf(stderr,
			"Hasznalat: %s viz|fugg <sorok> <oszlopok>\n",
			argv[0]);
		exit(1);
	}

	if (0==strcmp(argv[1],"viz")) irany = 1;
	else if (0==strcmp(argv[1],"fugg")) irany = 0;
	else goto hiba;
	sor = atoi(argv[2]);
	oszl = atoi(argv[3]);

	printf("%dx%d matrix bejarasa:\n", sor, oszl);
	zigzag(irany, sor, oszl);
	printf("\n");

	return 0;
}

------------------------- >8 -------------------------

István