ICO wiki - User contributions [en]

C++ lühikursus

2010-02-19T15:01:12Z

Jsarjas: /* Tüübiteisendus */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== Tingimus operaator (?:) ==

Tingimus (true/false) ? tulemus1, kui on tõene : tulemus2, kui on väär

<pre>
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;
// c:7, sest (2>7) on väär ja valitakse teine muutuja b väärtusega 7
</pre>

== koma (,) ==

Koma operaatorit kasutatakse seal, kus on oodatud ainult üks tehe, aga tehakse rohkem kui üks tehe.

<pre>
a = (b=3, b+2); // a:5
a = b=3, b+2; // a:3
</pre>

[http://en.wikipedia.org/wiki/Comma_operator Comma operator]

== Tüübiteisendus ==

[http://en.wikibooks.org/wiki/C++_Programming/Type_Casting C++ Type Casting]

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T15:00:48Z

Jsarjas: /* Tüübiteisendus */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== Tingimus operaator (?:) ==

Tingimus (true/false) ? tulemus1, kui on tõene : tulemus2, kui on väär

<pre>
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;
// c:7, sest (2>7) on väär ja valitakse teine muutuja b väärtusega 7
</pre>

== koma (,) ==

Koma operaatorit kasutatakse seal, kus on oodatud ainult üks tehe, aga tehakse rohkem kui üks tehe.

<pre>
a = (b=3, b+2); // a:5
a = b=3, b+2; // a:3
</pre>

[http://en.wikipedia.org/wiki/Comma_operator Comma operator]

== Tüübiteisendus ==

[http://en.wikipedia.org/wiki/Type_conversion Type conversion]

[http://en.wikibooks.org/wiki/C++_Programming/Type_Casting C++ Type Casting]

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T15:00:40Z

Jsarjas: /* Tüübiteisendus */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== Tingimus operaator (?:) ==

Tingimus (true/false) ? tulemus1, kui on tõene : tulemus2, kui on väär

<pre>
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;
// c:7, sest (2>7) on väär ja valitakse teine muutuja b väärtusega 7
</pre>

== koma (,) ==

Koma operaatorit kasutatakse seal, kus on oodatud ainult üks tehe, aga tehakse rohkem kui üks tehe.

<pre>
a = (b=3, b+2); // a:5
a = b=3, b+2; // a:3
</pre>

[http://en.wikipedia.org/wiki/Comma_operator Comma operator]

== Tüübiteisendus ==

[http://en.wikipedia.org/wiki/Type_conversion Type conversion]
[http://en.wikibooks.org/wiki/C++_Programming/Type_Casting C++ Type Casting]

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:59:04Z

Jsarjas: /* Tüübiteisendus */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== Tingimus operaator (?:) ==

Tingimus (true/false) ? tulemus1, kui on tõene : tulemus2, kui on väär

<pre>
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;
// c:7, sest (2>7) on väär ja valitakse teine muutuja b väärtusega 7
</pre>

== koma (,) ==

Koma operaatorit kasutatakse seal, kus on oodatud ainult üks tehe, aga tehakse rohkem kui üks tehe.

<pre>
a = (b=3, b+2); // a:5
a = b=3, b+2; // a:3
</pre>

[http://en.wikipedia.org/wiki/Comma_operator Comma operator]

== Tüübiteisendus ==

[http://en.wikipedia.org/wiki/Type_conversion Type conversion]

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:57:50Z

Jsarjas: /* koma (,) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== Tingimus operaator (?:) ==

Tingimus (true/false) ? tulemus1, kui on tõene : tulemus2, kui on väär

<pre>
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;
// c:7, sest (2>7) on väär ja valitakse teine muutuja b väärtusega 7
</pre>

== koma (,) ==

Koma operaatorit kasutatakse seal, kus on oodatud ainult üks tehe, aga tehakse rohkem kui üks tehe.

<pre>
a = (b=3, b+2); // a:5
a = b=3, b+2; // a:3
</pre>

[http://en.wikipedia.org/wiki/Comma_operator Comma operator]

== Tüübiteisendus ==

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:56:11Z

Jsarjas: /* (,) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== Tingimus operaator (?:) ==

Tingimus (true/false) ? tulemus1, kui on tõene : tulemus2, kui on väär

<pre>
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;
// c:7, sest (2>7) on väär ja valitakse teine muutuja b väärtusega 7
</pre>

== koma (,) ==

Koma operaatorit kasutatakse seal, kus on oodatud ainult üks tehe, aga tehakse rohkem kui üks tehe.

<pre>
a = (b=3, b+2);
</pre>

[http://en.wikipedia.org/wiki/Comma_operator Comma operator]

== Tüübiteisendus ==

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:52:04Z

Jsarjas: /* Operaatorid ja tehted */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== Tingimus operaator (?:) ==

Tingimus (true/false) ? tulemus1, kui on tõene : tulemus2, kui on väär

<pre>
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;
// c:7, sest (2>7) on väär ja valitakse teine muutuja b väärtusega 7
</pre>

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:51:34Z

Jsarjas: /* Tingimus operaator (?:) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== Tingimus operaator (?:) ==

Tingimus (true/false) ? tulemus1, kui on tõene : tulemus2, kui on väär

<pre>
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;
// c:7, sest (2>7) on väär ja valitakse teine muutuja b väärtusega 7
<pre>

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:51:11Z

Jsarjas: /* (?) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== Tingimus operaator (?:) ==

Tingimus (true/false) ? tulemus1, kui on tõene : tulemus2, kui on väär

<pre>
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;
// c:7, sest (2>7) on väär ja valitakse teine muutuja b väärtusega 7
<pre>

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:41:59Z

Jsarjas: /* Tehete järjekord */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== (?) ==

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

vaata linke [http://wiki.itcollege.ee/index.php/C%2B%2B_l%C3%BChikursus#Lisalugemist_2 lisalugemise] all.

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:41:12Z

Jsarjas: /* Tehete järjekord */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== (?) ==

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

vaata linke lisalugemise all

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:40:09Z

Jsarjas: /* Lisalugemist */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== (?) ==

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Kui klaviatuurilt ei saa mõnda operaatorit sisestada [http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

Tehete järjekord ja operaatorite üledefinerimise näide [http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:38:54Z

Jsarjas: /* Võrdlustehted ( ==, !=, >, <, >=, <= ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true, sest b väärtustatakse kahega (2 == 2).
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== (?) ==

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:37:33Z

Jsarjas: /* Võrdlustehted ( ==, !=, >, <, >=, <= ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

Võrdlevad arvulisi väärtusi, tagastab true või false.

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

<pre>
(7 == 5) // false.
(5 > 4) // true.
(3 != 2) // true.
(6 >= 6) // true.
(5 < 5) // false.

int a = 2;
int b = 3;
int c = 6;

(a == 5) // false, sest a ei ole võrdne viiega.
(a*b >= c) // true, sest (2*3 >= 6) on tõene.
(b+4 > a*c) // false, sest (3+4 > 2*6) on väär.
((b=2) == a) // true.
</pre>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== (?) ==

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:32:38Z

Jsarjas: /* Võrdlustehted ( ==, !=, >, <, >=, <= ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

<table>
<tr>
<td> == </td><td> Võrdus </td>
</tr>
<tr>
<td> != </td><td> Mittevõrdus </td>
</tr>
<tr>
<td> > </td><td> Suurem kui </td>
</tr>
<tr>
<td> < </td><td> Väiksem kui </td>
</tr>
<tr>
<td> >= </td><td> Suurem või võrdne </td>
</tr>
<tr>
<td> <= </td><td> Väiksem või võrdne </td>
</tr>
</table>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== (?) ==

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:31:42Z

Jsarjas: /* Võrdlustehted ( ==, !=, >, <, >=, <= ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

<table>
<tr>

<td> == </td><td> Võrdus </td>
<td> != </td><td> Mittevõrdus </td>
<td> > </td><td> Suurem kui </td>
<td> < </td><td> Väiksem kui </td>
<td> >= </td><td> Suurem või võrdne </td>
<td> <= </td><td> Väiksem või võrdne </td>

</tr>
</table>

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== (?) ==

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:26:30Z

Jsarjas: /* Loogikatehted ( !, &&, || ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false;
bool b = !a; // b:true
</pre>
</td>
</tr>

<tr>
<td>&&</td><td>AND</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a && b; // c:false
</pre>
</td>
</tr>

<tr>
<td>||</td><td>OR</td>
<td>
<pre>
bool a = false;
bool b = true;
bool c = a || b; // c:true
</pre>
</td>
</tr>
</table>

== (?) ==

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:15:11Z

Jsarjas: /* Loogikatehted ( !, &&, || ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

Võrdlevad kahendväärtusi (true, false)

<table>
<tr>
<td>!</td><td>NOT</td>
<td>
<pre>
bool a = false
bool b = !a // b:true
</pre>
</td>
</tr>
</table>

== (?) ==

== (,) ==

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:08:48Z

Jsarjas: /* Operaatorid ja tehted */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

== Tehete järjekord ==

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:08:16Z

Jsarjas: /* Operaatorid ja tehted */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

== Tüübiteisendus ==

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:04:55Z

Jsarjas: /* Suurendamine, vähendamine ühe võrra (++, --) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix (suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:04:24Z

Jsarjas: /* Bititehted ( &, |, ^, ~, <<, >> ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0xF000
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:02:39Z

Jsarjas: /* Bititehted ( &, |, ^, ~, <<, >> ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0x0
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T14:01:02Z

Jsarjas: /* Bititehted ( &, |, ^, ~, <<, >> ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>

<tr>

<td>|</td><td>OR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a | b; // c:0xFFFF
</pre>
</td>

</tr>

<tr>

<td>^</td><td>XOR</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a ^ b; // c:0xFF0
</pre>
</td>

</tr>

<tr>

<td>~</td><td>NOT</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
int b = ~a; // b:0xF0
</pre>
</td>

</tr>

<tr>

<td> << </td><td>SHL</td><td>Vasakule nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a << 8; // b:0xF0F0
b = a << 5; // b:0xE1E0
b = a << 12; // b:0x0
</pre>
</td>

</tr>

<tr>

<td> >> </td><td>SHR</td><td>Paremale nihe</td>
<td>
<pre>
short int a = 0xFF0F;
short int b = a >> 8; // b:0x0FF0
b = a >> 16; // b:0x0
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T13:49:19Z

Jsarjas: /* Bititehted ( &, |, ^, ~, <<, >> ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
short int a = 0xFF0F;
short int b = 0xF0FF;
int c = a & b; // c:0xF00F
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T13:45:40Z

Jsarjas: /* Bititehted ( &, |, ^, ~, <<, >> ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Bititehted modifitseerivad muutujaid arvestades nendes hoitavate väärtuste bitte.

<table>
<tr>

<td>&</td><td>AND</td><td></td>
<td>
<pre>
int a =
</pre>
</td>

</tr>
</table>

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T13:38:52Z

Jsarjas: /* Lisalugemist */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

[http://www.cppreference.com/wiki/alternative_operators Alternative Operators]

[http://www.cppreference.com/wiki/operator_precedence C++ Operator Precedence and overloading]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T13:28:17Z

Jsarjas: /* Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
a %= b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
a = a % b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T13:26:04Z

Jsarjas: /* Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td> <-> </td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
</pre>
</td>
<td> <-> </td>
<td>
<pre>
a = a - b;
a = a + b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T13:23:27Z

Jsarjas: /* Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

Kui me tahame modifitseerida muutuja väärtust rakendades talle mingit tehet hetkel salvestatud väärtusele selles muutujas.
Näiteks:

<table>
<tr>
<td>Tehtega omistamine</td><td>On samaväärne</td>
</tr>
<tr>
<td>
<pre>
a -= b;
a += b;
</pre>
</td>
<td>
<pre>
a = a - b;
a = a + b;
</pre>
</td>
</tr>
</table>

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T13:10:20Z

Jsarjas: /* Aritmeetilised tehted ( +, -, *, /, % ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Millega lugeja ehk kokku puutunud pole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T13:01:32Z

Jsarjas: /* Aritmeetilised tehted ( +, -, *, /, % ) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

Liitmine(+), lahutamine(-), korrutamine(*) ja jagamine(/) on üsna tavalised tehted ja nendest siin kirjutama ei hakka.
Mis aga nii tavaline ei ole on jäägiga jagamine(%).

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T12:57:10Z

Jsarjas: /* Suurendamine, vähendamine ühe võrra (++, --) */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

% on jäägiga jagamine

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

== Suurendamine, vähendamine ühe võrra (++, --) ==

Ühe võrra suurendamisega samaväärsed tehted.

<pre>
a++;
a+=1;
a=a+1;
</pre>

Prefix ja postfix(suffix).

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>

Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T12:47:25Z

Jsarjas: /* Operaatorid ja tehted */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

% on jäägiga jagamine

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

== Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ==

== Suurendamine, vähendamine ühe võrra (++, --) ==

<pre>
int a = 5;
// prefix, väärtustamine peale a väärtuse inkrementeerimist
int b = ++a; // b:6, a:6
// postfix, väärtustamine enne a väärtuse inkrementeerimist
int c = a++; // c:5, a:6
</pre>
Sama kehtib ka vähendamisel.

== Võrdlustehted ( ==, !=, >, <, >=, <= ) ==

== Loogikatehted ( !, &&, || ) ==

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

== Lisalugemist ==

[http://www.cplusplus.com/doc/tutorial/operators/ Operators]

[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T12:30:08Z

Jsarjas: /* Operaatorid ja tehted */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=
[http://www.cplusplus.com/doc/tutorial/operators/ Operators]
[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

== Muutuja väärtustamine (=) ==

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

== Aritmeetilised tehted ( +, -, *, /, % ) ==

% on jäägiga jagamine

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

== Bititehted ( &, |, ^, ~, <<, >> ) ==

Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

(++, --)

( ==, !=, >, <, >=, <= )

( !, &&, || )

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-19T12:28:47Z

Jsarjas: /* Operaatorid ja tehted */

=Kursusest=

ITK robootikaklubis kasutatakse pilditöötlusplatvormina enda poolt C++, QT4 ja OpenCV vanenditega loodud raamistiku. Kuna õppekavas C++ puudub:( ja samas on seda vähemalt robootikutel vaja siis siin lehel on kursuse materjalid ja tegevused.

=Harjutustunnid=
1. [http://www.cplusplus.com/doc/tutorial/program_structure/ Structure of a program] läbi lugeda

=Sissejuhatus=
Mis on C++ ja miks meil seda vaja on?
[http://langpop.com/ programmeerimiskeelte populaarsus]

=Keele põhikonstruktsioonid=

if - tingimuslause

Esimene tüüp - puhas IF

if("tingimus mille puhul seda tingimuslauset täidetakse"){
"tegevus mis sooritatakse kui tingimus tõele vastab"
}

NÄIDE
<pre>
#include <iostream>
using namespace std;
int main (){
//defineerin boolean i mille väärtus on true
bool i =true;
//if lause mis käivitub siis kui boolean i väärtuseks on true
if (i){
cout << "Hello World!";
}

}
</pre>

Teine tüüp -if else

Kui me näiteks meil on rohkem kui üks stsenaarium mille puhul soovime kasutada erinevaid tingimuslauseid võime kasutada "if else" lauset. Eriti mugav on seda kasutada väärtusvahemike eraldamiseks

NÄIDE:

<pre>
#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number ";
//küsib käsurealt numbrit
cin >> number;
//kui number on suurem kui 75 siis väljastab sõna "kala"
if (number >75 )
cout << "kala" << endl;
//kui number on suurem kui 50 aga väiksem kui 75 siis väljastab sõna "koer"
else if (number >50 )
cout << "koer" << endl;
//kui number on väiksem kui 50
else
cout << "mauntz" << endl;
return 0;
}
</pre>

Kolmas tüüp - valikulause (switch statement)

Kui meil näiteks on vaja, et muutuja iga konkreetse väärtuse peale käivituks erinev tingimus, võime kasutada valiklauset (switch case). Valiklauseid on suhteliselt kerge jälgida ning modifitseerida. Töötab see nii, et alustades ülaltpoolt hakkab programm võrdlema tingimusi- juhul kui tingimus sobib käivitab ta selle bloki. Viimane case blokk on "default" mis käivitatakse alati kui programm sinna jõuab. Kuna iga bloki lõpus on ka break käsk siis sinnani jõudes katkestatakse valiklause ning lõpetatakse seal oleva koodi täitmine.

NÄIDE

<pre>#include <iostream>
using namespace std;
int main(void)
{
int number;
cout << "Sisesta number 1,2 või 3 ";
cin >> number;
switch (number) {
//juhul kui number on üks käivitame selle bloki
case 1:
cout << "sisestati number 1 " << endl;
break;
//juhul kui number on 2 käivitame selle bloki
case 2:
cout << "Sisestati number 2" << endl;
break;
//juhul kui eelnevaid blokke pole üldse käivitatud lähme siia blokki
default:
cout << "Sisestati number mis pole kaks ega üks" << endl;
}
}
</pre>

While kordus

while(tingimus){kood mida täidetakse nii kaua kuni tingimus kehtib}

NÄIDE

<pre>#include <iostream>
using namespace std;

int main ()
{
int n;
cout << "Number";
cin >> n;
// while loop millest ei väljuta ennne kui tingimus ei vasta enam tõele (ehk n on väiksem kui 0)
while (n>0) {
cout << n << ", ";
//lahutame 'n'ist iga tsükli käivitamise korral ühe
n=n-1;
}
return 0;
}
</pre>

Do-while kordus

Do while kordus on põhimõtteliselt sama nagu while kordus ühe väikse erandiga: nimelt kontrollitakse tsüklist väljumise tingimust peale seda kui tsükkel on juba käivitatud. See tagab, et antud tsükkel käivitatakse vähemalt üks kord ka siis kui tingimus ei pruugi tõele vastata. Mis on väga kasulik juhul kui kontrolltingimus tsüklist väljumiseks on defineeritud tsükli enda sees .

NÄIDE
<pre>
#include <iostream>
using namespace std;

int main ()
{
unsigned long n;
do {
cout << "Enter number (0iga väljud tsüklist): ";
cin >> n;
cout << "sisestati: " << n << "\n";
} while (n != 0);
return 0;
}
}</pre>

==Muutujate deklareerimine==
===Deklareerimine===
Muutuja deklareerimine ütleb kompileerimise ajal kompilaatorile muutuja tüübi ning selle võimaliku suuruse - double (8 baiti), int (4 baiti), short (2 baiti), char (1 bait) jne.

Deklareerime int tüüpi muutuja 'a'.

'''Näide:'''
<pre>int a;</pre>

===Defineerimine===
Muutuja defineerimine sisaldab endas muutujale mälu eraldamist ning muutuja (esmase) väärtuse salvestamist mällu.

Defineerimine eelnevalt deklareeritud int tüüpi muutuja 'a'.

'''Näide:'''
<pre>a = 10;</pre>

Kui muutuja pole eelnevalt deklareeritud, siis on võimalik deklareerimine ja defineerimine omavahel kombineerida.
'''
Näide:'''
<pre>int a = 10;</pre>

===Muutujate deklareerimine funktsioonides===
Muutuja deklareerimine funktsiooni sees eraldab automaatselt muutujale mälu (defineerib muutuja).

'''Näide:'''
<pre>
int main()
{
int a;
return 0;
}
</pre>
Selline deklareermine on ohtlik, sest me ei tea, mis on muutuja 'a' väärtus. Kuna kompilaator defineerib muutuja 'a' automaatselt, siis ta väärtuseks saab see, mis parasjagu talle eraldatud mälu aadressil salvestatud oli.

===Muutujate väärtustamine===
Muutuja deklareerimisel on ta väärtus esialgu määramata või teadmata.
Esmakordset väärtustamist nimetatakse muutuja initsialiseerimiseks (''initialization'').

'''Näide:'''
<pre>
int a = 0;
int a (0); //constructor initialization
</pre>
Mõlemal kujul initsialiseerimine on C++ puhul korrektne.

===Lisalugemist===
Rohkem näiteid ja täpsemalt muutujate deklareerimise kohta saab lugeda aadressidelt:
[http://www.cplusplus.com/doc/tutorial/variables/ http://www.cplusplus.com/doc/tutorial/variables/]

[http://stackoverflow.com/posts/671984/revisions http://stackoverflow.com/posts/671984/revisions]

=Operaatorid ja tehted=
[http://www.cplusplus.com/doc/tutorial/operators/ Operators]
[http://en.wikipedia.org/wiki/Operators_in_C_and_C++ Operators in C and C++]

Muutuja väärtustamine (=)

<pre>#include <iostream>
int main () {
int a,b,c; // a:?, b:?, c:?
c = 0xFF; // c:255
a = 2 + (b = 5); // a:7, b:5
a = b = c = 5; // kõik väärtusega 5
}</pre>

Aritmeetilised tehted ( +, -, *, /, % )

% on jäägiga jagamine

<pre>
x = 9 % 6
</pre>

X väärtuseks saab 3, sest üheksa jagamisel kuuega on jääk 3.

Bititehted ( &, |, ^, ~, <<, >> )

Tehtega väärtustamine (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

(++, --)

( ==, !=, >, <, >=, <= )

( !, &&, || )

(?)

(,)

<pre>
a = (b=3, b+2);
</pre>

Tehete järjekord

=Sisendi ja väljundi manipuleerimine=
[http://www.cplusplus.com/reference/iostream/manipulators/ IOStream'i manipulaatorid] <br>
Ekraanil oleva teksti sisendi ja väljundi manipuleerimiseks on vaja kaasata "iomanip" header:
#include <iomanip>

==Välja laius==
setw(x), kus x on tähemärkide arv väljal.<br/>
Näide korralikult formeeritud korrutustabelist:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

==Joondamine väljal==
Väljal olevat teksti saab joondada vasakule ja paremale. Algselt joondatakse numbrid paremala ja selle jaoks on vaja ainult vasakjoondus sisse ja välja lülitada.<br/>
Sisse ja välja lülitamine:
setiosflags(ios::left);
resetiosflags(ios::left);

Kui teiste juhtumite korral on vaja paremjoondust, siis tasub kasutada ios::right lippu.<br/>
Näide, kus üle rea vahetatakse joondust:
<pre>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
const int max = 12;
const int width = 6;
for(int row = 1;row <= max;row++) {
if(row % 2) {
cout << setiosflags(ios::left);
}
else {
cout << resetiosflags(ios::left);
}
for(int col = 1;col <= max;col++) {
cout << setw(width) << row * col;
}
cout << endl;
}
return 0;
}
</pre>

=OpenCV=
==CvPoint==

Open CV-s on 5 erinevat punkti klassi, millega võib meelde jäta punkti kordinaate pinnal või ruumis.
Järgnevad näited erinevate punktide loomisest ja seletused nende järel.

<pre>
int main()
{
CvPoint uus = CvPoint(int x, int y) // Maht on vastav protsessori arhitektuurile (tavaliselt 32bit või 64bit). Klass on täisarvulise 2D punkti hoidmiseks mõeldud.
CvPoint2D32f uus = CvPoint2D32f(float x, float y) // Maht on 32bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D32f uus = CvPoint3D32f(float x, float y, float z) // Maht on 32bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.
CvPoint2D64f uus = CvPoint2D64f(double x, double y) // Maht on 64bit. Klass on komakohaga 2D punkti hoidmiseks mõeldud.
CvPoint3D64f uus = CvPoint3D64f(double x, double y, double z) // Maht on 64bit. Klass on komakohaga 3D punkti hoidmiseks mõeldud.

return 0;
}
</pre>

==cvLine==

Joone joonistamiseks pinnal kasutatakse cvLine funktsiooni, mis võtab sisse pildi, alguspunkti, lõpppunkti, värvi (RGB), joone paksuse, joone tüübi, kui palju joont liigutada võib.<br/>
funktsioon: cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0)
<pre>
int main(int argc, char *argv[]) // argc - mitu argumenti käsurealt kaasa anti programmi käivitamisel, argv[?] - argumentide massiiv
{
IplImage* img = cvLoadImage(argv[1]); // proovime laadida esimese argumendiga pildi
if(!img) // siis pole mõtet jätkata
{
cout << "Pilti ei leitud!" << endl; // teavitame kasutajat, et pilti ei leitud
exit(0); // ja paneme programmi kinni
}
CvPoint algus = CvPoint( (img->width/2), 0); // määrame alguspunkti pildi ülemisse äärde keskele
CvPoint lopp = CvPoint( (img->width/2), img->height ); // määrame lõpppunkti pildi alumisse äärde keskele

cvLine(img, algus, lopp, CV_RGB(0,255,0), 1, 8, 0); // joonistame joone

return 0;
}
</pre>

=Lingid=
[http://www.cplusplus.com/doc/tutorial/ C++ tutorial]
[[Category:Robootika]]

C++ lühikursus

2010-02-14T11:32:25Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T11:30:55Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T11:19:39Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T11:14:19Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T11:06:23Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T10:59:10Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T10:55:33Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T10:54:55Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T10:54:16Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T10:54:03Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T10:53:13Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T10:45:42Z

Jsarjas: /* Operaatorid ja tehted */

C++ lühikursus

2010-02-14T10:44:34Z

Jsarjas: /* Operaatorid ja tehted */