Opgaves voor beginners 1

[Johantrax]

Omdat ik de laatste tijd hier steeds meer vragen zie staan met betrekking tot het inoefenen van C++, heb ik besloten een aantal reeksen met oefening te maken. Ik zal proberen om telkens te vermelden welke kennis nodig is om een bepaalde reeks volledig op te lossen. Het is niet de bedoeling om hier de antwoorden rechtstreeks in te posten, wel om de problemen/vragen die je tegenkomt hier te bediscussiëren.

Welke kennis je nodig hebt voor deze eerste reeks:

cin / cout
integers
loops (while / for / do-while)

nodige headers:

#include <iostream>

Hopelijk helpt dit enkelen onder jullie op weg naar een beter begrip van de taal C++

--Johan

 

[tom169]

nadat ik op enter geduwt heb sluit mijn programma af

dit is mijn code

#include <iostream.h>
int bef(int euro)
{
     return euro*40.3399;
}
int main ()
{
    int euro ;
    cout<<"voeg u bedrag in euro in\n";
    cin>> euro;
    cout<< "\n de waarde in belgische frank";
    cout<< bef;
    return 0 ;
}

hoe kan ik dat veranderen?

 

[Arjan B]

#include <iostream.h>
int bef(int euro)
{
     return euro*40.3399;
}
int main ()
{
    int euro ;
    cout<<"voeg u bedrag in euro in\n";
    cin>> euro;
    cout<< "\n de waarde in belgische frank";
    cout<< bef;
    cin.get()  // <----------------
    return 0 ;
}

 

[Johantrax]

Wat extra uitleg bij de oplossing die Arjan je geeft:

----------
-- cin --
----------
wanneer je inleest met cin (dit is een stream) wordt dit eerst gebufferd.wanneer jij dat dan naar een variabele opslaat lees je eigenlijk uit die buffer. cin is standaard ingesteld zodat witruimte geneegeerd wordt.

neem volgende code:

int i1, i2;
cin >> i1 >> i2;

met gebruikersinvoer:

12
123

geeft eerst een invoerbuffer met als inhoud:

'1', '2', '\n', '1', '2', 3', '\n'

volgende code wordt uitgevoerd:

cin >> i1;

met als resultaat dat i1==12 en de invoerbuffer is nu:

'\n', '1', '2', 3', '\n'

dan wordt volgende code uitgevoerd:

(cin) >> i2;

cin negeert de witruimte ('\n') en gaat verder met lezen, met als resultaat dat i2==123 en de invoerbuffer wordt

'\n'

------------------
-- cin.get() --
------------------
cin.get() haalt 1 karakter uit de invoerbuffer. wanneer er niets in de invoerbuffer zit, wacht dit statement dus tot er iets inkomt, en houdt zo je venster open.

Als je zeker wil zijn dat je venster openblijft kan je na elk cin-statement cin.get() gebruiken, maar je merkt wel dat dat in grote applicaties veel extra codering vraagt.
Daarom raad ik je aan volgende code te gebruiken, ze maakt gebruik van getline(), een functie die een hele lijn uit de invoerbuffer inleest, INCLUSIEF de witruimte die volgt. Het laat je buffer dus leeg achter.

Deze code komt helemaal onderaan je main

string rest; //om de inhoud van de buffer te kunnen wegschrijven
getline(cin, rest);  //haalt een lijn uit cin (de invoerbuffer) en kopieërt die naar de string rest
cout << "Druk op een toets om af te sluiten... ";
cin.get(); //wacht op het binnenkrijgen van een karakter
return 0; //sluit af

Hopelijk geeft dit je wat meer inzicht,
--Johan

 

[tom169]

werkt niet

Ik heb deze code en het werkt niet

#include <iostream.h>
int bef(int euro)
{
     return euro*40.3399;
}
int main ()
{
    int euro;
    cout<<"voeg u bedrag in euro in\n";
    cin>> euro;
    cout<< "\n de waarde in belgische frank is ...";
    cout<< bef;
    string rest; //om de inhoud van de buffer te kunnen wegschrijven
    getline(cin, rest); //haalt een lijn uit cin (de invoerbuffer) en kopieërt naar de string rest
    cout<< "Druk op een toets om af te sluiten... ";
    cin.get(); //wacht op het binnenkrijgen van een karakter
    return 0 ;
}

Kan je me vertellen waarom dit niet werkt . Dan weet ik waarop ik moet letten.

 

[Arjan B]

#include <iostream.h>

iostream.h is een oude C header, je kunt "#include <iostream>" ervan maken voor de C++ header.

je functie moet een int returnen maar je vermenigvuldigt je integer met een double (getallen acther de komma).

als je cout wilt gebruiken moet je een van de volgende dingen doen:

-bovenaan "using namespace std;" zetten
-bovenaan "using std::cout;" zetten (dacht dat het zo was)
-of al je couts vervangen door std::cout

cout << bef;

vergeet bij de functie niet de haakjes:

cout << bef(euro);

een werkend voorbeeld van jouw programma:

#include <iostream>

using namespace std;

double bef(double);

int main ()
{
    double euro;
    cout << "Voeg uw bedrag in euro in: ";
    cin >> euro;
    cout << "\nDe waarde in belgische frank is: ";
    euro = bef(euro);
    cout << euro;
    string rest; //om de inhoud van de buffer te kunnen wegschrijven
    getline(cin, rest); //haalt een lijn uit cin (de invoerbuffer) en kopieërt naar de string rest
    cout << "\nDruk op een toets om af te sluiten... ";
    cin.get(); //wacht op het binnenkrijgen van een karakter
    return 0 ;
}

double bef(double euro)
{
       return euro * 40.3399;
}

het is nogal warrig opgeschreven en ik weet niet hoe alles precies zit maar hier komt het wel een beetje op neer

ik hoop dat het helpt

 

[Johantrax]

#include <iostream.h>

moet worden

#include <iostream>

In 1999 is de C++ standaard gewijzigd. Zowat alle headers zijn toen opnieuw gedefiniëerd. Omdat men geen nieuwe namen wou uitvinden heeft men bij de nieuwe headers de '.h' laten vallen.

int bef(int euro)
{
     return euro*40.3399;
}

het type int dient voor gehele getallen. In C++ levert elke bewerking tussen 2 gehele getallen een nieuw geheel getal op (dmv afkappen):

cout << 2/3;  //zal  0 weergeven
cout << 3/2; //geeft 1

Wanneer echter 1 van de twee getallen van het type float/double is wordt het resultaat ook van het type float/double:

cout << 2/3.0; //0.666667
cout << 3./2; //1.5

Ik stel voor om deze getaltypes in je code naar double om te zetten, wegens een grotere precisie dan float: (nu kan je ook kommagetallen invoeren )

double bef(double euro)
{
    return euro*40.3399;
}

Nu maken we ook van de waarde die we inlezen in de main een double zodat deze overeenkomt met het functieargument.

int main()
{
    double euro;

    cout<<"voeg u bedrag in euro in\n";

hierop zegt de compiler dat cout niet gekend is.
Hoezo? we hebben de header iostream toch geïnclude?
Inderdaad, maar dit volstaat niet! In C++ bestaat er zoiets als 'Namespaces', dit zijn letterlijk vertaalt 'Naamdomeinen'. De meeste standaardcommando's die je zal gebruiken bevinden zich in het naamdomein standaard (logisch, niet?) Dit domein wordt aangesproken via het keyword 'std'.
Er zijn verschillende mogelijkheden om aan te geven dat we in die namespace willen werken. Voorlopig is het het eenvoudigst om bovenaan je programma te stellen dat alle commando's uit de std-namespace komen. Dit doe door volgende regel toe te voegen, (net onder #include <iostream>):

using namespace std;

Et voila, alle fouten dat cin/cout ongekend zijn, zijn verdwenen :thumb:

    cout<< bef;

De compilererror:

[Warning] the address of `double bef(double)', will always evaluate as `true'

In plaats van de functie uit te voeren en het resultaat af te drukken, doe je hier een cout die nagaat of het geheugenadres van de functie bestaat. Wat altijd zo zal zijn en dus de waarde true (of 1) zal geven.

//Functieaanroep
functienaam(functieargument);

Bij ons wordt dit dan:

cout << bef(euro);

we roepen de functie bef() op met als argument de variabele 'euro'. Die variabele in je main kan elke naam hebben die je maar wil, zolang zijn type maar hetzelfde is van het type van het argument van de functie.
Als ik de omrekeningsfunctie bvb wil toepassen op een totaalbedrag van een winkelkarretje kan de code er als volgt gaan uitzien:

double product1 = 2.95;
double product2 = 3.33;
double totaal = product1 + product2;
cout << "in BEF: " << bef(totaal);

Nu zouden al je problemen eruit moeten zijn
--Johan


[EDIT]Arjan was me voor [/EDIT]

 

[tom169]

aja nog een vraagje

Hoe moet ik iets laten afprinten vanuit mijn code (opgave2). Er is niets van vermeld in mijn online cursus.

 

[Johantrax]

Ik bedoelde gewoon op het scherm weergeven. Afdrukken/Printen is nogal ingewikkeld voor beginners (en voor sommige iets-verdergevorderden ook )

--Johan

 

[Jabber]

Hehe, vooral de opmaak. Spreek uit ervaring....

 

[tom169]

ok

ah ok dat wordt makkelijker.
Ah joihantrax waarom maak jij geen cursus .keb gezien dat je er veel van kent en als er iets niet begrepen wordt vragen we het hier.

 

[Johantrax]

Ik ben gisteren aan een tutorial/cursus begonnen. Maar dat vraagt wel wat tijd. Ik zit namelijk ook verweven in PHP-projecten ea.

Dus zo'n cursus komt er wel eens, als ik genoeg vrij tijd heb gehad

--Johan

 

[Jabber]

Ik ben gisteren aan een tutorial/cursus begonnen. Maar dat vraagt wel wat tijd. Ik zit namelijk ook verweven in PHP-projecten ea.

Dus zo'n cursus komt er wel eens, als ik genoeg vrij tijd heb gehad

--Johan

Als je een opmaak naar mij wilt sturen van de tutorial/cursus wil ik wel even kijken of ik tijd vrij kan maken voor eventuele invulling.

 

[Johantrax]

waarom iostream.h werkt op sommige compilers en niet op andere

Waarom <iostream.h>, <limits.h>, ..., op sommige compilers werken, maar op anderen niet.

Wel, op verschillende compilers werken ze niet, gewoonweg omdat ze dat niet hoeven te doen --- deze headers zijn geen onderdeel van de standaard C++ headers (STL).

Om te kunnen begrijpen waarom deze namen niet werken op de meeste compilers moeten we even teruggaan in de geschiedenis van C++:

Helemaal in het begin van C++, nog voor er ook maar een kladversie van de standaard was, eindigden alle aanbevolen headers op '.h'. Zo zag bijna iedereen zijn eerste programma er als volgt uit:

#include <iostream.h>

int main()
{
        cout << "Hello world!" << endl;
        return 0;
}

Wanneer namespaces werden geïntroduceerd in C++ kwam er een nieuwe regel voor de library --- alle namen die door de standaard headers gedeclareerd werden, zouden binnen één namespace gedeclareerd worden, de namespace "std".

Het probleem was dat met deze regel alle bestaande C++ code plots onbruikbaar werd. Zelfs het eenvoudige "Hello world” programma dat zonet werd aangehaald, kon niet meer gecompileerd worden onder deze regel, aangezien cout en endl nu binnen "std" gedefiniëerd zijn. We zouden de hoofdregel als volgt moeten herschrijven:

std::cout << "Hello world!" << std::endl;

(of een evenwaardige 'using'-constructie gebruiken) op de nieuwere compilers die werkten volgens de std-regel. Maar dan zou de code ook niet meer kunnen gecompileerd worden op de oudere compilers, die nog geen weet van de std-namespace hebben...

Dit zorgde voor een groot probleem: Het is niet mogelijk om code te schrijven die op zowel oudere als niewe compilers werkt!

Er kwam een gedeeltelijke oplossing toen de nieuwe standaardheaders werden uitgebracht. De nieuwe headers zijn diegenen waarin cout en alle andere namen gedeclareerd zijn binnen de standaard namespace.

Schrijvers van compilers werden aangemoedigd om de verouderde .h headernamen ook in hun library op te nemen, om achterwaardse compatibiliteit te voorzien. Zo kan oudere code nog steeds foutloos gecompileerd worden. Volg even mee hoe het in zijn werk gaat:

De standaard-header, die zijn namen binnen std definiëert:

//  <iostream>
namespace std {
    class ostream {
        // ...
    };

    ostream cout;
}

De oude .h-vorm van de header is eigenlijk gewoon het inladen van de standaardheader en dan using-definities voor elke naam van de standaardheader. Zo worden de namen bruikbaar zoals in "de goede oude tijd":

//  <iostream.h>
#include <iostream>

using std::ostream;
using std::cout;
using std::endl;
//...

Met dit schema zou het oorspronkelijke "Hello world" gecompileerd kunnen worden zonder aanpassingen, terwijl nieuwe C++ code in de nieuwe regels kan geschreven worden:

#include <iostream>

int main()
{
        std::cout << "Hello world!" << std::endl;
        return 0;
}

of, meer voorkomend:

#include <iostream>
using namespace std;

int main()
{
        cout << "Hello world!" << endl;
        return 0;
}

--Johan

Deze post is een vrije vertaling van deze faq-pagina