### Niema różnicy czasowej w:
//===1 sposób===
for (i=0; i<gRozmiar; ++i) if (Tab[i] == w) break;
//===2 sposób===
i = 0;  while(i<gRozmiar && Tab[i] != w) ++i;
//===3 sposób===
i = 0;
ET1: if (Tab[i] != w) ++i; else goto ET2; 
goto ET1;

### Builder:
i = (i+1) % 256 //szybsze
++i;  i %= 256; //wolniejsze
++i %= 256; //powoduje błąd!!!

j = (j + perm[i]) % 256; //szybsze
j += perm[i];  j %= 256; //wolniejsze

-szybciej działa for i na int niż na __int64; nawet gdy dalej są operacje z i oraz __int64
-najszybciej działają odwłania do tablic na stosie niż tworzonych dynamicznie przez new
-przy zadeklarowaniu powyżej około 153600 B na zmienne lokalne w funkcji (też w main) wyskakuje 'Stack Overflow'

# co jest szybsze? Tab[(int)i], Tab[(unsigned int)i], Tab[(unsigned char)i],  ... ???

-w Visual C++ 
 * nie ma różnicy w:
 - Tablica[Index++] ^= perm[(perm[i]+perm[j]) % 256];
 - Tablica[Index] ^= perm[(perm[i]+perm[j]) % 256];  ++Index;
 * nie ma różnicy w:
 - i = (i+1) % 256;
 - i = ++i % 256;
 - ++i %= 256;
 - ++i;  i%=256; //!
 * nie ma różnicy w:
 - j += perm[i];  j %= 256;
 - j = (j+perm[i]) % 256;

-zamiast a = -a; lepiej a *= -1;
-szybciej jest: v = ++x; niż v = x++; bo w 2-przypadku trzeba zapamiętać i podstawić do v starą wartość x!
-pętle for od max do 0 -bo porównywanie z zerem jest szybsze
-zamienić wsz. tablice wielowymiarowe na jednowymiarowe
-Visual C++ jest dużo szybszy w obliczeniach arytmetycznych od C++Buildera
-BIGNUM - biblioteka liczb wysokiej precyzji w C++ [313]
-Czy można w C++ dynamicznie stworzyć wielowymiarową tablicę?
 np. w = new double[3][5]
-MAX_PATH ??
-nie można użyć new do przydzielenia pamięci tablicy wielowymiarowej, gdzie rozmiar każdego wymiaru jest zmienną, np.
  double **W; W=new double[K][K]; //nie da się!
  W[0][0]=0;
-nie można tak robić:
 sprintf(s,"...",...,s,...); np. sprintf(linia," %s%s",linia,sw); 

-zamiast itoa(123,s) używać sprintf(s,123) jeżeli do s coś jeszcze zaraz dokładamy
-spr czy if (a==5 && b==9) sprawdzane są zawsze wszystkie warunki czy
 jeśli już jeden nie zgadza się to reszta jest niesprawdzana?
 Jeśli jest wsz. sprawdzane to lepiej robić:
 if (a==5)
  {if (b==9) {}
  }
-jak jest w C++ z usuwaniem lokalnych zmiennych, tablic szczególnie ?
 czy np.  int a[20]; zostanie usunięte z pamięci po zakończeniu funkcji?
 może trzeba: int *a=new int[20], a potem delete[] a;  ???
-spr. rodzaje instrukcji do opercji na plikach: 
 -fopen
 -open
 -cout<<
 -Api
 -Builder
-------------------------------------------------
char * LCzlon(char *s)
{char t[256]; 
 strcpy(t,s);  s=t;
 while (isalpha( (int)*s ) ) s++;
 *s=0;
 return t;
}
//------------
void Fun(void)
{Label->Caption=LCzlon("house-garden");
}

Czy to jest bezpieczne. Czy można się zwracać i odwoływać do
zmiennej automatycznej stworzonej w funkcji LCzlon ?
Czy po zakończeniu LCzlon w trakcie zwracania t można sięgać z zwenątrz do tej zmiennej?
Takie działanie powiodło mi się, ale czy zawsze może się udać o ile to nie jest poprawne?
-------------------------------------------------------
### PYTANIA ###
-co oznacza warning: Unreachable code (->conv_txt_pc2c64)
 while ( (z=getc(wej))!=EOF ) <- ???
 fputc(a[z],wyj);

### UWAGI ###
*-> gdy:
  char s[256];
  char *wskaznik_na_char;
 -> to nie można:
  s=wskaznik_na_char 
 -> bo zmieniamy adres zmiennej lokalnej !!!
-! ŚREDNIK po deklaracji klasy ! 
-dziedzina exp(x) x<709.782226
-!wszelkie działania na liczbach rzeczywistych są typu double, a na liczbach całkowitych są typi int

### Metody spr. i ustalania k-tego bitu (od zera) w liczbie n
Najlepiej ztablicować potęgi 2: Potega2[i]={1,2,4,8,...};
*Czytanie bitu k:
1. = (n / Potega2[k])%2
2. = (n>>k)%2 lub (n>>k)&1  <-szybsze od 3 i minimalnie od 1
3. = ((n & Potega2[k])!=0)
*Ustawienie bitu k na 1:
1. n = n | (2^k); czyli n |= (Potega[k]) lub n += Potega[k]

### 2^i = 1<<i

### 
[a/b] - podłoga = a/b (wiadomo)
[a/b] - sufit = a/b+(a%b!=0), lub a/b+(a%b ? 1 : 0)
     

### Ciekawostki
-można: void main(sdfsfbzdetybvvb) {}

### SZYBKOŚĆ ###
-unkiać if()- bardzo spowalnia; o ile można lepiej robić wyrażenie matematyczne
-lepiej używać swich {case}  niż  if(); else if(); else if(); lub niż  void (*(TabFun[7]))(void)
-w metodzie danej klasy lepiej użyć zmiennej lokalnej int niż korzystać z pola int klasy
-e=(a-b)*(a-b); <-jest szybsze niż: w=a-b; e=w*w;
-printf jest 2 razy szybsze niż cout !! [spr. Code::Blocks]
!-zamiast: i=(i+1)%n;  lepiej: i++; i%=n; lub ++i%=n
-szybciej jest gdy:  if (x<A) ...; else if (x>A) ...;//tu 1 lub 2 razy jest sprawdzane
 	       niż:  if (x<A) ...;  if (x>A) ...; //tu zawsze 2 razy jest sprawdzane

-chyba lepiej jest: a/(b*c) niż a/b/c -bo dzielenie jest bardziej czasochłonne niż mnożenie
-szybsze jest dzielenie modulo '%' niż zwykłe '/' !
-unikać dzielenia

### JĘZYK
-minimalny = najmniejszy możliwy
-maksymalny = największy możliwy

###
])( tablica funkcji

### computed gotos
assigned goto
labels as values

### Zasady do mojego stylu pisania w C++
-definiowanie klas:
 class
  {
  }

- pary nawiasów { } zawsze pod sobą, tzn. np:
 switch ()
  {
  }
- instrukcja if:
 if (...)
  {...
  }

-po nazwie funkcji ewentualnie komentarz o wartościach zwracanych i ich znaczeniu
 lub jedna linia wolna po {
-Nazwy zmiennych globalnych zaczynam z dużej litery i z przedrostkiem 'g', np. gBufor

-! nazwy pól klasy zaczynają się od "m_"

-pętle for ze spacjami: for (i=0; i<AL.m_MaxLiczba; ++i)

### LEGENDA ###
[!] - zastosowany sprytny trik, alg., zapis
[...] - do sprawdzenia, przemyślenia
() - nie potrzebne

### Algebraiczny sposób pisania programów:
-łatwość zmian
-używanie ogólników - jak najmniej dosłownych zmiennych, nazw

-algebraizacja, abstrakcjonowanie, abstrahowanie, symbolizowanie, tworzenie powszechników, formalizacja

### Programując zawsze staram się zachowywać następujące podstawowe zasady-cele:
1. Optymalny kod: zużywaj±cy jak najmniej zasobów komputera:
 A. Czas procesora,
 B. Pamięć,
 C. Dostęp do urz±dzeń: dysk HD, dysk optyczny itp.
2. Kod elastyczny, przenaszalny, skalowalny, tzn. łatwy do wykorzystania w innych systemach, programach (programowanie obiektowe)
3. Kod źródłowy napisany czytelnie i w sposób uporządkowany (tak aby wracając do kodu po długim czasie, można go było szybko zrozumieć)
4. Uzupełnianie-utrzymywanie dokumentacji i komentarzy w kodzie źródłowym (nieraz komentarz jest ważniejszy od samego kodu)
5. Program komunikujący dokładnie o wszelkich krytycznych sytuacjach i obsługujący je

### Wikipedia:
Poezja kodu - styl programowania, czyli pisania programów komputerowych, który szczególny nacisk kładzie na perfekcyjną znajomość zagadnienia oraz czytelność samego kodu, tak by możliwa była jego łatwa modyfikacja i rozszerzanie.

Styl ten akcentuje nie tylko dążące do idealnych konstrukcje składniowe i gramatyczne kodu i jego wizualną przejrzystość, ale zwraca też uwagę na konwencje programowania, zgodność ze standardami, przenośność i dobre dokumentowanie pracy (komentarze wewnątrz, jak i zewnętrzne podręczniki).

W komercyjnych projektach programistycznych raczej rzadko można napotkać program, który można by uznać za poezję kodu, ponieważ nacisk tam bardziej kładzie się na wydajność programisty. W poezji kodu programowanie staje się celem samym w sobie, przypomina rzemiosło, przy pomocy którego twórca wyrabia w sobie pokorę do wykonywanej pracy i przekracza własne możliwości, nie bacząc na termin ukończenia dzieła.

###### Info-kompilatory
*Code::Blocks
Build\Compiler options [Compiler settings]
Szybciej działa z:
 -WYłączonym: -s [znacznie redukuje rozmiar], -Os
 -WŁączonym: -386, -486

*Visual C++ 6.0
-conversion from unsigned __int64 to double not implemented, use signed __int64
-suffix dla: __int 64 x = 1i64;

*Delphi
 - dokładny w obliczeniach liczb rzeczywistych
 W pętli for nie można uzyć iteratora typu Int64 !!! np.
 i: Int64; For i:=1 To 10 Do ...

*DigitalMars C++ 8.42n:
 -Opcja -O dobra (np. dla operacji na liczbach rzeczywistych) !!!
 -nie ma funkcji do zamiany __int64 na ciąg znaków !
 -Nie skompiluje się, gdy przed main() zadeklarunjemy dużo na pamięć, np.:
  const int RozTab = 10000000;  int Tab[RozTab]; //max RozTab=9150000
 -Nie skompiluje się:
  ++i %= DlHasla;  //Trzeba: i = (i+1) % DlHasla;
  ++i %= 256; //Trzeba: ++i;  i%=256; 

*DigitalMars D
 -nie stosuje się inline; kompilator sam sobie to ustala
 -unsigned char to ubyte
 -nie da się razem zdefiniować: ubute x, perm[256]; 
 -to samo co w DigitalMars C++: overflow for static array ale jeszcze gorzej
 The total size of a static array cannot exceed 16Mb.

*MinGW wersja gcc w pliku gccbug
 -lepsza opcja -O2 niż O3 !!!

*Borland Builder 6:
 -dokładniej liczy na liczbach double
 (-szybciej jest BEZ 'Floating point -fast' !
 -gdy za dużo na stosie - błąd kompilacji (a nawet kompilatora!) 'Fatal error derected'
 -Te kody Builder traktuje inaczej: !!!
  ++i;  i %= DlHasla;
  ++i %= DlHasla;
 Ale to już jest równoważne:
  ++i %= 256; //TO MOŻE powodować BŁĄD!!!
  ++i;  i%=256; 

*CodeBloks
 - należy zmienić PATH do wynikowego exe w pliku console.cbp
 - przyspieszenie daje opcje kompilatora: pentium -mmx,2,3,4

*OpenWatcom 1.7
-6r -szybsze!

*Intel opcje:
/Og
/Oi
/Ot
/GR-
/GA
/Qip
/QaxN
/QxN
/fp:fast=2
/O3