• De afgelopen dagen zijn er meerdere fora waarop bestaande accounts worden overgenomen door spammers. De gebruikersnamen en wachtwoorden zijn via een hack of een lek via andere sites buitgemaakt. Via have i been pwned? kan je controleren of jouw gegeven ook zijn buitgemaakt. Wijzig bij twijfel jouw wachtwoord of schakel de twee-staps-verificatie in.

C++ Tutorial

  • Onderwerp starter pderaaij
  • Startdatum
Status
Niet open voor verdere reacties.
P

pderaaij

Gast
[hand]

Deze tutorial is nog in bewerking, er kunnen nog fouten of onduidelijkheden instaan. Meld ze in dat geval a.u.b.

Een simpel voorbeeld

Code:
    #include <iostream.h>
    int main()
    {
       cout << "Hello World!\n";
       return 0;
    }

Output: Hello World!

Dit is de makkelijkste stuk C++ code. Ik ga nu regel voor regel uitleggen.

#include &lt;iostream.h&gt;

Dit betekent dat de compiler de file iostream.h opzoekt en hem in het programma bijvoegt. Het lijk nu net of je hem zelf heb ingetikt. De &lt; & &gt; betekenen dat hij het bestand in de gebruikelijke locaties zal zoeken, bijvoorbeeld de library mappen en dergelijke.

int main()

Dit zal je bij iedere programma gebruiken. Hier begint je programma pas echt. Hierin maak je aanroepen naar andere functies, maak je variabelen aan enzovoort.

int - Return type. Dit geeft aan dat er een getal word terug gestuurd.

main() - De naam van de functie. Altijd main(). De haakjes zijn de parameter lijst. Maar we gebruiken geen parameters, dus blijft het leeg.

cout<< "Hello World!\n";

Met cout kan je tekst weergeven op het scherm. Alles tussen haakjes zal hij weergeven. cin is voor de invoer.

\n geeft aan dat je een nieuwe regel wil beginnen. De tekencombinaties met een \ ervoor, worden nooit weergegeven.

Iedere statement, wat de regel met cout is, word afgesloten met een ;. Dit is belangrijk en mag je niet vergeten, anders compileert het niet.

return 0;

Zoals ik eerder zei betekent de int van int main() dat er een getal word teruggegeven. Dat doen we nu dus, aan het eind van de programma. We sturen gewoon 0 terug, waarmee we aangeven dat het met succes is voltooid.

Ik ga ons voorbeeld van de vorige keer wat uitbreiden. We maken er een soort gok spel van, omdat ik dan de basis facetten makkelijk kan uitleggen.

Code:
    #include &lt;iostream.h&gt;
    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;

    int GokGetal;
    int Getal;
    bool geraden = false;

    int main()
    {
       Getal = rand()%11;
       cout << "Gok het getal\n";
       
       while(geraden == false)
       {
          cout << "Vul nu een getal in\n";
          cin >> GokGetal;

       if(GokGetal == Getal)
       {
          cout << "Je hebt het goed geraden! Goed zo!\n";
          geraden = true;
       }
       
       if(GokGetal < Getal)
          {
             cout << "Het getal is groter dan jij gokte!\n";
          }
          
       if(GokGetal > Getal)
          {
             cout << "Het getal is kleiner dan jij gokte!\n";
          }

       
       }

       return 0;

    }
De uitleg:

Allereerst hebben we de gewone includes die ik vorige keer heb uitgelegd.

Dan beginnen we met het initialiseren van de variabelen. Dit zijn objecten die een stukje gegevens kan opslaan. Hier zie je 2 vormen int & bool

int - Kan getallen opslaan
bool - Kan true of false opslaan, meer niet.

De loop

Dan komt de loop. Dit is een while loop, deze loopt gewoon net zolang totdat de conditie waar is. In ons geval dus totdat het getal geraden is.

If loop
Dan gaan we kijken of het getal goed is. Dit doen we met 2 = (is-gelijk tekens). Want als je er maar 1 gebruikt ken je wat toe aan de variabele en bij 2 controleer je de variabele.

Als het getal goed is, dan word alles tussen de haakjes uitgevoerd, waaronder de bool op true zetten waardoor de while loop eindigt, en anders gaan we door.

Daaronder logischerwijs word gekeken of het getal groter of kleiner dan het getal wat gegokt is.

Dan gaan we weer terug naar het begin van de while loop. Is het getal goed gegokt, is geraden dus veranderd en eindigt de loop en word het programma afgesloten. Zo, niet dan gaan we door.

Ik ga in een lekker tempo door, want we gaan nu al classes behandelen. Dit is vrij snel. Maar ik denk dat jullie dit nu wel al aan kunnen.

Wat zijn classes

Als we een auto zien, zien we een geheel wat rijdt. De definitie auto is een compleet ding. Maar een auto bestaat in feite uit onderdelen. Hij bevat wielen, motor, stuur, ramen enzovoort. Dat zijn onderdelen van een auto. Zo kunnen we het met classes ook bekijken.

De class is compleet geheel. Die je kan gebruiken. Je hoeft niet te weten hoet het is gemaakt. Je moet alleen weten hoe je het moet gebruiken. Dit komt voort uit de hardware industrie. Als een technicus een nieuw moederbord maakt en hij heeft een weerstand nodig, pakt hij gewoon de weerstand. Hij hoeft niet eerst een weerstand te ontwerpen en maken.

Zo werkt het met classes ook. Een keer creeren vervolgens alleen maar gebruiken. Je hoeft alleen maar te weten hoe je het gebruik't niet hoe het in elkaar steekt.

Voorbeeld

Goed nu even een klein voorbeeld van classes. Hiervoor gebruiken we een Auto.

Code:
    #include <iostream.h>
    #include <stdio.h>

    class CAuto
    {
    public:
       CAuto(int motpk);            // contructor
       ~CAuto();                  // destructor
       ReturnKleur();               // geef de kleur      ACCESSOR
       ReturnMoterStat();            // geef de moto status  ACCESSOR
       ReturnMotorPK();            // geefPK's terug
       SetKleur(int kleurauto);      // stel de kleur in
       SetMotoStat(int motstat);      // stel de motor aan/uit 

    private:
       int kleur;         // kleur waarde
       int motorstat;      // motor status
       int motorpk;      // pk's motor
    };

    CAuto::CAuto(int motpk)
    {
       motorpk = motpk;
    }

    CAuto::~CAuto()
    {
    }

    CAuto::SetKleur(int kleurauto)
    {
       kleur = kleurauto;
    }

    CAuto::SetMotoStat(int motstat)
    {
       motorstat = motstat;
    }

    CAuto::ReturnKleur()
    {
       return kleur;
    }

    CAuto::ReturnMoterStat()
    {
       return motorstat;
    }

    CAuto::ReturnMotorPK()
    {
       return motorpk;
    }

    void menu()
    {
       cout << "***************MENU***************" << endl;
       cout << "*** 1. Kleur instellen         ***" << endl;
       cout << "*** 2. Motor in/uitschakelen   ***" << endl;
       cout << "*** 3. Info opvragen         ***" << endl;
       cout << "*** 4. Einde programma         ***" << endl;
       cout << "**********************************" << endl;

    }

    int main()
    {
       int keuze;
       CAuto smart(80);

       menu();

       while(keuze)
       {
          
          cin >> keuze;
       
          switch(keuze)
          {
          case 1:
          {
          int kleur;

          cout << "Stel hier de kleur van de auto in (0-999)" << endl;
          cin    >> kleur;
          smart.SetKleur(kleur);
          menu();
          break;
          }
          
          case 2:
          {
          int motor;
          cout << "Schakel de motor aan of uit (0 - 1)" << endl;
          cin >> motor;
          smart.SetMotoStat(motor);
          menu();
          break;
       }

       case 3:
       {
          cout << "De kleur van de auto is " << smart.ReturnKleur() << endl;
          cout << "De motor bevat " << smart.ReturnMotorPK() << "PK." << endl;
          cout << "De motor status is " << smart.ReturnMoterStat() <<". 0 is uit, 1 is aan" << endl;
          menu();
          break;
       }

       case 4:
       {
          return 0;
          break;
       }
       
       default: return 0; break;
       }
       }
    }
De uitleg

We beginnen weer met de standaard includes. Dan komt er iets nieuws. We gaan de class maken.

We beginnen met class CAuto. class geeft aan dat we een class gaan maken en CAuto is de naam. Vervolgens komt het keyword public". Dat betekent dat de methodes en objecten die er onder staan vanuit het hele programma beschikbaar zijn. Als iets private is, is het alleen beschikbaar vanuit de class.

Vervolgens komen er gewoon normale functie en variabele declaratie te staan.

Bij een aantal functies staat er ACCESSOR in het commentaar. Dit zijn namelijk zo genoemde accessor functies. Deze functies maak je om de variabele private te kunnen houden en zo geef je de inhoud van de variabele toch aan het programma en heb je niet het risico dat het programma ongewild de variabele van waarde doet veranderen.

Dan krijgen we de functie definities. Dit is niet anders dan normaal.

Dan komen we de functie menu tegen. Hier word gewoon een menu geprint, dit doe ik in een functie, omdat je het menu vaker dan 1 keer wil laten zien. Dit werkt het makelijkst.

In de main functie gaan we eindelijk wat doen met de class. Dat doen we zo.

CAuto smart(80);

Nu kan je alles met je class doen wat je wil. Wat we dan ook gaan doen met behulp van het menu. Daar onder staat een switch loop. Die kijkt of keuze 1,2,3 of 4 bevat. En voert dat uit wat hij daarin moet doen. En dan zijn we klaar en heb je een werkend programma.


[/hand]
 
Laatst bewerkt:
Ik heb dit ff hierheen verplaatst, zodat je er nog aan kunt werken (staat er nog boven). Als je het af vind, laat het me maar ff weten dan kan het in het goede gedeelte.
 
Moet er weer eens aan werken. Maar ja... tijdgebrek... Zal proberen er van het weekend aan te werken. Is ook geen probleem als jij het één en ander past ;)
 
Status
Niet open voor verdere reacties.
Steun Ons

Nieuwste berichten

Terug
Bovenaan