zaterdag 18 juni 2011

Les4 C++ BESLISSINGEN

Beslissingen

Nu we kunnen rekenen met de variabelen komt het volgende gereedschap aan de beurt hiermee kunnen we het programma beslissingen laten nemen.  Waardoor we het programma een keuze kunnen laten maken.
We laten hiervoor het programma controleren of een bewering waar is of niet waar
Als de bewering waar is voer dan de volgende opdracht uit
Is de bewering niet waar sla dan de opdracht over.
Dit stuk gereedschap heeft 3 basis instellingen met enkele hulp stukken, die we nader zullen bekijken.
De hulpstukken die we nodig hebben noemen we de relational operators

Operator
 Symbool 
Form
Bewerking
Groter dan
>
x > y
WAAR als x groter is dan y, anders NIET WAAR
Kleiner dan
<
x < y
WAAR als x kleiner is dan y,
anders NIET WAAR
Groter dan of
gelijk aan
>=
x >= y
WAAR als x groter of gelijk
aan y, anders NIET WAAR
Kleiner dan of
gelijk aan
<=
x <= y
WAAR als x kleiner dan of gelijk
aan y, anders NIET WAAR
Gelijk aan
==
x == y
WAAR als x gelijk aan y is
anders NIET WAAR
Niet Gelijk aan
!=
x != y
WAAR als x NIET gelijk aan y is
anders NIET WAAR








Eerste instelling:                                       Tweede instelling:                                    Derde instelling:
if(condition)
{
  statement;
}


 
 
======================================================================
 
 



int nX ;if(nX < 10)" nX < 10 " << nX << endl;

 

nX = 9;

{
cout <<
}












=====================================================================
 



 




int nX ;if(nX < 10)" nX < 10 " << nX << endl;else
nX = 9;

{
cout <<
}

{" nX > 10 " << nX << endl;
cout <<
}


 












==================================================================








  int nX ; if(nX < 10)" nX < 10 " << nX << endl; else if( nX > 10)" nX > 10 " << nX << endl; else {
 cout <<
 }
" nX > 10 " << nX << endl;


 nX = 9;

 {
 cout <<
 }

 {
 cout <<
 }

Les3 C++ REKENEN

Rekenen

 Binary arithmetic operators

Nu we materiaal hebben kunnen we er het eerste gereedschap bij halen om het materiaal te bewerken. Het eerste gereedschap is het gereedschap waarmee we kunnen rekenen. En dit gereedschap heeft de volgende basis instellingen waaruit we kunnen kiezen.

Optellen                         +
Aftrekken                        -
Vermenigvuldigen          *
Delen                              /
Modulus                         %

 Dit zijn de arithmetic operators

Met behulp van de assignment operator = kunnen we de uitkomst bewaren in een variabele.
Datgene wat rechts staat van het = teken zal worden uitgerekend  en
dan overgebracht worden naar de variabele links van het = teken.


som = getal 1 + getal 2
Het programma zal de waardes ophalen uit het geheugen. Vervolgens naar de CPU sturen. de CPU berekent het en stuurt het antwoord weer terug.




Bewerkings volgorde.

Zie hier enkele sommen:

3 + 4 – 8 =
3 + 4 – 8 /5 * 6 =
3 + 4 - -8 * 6 / 10 + 9 * 2 =

In welke volgorde moeten we dit nu oplossen ?
Hierover is een afspraak gemaakt. Vroeger ging het volgens “Meneer Van Dale Wacht Op Antwoord” wat staat voor eerst machtsverheffen dan vermenigvuldigen , delen, worteltrekken optellen, aftrekken. Dit is echter achterhaald nu is de afspraak.
1.Haakjes.
2.Machtsverheffen en worteltrekken.
3.Vermenigvuldigen en Delen.
4.Optellen en Aftrekken.

Voor ons is het nu belangerijk te weten welke volgorde de computer hanteert.
Dit kunnen we controleren met een voorbeeld dan zien we het zelf.

#include <iostream>
#include <climits>

using namespace std;

int main(void)
{

        float nGetal1;
        float nGetal2;
        float nGetal3;

        float nAntwoord1;
        float nAntwoord2;
        float nAntwoord3;

        nGetal1 = 8;
        nGetal2 = 7;
        nGetal3 = 3;

        nAntwoord1 = 0;
        nAntwoord2 = 0;
        nAntwoord3 = 0;

        nAntwoord1 = (nGetal1 / nGetal2) * nGetal3;
        nAntwoord2 = nGetal1 / (nGetal2 * nGetal3);
        nAntwoord3 = nGetal1 / nGetal2 * nGetal3 ;

        cout << "Antwoord =  " << nAntwoord1<< '\n';
        cout << "Antwoord =  " << nAntwoord2<< '\n';
        cout << "Antwoord =  " << nAntwoord3<< '\n';
    return 0;
}

Wat tussen haakjes staat wordt eerst uitgerekend. Haal de haakjes weg en kijk of je het zelfde antwoord krijgt. Probeer nu zelf wat sommen te maken en kijk in welke volgorde ze worden opgelost. Noteer nu voor je zelf welke volgorde de computer hanteert.
Dit blijft altijd lastig vandaar dat haakjes al veel verduidelijken
En niet iedereen kent of houdt zich aan afspraken.
Kijk maar naar gewicht joule bar.



#include <iostream>
using namespace std;

int main()
{// begin blok

        //declareer
        int nGetal1;  //local variabelen
        int nGetal2;

        int nSom;
        int nProdukt;
        float nBreuk;
        int nVerschil;


        //initialiseer

        nGetal1 = 4;
        nGetal2 = 7;

        // instructies
        nSom = nGetal1 + nGetal2;
        nProdukt = nGetal1 * nGetal2;
        nBreuk =   (float)nGetal1 /nGetal2;
        nVerschil = nGetal1 - nGetal2;

                nGetal1 = nGetal1 + nGetal2;
        cout <<”de waarde van nGetal is nu “ << nGetal << endl;
                nGetal1 = nGetal1 + nGetal2
        cout <<”de waarde van nGetal is nu “ << nGetal << endl;

                nGetal1 = nGetal1 + nGetal2;
                nGetal1 = nGetal1 + nGetal2;

        cout <<”de waarde van nGetal is nu “ << nGetal << endl;
cout <<”de waarde van nGetal is nu “ << nGetal << endl;


        cout << "Toon getallen " << nGetal1<< "\t" << nGetal2 << endl;
        cout << "Toon adres " << &nGetal1<< "\t" << &nGetal2 << endl;
        cout << "Toon getallen " <<  nSom << endl;
        cout << "Toon adres " << nProdukt << endl;
        cout << "Toon getallen " <<  nBreuk << endl;
        cout << "Toon adres " << nVerschil << endl;


        return 0;
}// einde blok

Converteren

Als we twee integers 8 / 5 willen delen krijgen we een probleem, de uitkomst is namelijk geen geheel getal , we zullen er dus voor moeten zorgen dat de variabelen van het type float worden. Of we converteren deze integers naar float. Dit kan door (float) voor de berekenning te zetten.

Modules %
De remainder operator
Modulus % deze werkt alleen met  integers.

7 % 3 = 1  dit is 7 / 3 gaat 2 x 3 = 6  blijft over 7 – 6 = 1.
48 % 9 =  3  gaat 5 x 9 = 45 ,blijft over 48 – 45 = 3.

Mooi maar wat kun je er mee ? We zullen later zien dat je het kunt gebruiken om een periodieke
Instelling te maken.



Tot zover de binary aritmetic operators.

Belangrijk is nu om te weten:
De bewerkings volgorde
Gebruik haakjes om het eventueel duidelijker te maken.
De juiste types gebruikt worden.
Delen door nul moet je nooit doen.
En opletten met negatieve getallen.

Toets

  1. Wat is hier fout ?.
      ngetal1 + ngetal2 = nsom;
  2. Wat wil sequentieel zeggen ?.
  3. hoe vind je het adres van een variabele ?.
  4. hoe noemen we het is = teken ?.
  5. welke data types zijn er ?.
  6. wat vertelt het { teken je ?.
Bekijk het volgende stukje code
1. maak het in orde.
2. zorg dat nAntwoord1 klopt, bedenk  twee manieren om het op te lossen.

include <iostream>
using namespace sdt

int main(void)
{

        int nGetal1;
        int nGetal2;
        int nAntwoord1;
       
        nGetal1 = 8;
        nGetal2 = 7;
        nAntwoord1 = 0;

        nAntwoord1 = nGetal1 / nGetal2;
  cout >> "Antwoord =  " >> nAntwoord1>> '\n';

    return 0;
{


Sequentieel

Je kunt niet eerst een waarde op vragen en daarna deze waarde declareren.
het programma werkt seqentieel, dit wil zeggen dat regel na regel gelezen en uitgevoerd wordt.
Het programma kan dus niet weten wat op regel tien staat als deze pas bij regel 9 is.

Opdracht: verander de plaats van regels in je programma bedenk wat er gebeuren zal
en controleer of je gelijk hebt.

Dat is weer het fijne aan programmeren je kunt na gaan of het werkt en of de compiler het signaleert.
Echter dit houdt niet in dat je maar luk raak moet gaan uitproberen tot het uiteindelijk werkt.
Als je niet weet waarom het werkt ben je verkeerd bezig . Probeer dus altijd te achter halen waarom werkte het.

1.       De compiler ontdekt je fout en geeft dit aan.
2.       De compiler ontdekt een fout maar geeft niet de daadwerkelijke fout aan.
3.       De compiler ontdekt geen fout maar er is wel een fout dit zijn de bekende bugs.
4.       De compiler ontdekt geen fout en er is ook niks fout.

TIP: in het begin is de fout meestal het vergeten van de ; of } {


Les2 C++ VARIABELEN

Variabelen

De bouwstenen van een programma zijn de variabelen, zie dit als het materiaal wat we gaan bewerken met ons gereedschap.
Dit werkt als in het ram wordt ruimte gereserveerd, waar  waardes in opgeslagen kunnen worden. Deze geheugen ruimtes zijn voorzien van een adres zodat de opgeslagen waardes weer terug te vinden zijn. Instructies zorgen er dan voor dat deze waardes opgeslagen opgehaald en bewerkt kunnen worden.
Dit ziet er alsvolgt ongeveer zo uit.

 


Een instructie zegt dan bij voorbeeld haal de waarde op die op adres 0001 bewaart wordt tel daarbij op de waarde die op adres 0002 bewaart wordt en bewaar de uitkomst op adres 0003.


Hoe we de waardes (data) erin kunnen opslaan laten we je zo zien eerst moeten we ruimte reserveren voor onze waardes dit noemen we declareren.  Behalve dat we ruimte willen reserveren zullen we ook nog moeten aangeven waarvoor het dient zodat de juiste hoeveelheid ruimte wordt vrijgemaakt.
Dit geven we aan met het type data
Gebruiken we alleen gehele getallen kunnen we  het type int gebruiken.Willen we echter decimale getallen gebruiken hebben we het type float nodig.
En zo zijn er nog enkele types.
Nadat we aangegeven hebben welk type data we willen opslaan  kunnnen we de data ruimte voorzien van een waarde. Dit noemen we  initialiseren. Hiervoor gebruiken we het = teken
wat staat voor assignment operator. Deze zorgt er voor dat de betreffende waarde in de variabele wordt opgeslagen.

#include <iostream>
using namespace std;


void main(void)
{//--------------------begin blok ------------------

//declareer
        int nVariabele1;
        int nVariabele2;

//initialiseer
        nVariabele1 = 10;
        nVariabele2 =  5;

//instructie
        cout << "nVariabele1 = " << nVariabele1 << endl;
        cout << "nVariabele2 = " << nVariabele2 << endl;

}//------------------einde blok ---------------------


Declareer  we mogen zelf kiezen hoe we de variabele noemen
Zolang deze maar uit letters, cijfers en of een underscore bestaat
Dus geen speciale tekens.  
De naam moet met een letter beginnen  of een under score.
En het mag niet een key woord zijn. Zie key woords aan het eind.
Verder wordt er onderscheidt gemaakt tussen hoofdletters en normale karakters
De naam van een variabele noemen we een identifier.

Hier hebben we gekozen voor nVariabele1  aan de n kunnen we dan zien dat het om een integer gaat
Probeer de naam altijd zo te kiezen dat je er aan kunt zien waar deze voor dient.

Int  De waarde die de variabele kan opslaan zijn van het type int integer dit zijn de positieve en negatieve gehele getallen tussen signed: -2147483648 to 2147483647

Initialiseer  nu we de variabele een geheugen plek hebben gegeven kunnen we er een waarde  in opslaan de assignment operator = zal nu de waarde 10 toekennen  aan de variabele.

Instructie  "nVariabele1 = " zal als text naar het console gaan  nVariabele1 toont de opgeslagen waarde.



Op welk adres een waarde wordt opgeslagen kunnen we zien door het & teken voor de variabele te plaatsen &variabele.
Met de sizeof operator kunnen we ook nog zien hoeveel bytes ruimte gereserveert is.


#include <iostream>
using namespace std;

int main()
{ // begin blok main --------------------------------------------------------------------------------

//declareer RAM geheugenruimte reserveren

int         nGetal01;          //variabelen in dit blok noemen we local variabelen
unsigned    nGetal02;
float       nGetal03;
double      nGetal04;
long double nGetal05;


//initialiseer is Waarde(data) toekennen aan de variabelen

nGetal01 = -3;
nGetal02 = 14;
nGetal03 = 0.5;
nGetal04 = 0.00006;
nGetal05 = 10e10;  // is 10 x 10^10

//instructies

cout << "     getal   "<< "adres" << "\t" << "waarde"  << "\t" << "aantal bytes" <<"\n" << endl;
cout << "toon getal01 "<< &nGetal01 << "\t" << nGetal01  << "\t\t" << sizeof(nGetal01) << endl;
cout << "toon getal02 "<< &nGetal02 << "\t" << nGetal02  << "\t\t" << sizeof(nGetal02) << endl;
cout << "toon getal03 "<< &nGetal03 << "\t" << nGetal03  << "\t\t" << sizeof(nGetal03) << endl;
cout << "toon getal04 "<< &nGetal04 << "\t" << nGetal04  << "\t\t" << sizeof(nGetal04) << endl;
cout << "toon getal05 "<< &nGetal05 << "\t" << nGetal05  << "\t\t" << sizeof(nGetal05) <<"\n" << endl;

return 0;

} // einde blok main -----------------------------------------------------------------------------------





Opdracht : Start en eindig het programma een paar keer en let op de toegewezen adressen
             Comment het initialiseren weg
Tip edit ->comment selection

//nGetal01 = -3;
//nGetal02 = 14;
//nGetal03 = 0.5;
//nGetal04 = 0.00006;
//nGetal05 = 10e10;  // is 10 x 1010

         
Je  krijgt een waarschuwing dat de variabelen niet gedefinieerd zijn negeer dit en kijk welke waarde de variabele krijgt.
Dit is niet nul. Vandaar dat het verstandig is altijd een waarde voorzien van een begin waarde. Ook wel bekend als een default waarde.

Met het volgende program kun je het bereik van de waarde van het type int zien.
Maak nu een programma waarmee je, die van bool, float, short, long, double en long double kunt zien.  


#include <iostream>
#include <climits>

using namespace std;

int main(void)
{

    cout << "Size of int types is " << sizeof(int) << " bytes"<< '\n';
    cout << "Signed int min: "<< INT_MIN << " max: "<< INT_MAX << '\n';
    cout << "Unsigned int min: 0 max: "<< UINT_MAX << "\n\n";
    return 0;
}


Nou denk je mischien waarom niet altijd het type double gebruiken dan weet ik zeker dat ik altijd goed zit. Dat klopt echter betekend dat extra geheugen ruimte en meer werk voor de processor waardoor je programma langzamer wordt.
Nu we weten hoe we een programmaatje moeten opstellen kunnen we verder gaan met het uitbreiden hiervan. Door met de variabelen te rekenen en hun waardes te veranderen.

Toets

  1.  wat doet een declaratie
  2.  waarom initialiseren
  3.  wat achterhaal je met een & teken voor een variabele
  4.  waar begint je programma
  5.  wat is het verschil tussen signed en unsigned
  6.  waaraan herken je een statement
  7.  waaruit bestaat een variabele
  8.  wat is het verschil tussen een int en een long double
  9.  kun je een int door een int delen zo ja waarom zo niet waarom niet
10.  kun je nu zonder te spieken zelf een mini program programmeren

KEY WORDS