Programming

A więc tak najpierw trochę c++ aby poznać podstawy kiedy dojdzie coś z GUI użyje się C#.
Na początek jeden łopatologiczny program.

//////////////////////////////////
 #include <iostream>


 using namespace std; 

 int main(void)
 {
 unsigned int uiVariable1 = 10, uiVariable2;
 cout << "Wprowadz pierwsza liczbe calkowita : ";
 cin >> uiVariable1;
 cout << "Wprowadz druga liczbe calkowita : ";
 cin >> uiVariable2;
 if(uiVariable1 < uiVariable2)
 {
 cout << "Pierwsza liczba jest mniejsza od drugiej" << endl;
 } else if(uiVariable1 > uiVariable2)
 {
 cout << "Pierwsza liczba jest wieksza od drugiej" << endl;
 } else cout << "Pierwsza liczba jest rowna drugiej" << endl;
 unsigned int i = 0;
 for(i = 0; i < 5; i++)
 {
 uiVariable1 = uiVariable1 + 1;
 if((uiVariable1 % 2) == 0) cout <<
 "Liczba jest parzysta i wynosi : " << uiVariable1 << endl;
 }
 while(i > 0)
 {
 cout << i << " ";
 i--;
 }
 cout << endl;
 do
 {
 cout << i << " ";
 i++;
 } while(i < 5);
 cout << endl;
 
 cout << "Wprowadz liczbe calkowita : ";
 cin >> uiVariable1;
 switch(uiVariable1)
{
 case 5:
 cout << "Liczba jest rowna 5" << endl;
 break;
 default :
 cout << "Liczba jest rozna od 5" << endl;
 }

 system("PAUSE");
 return 0;
 }

////////////////////////////////////


////////////////////////////////////

Nie wiem czy trafiłem dobrze z poziomem ale mam nadzieje, że tak ;]
To teraz, krótki opis każdego elementu.
#include<iostream>
Instrukcja ta włącza do naszego programu bibliotekę standardową. Tzn. Aby użyć pewnych elementów takich jak wczytywanie danych z klawiatury, potrzebujemy użyć specialnych obiektów, które znajdują się w danym pliku. W zasadzie zawartość pliku iostream.h jest po prostu wklejana do naszego programu.
/*****************************************************************************/
int main() {  }
Jest to główna funkcja programu podczas działania aplikacji wykona się tylko to znajduje się między nawiasami funkcji main. {} są odpowiednikami begin i end z płaskala.Funkcja ta musi nazywać się main nie ma innej możliwości.
/********************************************************************************/
unsigned int uiVariable1 = 10, uiVariable2;
Jest to po prostu deklaracja zmiennych o typach będzie na końcu ;]. W każdym razie jak zauważycie pierwszej zmiennej przypisano wartość 10 a drugiej nic. Kompilator automatycznie za nas przypisze jej wartość zero, jeśli my sami nie nadamy zmiennej wartości. Dla pascalowców: = jest znakiem przypisania a znak == porównania. Każda linia instrukcji musi kończyć się ";";
/*-------------------------------------------------------------------------------------------------------------*/
cout<<"Wprowadz pierwsza liczbe calkowita";
Tutaj widzimy wykorzystanie obiektu biblioteki standardowej. Używając obiektu cout razem z operatorem <<
wrzucamy dany tekst do strumienia(czyli po prostu wypisujemy na ekran). Każdy tekst musi być ujęty w cudzysłówowia.
/*----------------------------------------------------------------------------------------------------------*/
cin>>uiVariable1;
Tutaj mamy kolejny obiekt biblioteki standardowej. Pozwala on na wczytanie danych z klawiatury.
Trzeba uważać aby podawać dane takiego typu jakiego używamy w operacji wczytania(w tym wypadku po prostu liczba, uiVariable1 jest  typu unsigned int).
/*------------------------------------------------------------------------------------------------------------*/
13: if(uiVariable1 < uiVariable2)
14: {
15: cout << "Pierwsza liczba jest mniejsza od drugiej" << endl;
16: } else if(uiVariable1 > uiVariable2)
17: {
18: cout << "Pierwsza liczba jest wieksza od drugiej" << endl;
19: } else cout << "Pierwsza liczba jest rowna drugiej" << endl;

Jest to zwykły blok if. Jeżeli wartość wyrażenia w nawiasach po if jest true wykona się blok kodu zawarty między klamrami.

cout<<"tekst"<<endl;
Obiektu cout można używać kaskadowo. Czyli zamiast pisać cout<<"pierwszy"; cout<<"drugi";
Piszemy po prostu cout<<"jeden"<<"dwa";
Tajemniczy element endl także jest elementem biblioteki standardowej powoduje On przejście do następnej lini.
Instrukcja else if oznacza dość jednoznacznie, jeżeli if(Var1<Var2) jest nieprawdziwe program przechodzi do instrukcji else if gdzie znów sprawdzany jest warunek, jeżeli On również jest nieprawdziwy program wykona instrukcje zawarte w else bez sprawdzania warunków.  Ktoś może zapytać dlaczego w else nie ma klamer. Odpowiedź jest bardzo prosta, kiedy instrukcje są jednolinijkowe nie trzeba używać klamer.
np: if(2>1)cout<<"cos";
lub
if(2>1)
cout<<"cos";
Program uzna, że instrukcja kończy się w końcu następnej instrukcji zakończonej średnikiem.
/*----------------------------------------------------------------------------------------------------------------------*/
unsigned int i=0;
for(i=0;i<5;i++)
{
if((uiVariable1 % 2) == 0) cout <<
"Liczba jest parzysta i wynosi : " << uiVariable1 << endl;
}

Jest to zwykła pętla for(//tutaj ustalmy poczatkową wartosc licznika ; //tutaj sprawdzany jest warunek ; //instrukcje jakie mają być wykonane po każdej pętli w naszym przypadku zwiększenie licznika o 1)
Pętla zakończy swoją prace kiedy warunek i<5 wyniesie false.
if((uiVariable1 % 2) == 0)
operator % to po prostu dzielenie z reszta.
/*------------------------------------------------------------------------------------------------------------------------*/

While(i>0)
{
i--;
}

Tego chyba  nie trzeba wyjaśniać.
/*-----------------------------------------------------------------------------------------------------------------------*/
do
{
i++;
}
while(i<5)

To samo tylko pętla wykona się przynajmniej raz nawet jeśli warunek jest nie sprawdzony.
/*-------------------------------------------------------------------------------------------------------------------------*/

43: switch(uiVariable1)
44: {
45: case 5:
46: cout << "Liczba jest rowna 5" << endl;
47: break;
48: default :
49: cout << "Liczba jest rozna od 5" << endl;
50: }

Ten sam efekt można uzyskać używając po prostu if,else i else if.
switch(var1)
czyli co ma zostać poddane sprawdzaniu
45: case 5:
46: cout << "Liczba jest rowna 5" << endl;
47: break;

case 5:
Czyli w przypadku gdy element sprawdzany ma wartość 5 wykona się instrukcja pod case.
break;
Daje to znak programowi, że ma opuścić dany zasięg czyli w tym wypadku blok switch.
Tutaj także w wypadku wielolinijkowych linii kodu dajemy klamry.
case 5:
{
cout << "Liczba jest rowna 5" << endl;

cout<<"cos jeszcze";
}
break;

W przypadku gdy switch nie odnajdzie pasującego case przechodzi i wykonuje blok default.
/*--------------------------------------------------------------------------------------------------------*/
System("pause");

zatrzymuje prace programu gdyby nie to program wykonałby prace i natychmiast się wyłączył a tak poczeka na naciśnięcie klawisza.

/*--------------------------------------------------------------------------------------------------------*/
return 0;
Zwraca liczbę informującą o poprawnym zakończeniu programu.
/*----------------------------------------------------------------------------------------------------------*/

Tajemnicze using namespace std; Bez tego do każdego obiektu z biblioteki standardowej musielibyśmy się odnosić std::cout,std::endl,std::cin używanie tego jest dobre kiedy mamy konflikt nazw a używając std:: jednoznacznie oznaczamy o który obiekt nam chodzi. Najczęściej dołączamy instrukcje using... aby skrócić i ułatwić pisanie.

Na początek to tyle. Chciałbym aby każdy poćwiczył używanie pętli,if'ow,operacje na danych. A najlepiej jakby swoje wypociny wkleił tutaj. W razie problemów pytać.


A Teraz mały dodatek  o typach:
wartości i liczbą okupowanych bajtów pamięci.
Typ               Bajtów           signed                                                        unsigned
char              1              -128 … 127                                                      0 ... 255
short             2              -32 768 ... 32 767                                            0 ... 65 535
int                 4              -2147483648 ... 2 147 483 647                      0 ... 4 294 967 295
long              4               -2147483648 ... 2 147 483 647                      0 ... 4 294 967 295
//float i double nie maja wersji unsigned!
float              4               -3.4*10-38 ... 3.4*1038 (7 cyfr)
double           8               -1.7*10-308 ... 1.7*10308 (15 cyfr)