🚀 go-pugleaf

Adam Karpierz wrote:
> Dariusz Slusarczyk wrote:
> PS: Natomiast jestem ciekawy jak Pan ta metode
>        zastosuje w przypadku tablic wielowymiarowych
>        powiedzmy dwywymiarowych ?.
>        Tu juz chyba tak latwo sie nie da prawda ?.

no... chyba Pana zaskocze, bo da sie to zrobic, gdyz jest to wlasciwie
to samo :)

np. tablica char array['a':'f']['a':'z'];
oto gotowy kod (mozna kopsnac do pliku i odpalic)
jako zagorzaly zwolennik pisania kodow tak przejrzystych jak to tylko
mozliwe [czyli tak jak zaleca organizacja IOCCC :)] pozwolilem sobie na
uzycie paru konstrukcji, ktore zawsze staram sie wykorzystac przy
tablicach wielowymiarowych (wiecie, pielegnacja i te sprawy) :)

//marines marinesovitch
//opowiesc o tym jak indexowalem tablice
//dwuwymiarowa array['a':'f']['a':'z']
#include <string.h>
#include <stdio.h>

#define FIRST_ROW    'a'
#define LAST_ROW     'f'
#define FIRST_COLUMN 'a'
#define LAST_COLUMN  'z'
#define ROW_CX       (int)(LAST_ROW-FIRST_ROW+1)
#define RANGE        (int)(LAST_COLUMN-FIRST_COLUMN+1)

void main(void)
{
 int i,j,x=0;
 char trueArray[ROW_CX][RANGE];
 int y=0;
 char(*array)[RANGE]=
                (char(*)[RANGE])&trueArray[-FIRST_ROW][-FIRST_COLUMN];
 printf("\n%X %X\n",&array[-FIRST_ROW][-FIRST_COLUMN],trueArray);
 memset(trueArray,'0',ROW_CX*RANGE);
 printf("\ntrue array ROW_CX %d RANGE %d",ROW_CX,RANGE);
 for(i=0;i<ROW_CX;i++)
 {
  printf("\n");
  for(j=0;j<RANGE;j++) 
   printf(" %c ",*(j+*(i+trueArray)));  
 }
 for(i=FIRST_ROW;i<=LAST_ROW;i++)       //indexuje ladnie od 'a' do 'f'
  for(j=FIRST_COLUMN;j<=LAST_COLUMN;j++)//indexuje ladnie od 'a' do 'z'
   j[i[array]]=j;                       
 printf("\narray %d\n",x);
 for(i=FIRST_ROW;i<=LAST_ROW;i++)       //indexuje ladnie od 'a' do 'f'
 {
  printf("\n");
  for(j=FIRST_COLUMN;j<=LAST_COLUMN;j++)//indexuje ladnie od 'a' do 'z'
   printf(" %c ",(i*RANGE+j)[(i^i)[array]]); 
 }
 printf("\ntrue array");
 for(i=0;i<ROW_CX;i++)
 {
  printf("\n");
  for(j=0;j<RANGE;j++)
   printf(" %c ",j[*(i+trueArray)]);    
 }
 printf("\nograniczniki X=%d Y=%d\n",x,y);
}

konstrukcje takie jak 
*(j+*(i+trueArray))
j[i[array]]
(i*RANGE+j)[(i^i)[array]]
j[*(i+trueArray)]
chyba nie wymagaja zadnego komentarza, zdajac sobie jednak sprawe, ze
liste moga czytac rowniez ludzie nie znajacy C [sa tacy?! :)] powiem, ze
chodzi oczywiscie o zwykly dostep do tablicy - kazda z w/w konstrukcji
jest rownowazna 
array[i][j] tudziez 
trueArray[i][j] :>>> 
[jesli ktos nie wierzy niech sobie pozamienia kod na w/w odpowiedniki]

jedyne co trzeba wlasciwie zrobic to
 char(*array)[RANGE]=(char(*)[RANGE])&trueArray[-'a'][-'a'];

a potem mozemy juz sobie ladnie(?) indexowac ['a':'f']['a':'z']

to naprawde nie jest zaden problem

dlaczego to dziala?
powiem na przykladzie prostszej tablicy:
char array[5..8][5..8]
&array[5][5] ma wskazywac dokladnie na to samo co &trueArray[0][0]
(czyli prosciej trueArray)

&array[6][5] na &trueArray[1][0]
&array[7][6] na &trueArray[2][1]
..
uzyskac takie odwzorowanie to zadna sztuka wystarczy ustawic wskaznik o
5*4+5 bajtow wczesniej czyli bezwzglednie array=trueArray-25
5*4+5 
 5  bo to pierwszy index w pierwszym wymiarze 
 *4 bo mamy 4 kolumny [5..8] po jednym bajcie [char jako jeden bajt]
 5  bo to pierwszy index w drugim wymiarze 

  array[5][5] daje offset 5*4+5=25  a 25+(trueArray-25)=trueArray+0
wiec mamy odwzorowanie array[5][5] -> trueArray[0][0] bo 0*4+0=0 ^^^

  array[6][5] daje offset 6*4+5=29  a 29+(trueArray-25)=trueArray+4
wiec mamy odwzorowanie array[6][5] -> trueArray[1][0] bo 1*4+0=4 ^^^

  array[7][6] daje offset 7*4+6=34  a 34+(trueArray-25)=trueArray+9 
wiec mamy odwzorowanie array[7][6] -> trueArray[2][1] bo 2*4+1=9 ^^^

itd itd

ot zwykla arytmetyka :)

na koniec dodam tylko, ze podany tutaj przeze mnie sposob mozna
generalizowac na wieksza ilosc wymiarow

p.s. przepraszam za lamerskie mnozenie przez 4, nie chcialem pisac <<2
(czyli przesuniecia w lewo o 2) dla zwiekszenia czytelnosci
gdyby tablica byla typu int to oczywiscie powyzsze rozwazania nalezalo
by nieco zmodyfikowac [wtedy dlugosc wiersza nie bylaby jak teraz dla
char'ow 4bajtowa tylko 16bajtowa, bo jedyny sluszny int to przeciez
4bajty :)]
> --
> Adam Karpierz
-- 
marines()
{ 
 return Dariusz_Slusarczyk; 
}