[C++] Programmeren Beginnersvraag(en)

[kitao]

Hallo,

Als hobby pas (weer) begonnen met C++ en maak daarvoor gebruik van visual studio 2017 en deze website waarvan onderstaande link meteen opgave 3 toont waar mijn vraag over gaat :

http://www.ronkes.nl/oldprogrammeren/oefeningen8.html

Ik probeer het zo kort mogelijk te houden met hierna mijn broncode.

Ik begrijp namelijk niet goed waarom de parameter int ivUitkomst in de functie Machtsverheffen niet verandert, ondanks de for-lus eronder die deze parameter wijzigt.
Als de functie zn bewerking heeft gedaan en terugspringt naar main() krijg ik namelijk niet de gewijzigde waarde van ivUitkomst maar de beginwaarde ervan, dus van voordat de functie werd aangeroepen.

Lastig dit onder woorden te brengen maar heb mn best gedaan.
Hopelijk maakt de broncode duidelijker :

code:

/*
3. Schrijf een functie die een grondtal en een exponent(beide gehele getallen) als parameters meekrijgt 
en hiermee een machtsverheffing uitvoert.
Gebruik voor de berekening van het antwoord een for - lus.

Schrijf de onderstaande unit test voor de functie :
- een specifiek geval(bijvoorbeeld 3^5 = 243)
*/

#include<iostream>
using namespace std;

int ivGrondtal;
int ivExponent;
int ivUitkomst;

// functie machtsverheffen
int Machtsverheffen( int ivGrondtal,  int ivUitkomst)
{
    for (int i = 1; i < ivExponent; i++)
    {
        ivUitkomst = ivUitkomst * ivGrondtal;
        cout << ivUitkomst << endl;
    }

    cout << endl << endl << "ivUitkomst vlak voor return = " << ivUitkomst << endl;
    
    return ivUitkomst;
}

int main()
{
    cout << "voer een willekeurig grondtal in, maar gebruik voor deze test een 3   \n";
    cin >> ivGrondtal;

    cout << "voer een willekeurige exponent in, maar gebruik voor deze test een 5     \n";
    cin >> ivExponent;

    // nodig om kwadraat te berekenen :
    ivUitkomst = ivGrondtal;
    
    // zet alvast de eerste twee getallen van de machtsverheffings-reeks neer van x^0 en x^1
    cout << endl << "1" << endl;
    cout << ivGrondtal << endl;

    //roep functie aan
    Machtsverheffen(ivGrondtal, ivUitkomst);

    cout << "dit krijg ik dan terug als return van de functie :" << endl << endl;
    cout << endl << "ivUitkomst is niet gelijk meer aan de return in de functie Uitkomst ??????"  << endl << endl;
    cout << "ivUitkomst is namelijk teruggesprongen naar zijn beginwaarde vlak voor het aanroepen van de functie" << endl << endl;
    cout << "ivUitkomst is weer " << ivUitkomst << " geworden terwijl ik 243 had verwacht en daarom mislukt de Test." << endl << endl;

    //unit test
        if (ivGrondtal == 3 && ivExponent == 5 && ivUitkomst == 243)
        {
            cout << "Test gelukt !!" << endl;
            cout << endl;
            system("pause");
        }
        else
        {
            cout << "Test mislukt !!" << endl;
            cout << endl;
            system("pause");
        }
}

ik heb op iedere regel breakpoints gezet en integer variabele ivUitkomst veranderde prima mee totdat die terugkwam in main waarna die weer zn beginwaarde aannam. Mijn vraag is nu , waar gebeurt dat dan precies en waarom behoudt ivUitkomst niet zn laatste waarde na de berekening in de for-lus ?


Overigens heb ik het inmiddels zelf goed gekregen, maar dat verklaart (mij) nog niet waarom bovenstaande niet werkt.

Vrijwel zelfde code maar dan iets anders :

code:

/*
3. Schrijf een functie die een grondtal en een exponent(beide gehele getallen) als parameters meekrijgt
en hiermee een machtsverheffing uitvoert.
Gebruik voor de berekening van het antwoord een for - lus.

Schrijf de onderstaande unit test voor de functie :
- een specifiek geval(bijvoorbeeld 3^5 = 243)
*/

#include<iostream>
using namespace std;

int ivGrondtal;
int ivExponent;
int ivUitkomst;
int ivResultaat;

// functie machtsverheffen
int Machtsverheffen(int ivGrondtal, int ivUitkomst)
{
    for (int i = 1; i < ivExponent; i++)
    {
        ivUitkomst = ivUitkomst * ivGrondtal;
        cout << ivUitkomst << endl;
    }

    ivResultaat = ivUitkomst;
    return ivResultaat;
}

int main()
{
    cout << "voer een willekeurig grondtal in, maar gebruik voor deze test een 3   \n";
    cin >> ivGrondtal;

    cout << "voer een willekeurige exponent in, maar gebruik voor deze test een 5     \n";
    cin >> ivExponent;

    // nodig om kwadraat te berekenen :
    ivUitkomst = ivGrondtal;

    // zet alvast de eerste twee getallen van de machtsverheffings-reeks neer van x^0 en x^1
    cout << endl << "1" << endl;
    cout << ivGrondtal << endl;

    //roep functie aan
    Machtsverheffen(ivGrondtal, ivUitkomst);

    cout << endl << "dit krijg ik terug als return van de functie :" << ivResultaat << endl << endl;

    //unit test
    if (ivGrondtal == 3 && ivExponent == 5 && ivResultaat == 243)
    {
        cout << "Test gelukt !!" << endl;
        cout << endl;
        system("pause");
    }
    else
    {
        cout << "Test mislukt !!" << endl;
        cout << endl;
        system("pause");
    }
}

Alvast bedankt voor een antwoord

Aangaande dit topic, van mij mogen anderen die ook C++ beginnersvragen hebben dit topic gebruiken om hun eigen vraag/opmerking te stellen.

[Marber]

Je geeft de uitkomst mee aan de functie, dus zal je zien dat als een cout doet van je functieaanroep hij wel het goede resultaat geeft.

Andere oplossing is werken met pointers, maar daar zou ik nog even mee wachten

[kitao]

Marber schreef op maandag 7 januari 2019 @ 18:07:
Je geeft de uitkomst mee aan de functie, dus zal je zien dat als een cout doet van je functieaanroep hij wel het goede resultaat geeft.

Andere oplossing is werken met pointers, maar daar zou ik nog even mee wachten

Bedankt voor je antwoord

maar ik begrijp je niet helemaal.
ik dacht namelijk niet dat ik de uitkomst meegeef aan de functie Machtsverheffen.
Ik gaf wel een beginwaarde mee voor ivUitkomst en dat was in dit geval 3 (regel 40) na invoer op regel 33.
de functie gaat vervolgens verder rekenen met deze beginwaarde van ivUitkomst en print deze netjes uit in de for-lus van regel 20 t/m 24.
als de for lus klaar is blijkt ivUitkomst nog steeds 243 te zijn, zie cout regel 26.
daarna komt echter de return op regel 28 naar regel 48 in main en dan blijkt ivUitkomst ineens weer 3 te zijn ?

Zelf dacht ik aan het volgende :
dit is de functie op regel 18

int Machtsverheffen(int ivGrondtal, int ivUitkomst)

volgens de website uit de OP worden de int ivGrondtal, int ivUitkomst de parameters genoemd van de functie.
omdat deze in de functie staan opgenomen kun je er blijkbaar wel mee rekenen of bewerken, maar niet in gewijzigde vorm, dwz de stand volgens de laatste bewerking, als return terugsturen.

daarom heb ik in de tweede code de extra int ivResultaat opgenomen waarna de unit test wel goed werkte (in visual studio zie je ook kleurverschil tussen de parameters en een 'gewone variabele') , maar ik begrijp niet goed waarom ik niet de bewerkte parameter als return krijg in de eerste code.

overigens staat er in regel 50 een klein foutje maar is niet van invloed op het geheel

50 cout << endl << "ivUitkomst is niet gelijk meer aan de return in de functie Uitkomst ??????" << endl << endl;

dit moet zijn :

50 cout << endl << "ivUitkomst is niet gelijk meer aan de return in de functie Machtsverheffen ??????" << endl << endl;

Op het laatste moment heb ik de naam van de functie gewijzigd maar ben die regel vergeten mee te wijzigen.

Beide codes zijn getest op visual en heb op meerdere plaatsen cout geplaatst , ook via breakpoints de waardes blijven volgen, maar punt is, code 1 geeft een mislukte test bij grondtal 3 en exponent 5 en code 2 met diezelfde getallen slaagt wel.
Mijn conclusie is dus dat een bewerkte parameter, zoals in dit geval ivUitkomst, niet als return kan worden meegegeven. (?)

[Verwijderd]

ivResultaat = Machtsverheffen(ivGrondtal, ivExponent), hierdoor wordt de return value van de functie machtsverheffen toegewezen aan de variable ivResultaat.

In het tweede deel wijs je ivResultaat in de functie machtverheffen al toe, daardoor werkt deze wel

Daarnaast: de variabelen in de functie machtsverheffen (lokale variabelen) anders benoemen dan de globale gedeclareerde variabelen, deze kunnen met elkaar in conflict komen. Gaat nu wel goed, omdat het dezelfde waardes heeft volgens mij..

[kitao]

Bedankt, ben al stuk verder geholpen.
Pointers, lokale en globale conflict variabelen was ik in die lessen serie nog niet tegengekomen.
Zal morgen proberen een nog kortere versie van een code te schrijven waaruit waarschijnlijk zal blijken dat de return-waarde van een parameter in een functie ook na bewerking zn begin-waarde vasthoudt.
Maar waarom dat zo is, (als dat zo is en dat lijkt er wel op na de run van code 1), is me nog steeds niet helemaal duidelijk.

[Daos]

kitao schreef op maandag 7 januari 2019 @ 20:33:
Maar waarom dat zo is, (als dat zo is en dat lijkt er wel op na de run van code 1), is me nog steeds niet helemaal duidelijk.

Dat hoort gewoon zo (in C++ en vele andere talen). De waardes worden gekopieerd bij het aanroepen van een functie. Dit noemt men "call by value". Als je de originele variabelen wilt wijzigen in een functie dan kan je pointers (* C-manier) of references (& C++-manier) gebruiken.

In jouw geval kan je, zoals anderen al hebben aangegeven, ook de return value gebruiken. Dat doe je door een variabele en een = voor de functie-aanroep te zetten. De uitkomst die je meegeeft aan return wordt dan in die variabele gestopt. Bv:

C++:

int functie (int a, int b) {
    return a + b;
}

uitkomst = functie(a, b);

[Verwijderd]

Is er een reden dat letterlijk niemand de oplossing geeft voor het probleem dat zijn uitvoer variabele niet verandert? Het is voor dit probleem uiteraard niet de ideale oplossing, maar wel het antwoord op zijn vraag. @Daos is de enige die het in passing noemt: pass by reference.

Hij programmeert in c++ een minuscule wijziging in zijn code lost het probleem op

C++:

void Machtsverheffen(int ivGrondtal, int &ivUitkomst)
{
    for (int i = 1; i < ivExponent; i++)
    {
        ivUitkomst = ivUitkomst * ivGrondtal;
    }
}

Wel redelijk dubbel op om de waarde dan ook nog eens als return value mee te geven dus dat heb ik er ook maar uit gehaald.:/

Aanroep van de functie blijft exact gelijk.

Ik zat wel even te kijken wat deze bij exponent 0 doet.

De loop wordt dan niet doorlopen en uitkomst houdt de innitiele waarde zijnde het grondgetal. Deze functiie rekent dus fout als iemand voor exponent 0 invoert!

0 tot de macht 0 is wiskundig niet gedefinieerd, vandaar dat de opgave zegt dat je die mag negeren. In de praktijk heb je twee gangbare oplossingen: 1 of een exception.

De opdracht geeft ook aan dat het exponent een functieparameter moet zijn, dat heeft TS niet gedaan. TS gebruikt globale variabelen in een functie, iets om meteen af te leren.

C++:

int Machtsverheffen(int ivGrondtal, int ivExponent)
{
    int resultaat = 1;
    for (int i = 0; i < ivExponent; i++)
    {
        resultaat = resultaat * ivGrondtal;
    }
   return resultaat;
}

Is denk ik waar de website naar streeft.

[ Voor 39% gewijzigd door Verwijderd op 07-01-2019 21:29 ]

[ThomasG]

Verwijderd schreef op maandag 7 januari 2019 @ 21:02:
Is er een reden dat letterlijk niemand de oplossing geeft voor het probleem dat zijn uitvoer variabele niet veranderd? Het is voor dit probleem uiteraard niet de ideale oplossing, maar wel het antwoord op zijn vraag. @Daos is de enige die het in passing noemt: pass by reference.

Hij programmeert in c++ een minuscule wijziging in zijn code lost het probleem op

C++:

void Machtsverheffen(int ivGrondtal, int &ivUitkomst)
{
    for (int i = 1; i < ivExponent; i++)
    {
        ivUitkomst = ivUitkomst * ivGrondtal;
    }
}

Wel redelijk dubbel op om de waarde dan ook nog eens als return value mee te geven dus dat heb ik er ook maar uit gehaald.:/

Aanroep van de functie blijft exact gelijk.

Dit is een oplossing maar of dat in dit geval een goede oplossing is, is natuurlijk een ander verhaal. Aangezien hij globale variabelen gebruikt was in dit geval het hernoemen van de functie argumenten, of ze geheel weglaten, een "betere" optie dan ad-hoc gebruik maken van references.

In dit geval zijn dat beide echter slechte oplossingen. Als we het probleem even versimpelen komt het neer op het volgende: we hebben gehele getallen als invoer, en krijgen een geheel getal als uitvoer. In dit geval kunnen we dus de meest basis oplossing gebruiken: de functie aanpassen naar twee invoer argumenten, en een return waarde. We veranderen het tweede argument van uitvoer naar exponent, omdat uitvoer hier onnodig is als we ook de eerste stap ivUitvoer = ivGrondgetal verplaatsen naar binnen de functie.

C++:

int Machtsverheffen(int grondgetal, int exponent) {
    int uitkomst = grondgetal;
    for (int i = 1; i < exponent; ++) {
        uitkomst = uitkomst * grondgetal;
    }
    return uitkomst;
}

//
ivUitkomst = Machtsverheffen(ivGrondgetal, ivExponent);

[Verwijderd]

ThomasG schreef op maandag 7 januari 2019 @ 21:14:
[...]
Dit is een oplossing maar of dat in dit geval een goede oplossing is, is natuurlijk een ander verhaal. Aangezien hij globale variabelen gebruikt was in dit geval het hernoemen van de functie argumenten, of ze geheel weglaten, een "betere" optie dan ad-hoc gebruik maken van references.

Helemaal mee eens. Maar TS vroeg niet zo zeer naar de oplossing, maar waarom ivUitkomst niet wijzigde.

Overigens heb je een foutje in jouw uitwerking: uitkomst = uitkomst * uitkomst gaat je niet de juiste waarde opleveren. 'e'en van de twee variabelen aan de rechterzijde moet grondgetal zijn.

En het gaat mis bij exponent = 0! Dat laatste is simpel op te lossen door de innitiele waarde van uitkomst op 1 te zetten en de loop bij i=0 aan te vangen.

p.s. misschien kom ik wat kort door de bocht over, is niet mijn bedoeling. Zat een OpenCL kernel in c te schrijven toen ik deze welkome afleiding zag. Daar wordt je vanzelf een mierenneuker van anders werken die niet

[ Voor 18% gewijzigd door Verwijderd op 07-01-2019 21:24 ]

[kitao]

Iedereen hartelijk dank allemaal, heb jullie reacties eens goed doorgelezen en er al veel van opgestoken

Mijn vraag was inderdaad waarom kan je een parameter wel bewerken in een functie maar deze niet als bewerkt zijnde een return geven , dwz je kan hem wel returnen maar dan springt hij terug naar zn beginwaarde.
Hieronder heb ik de code korter gemaakt met een plaatje erbij.

code:

/*De return van een functie parameter*/

#include <iostream>
using namespace std;

int Parameter1 = 17;
int Parameter2 = 2;

int Functie(int Parameter1, int Parameter2)
{
    Parameter1 = Parameter1 * Parameter2;
    cout << "Regel 12 : Parameter1 binnen de functie en na bewerking binnen de functie is gelijk aan : " << Parameter1 << endl << endl;

    return Parameter1;
}

int main()
{
    cout << "Regel 19 : Print Parameter1 voordat de functie wordt aangeroepen, dan heeft deze de volgende waarde : " << Parameter1 << endl << endl;

    // roep de functie aan
    Functie(Parameter1, Parameter2);

    // de functie returnt met de volgende waarde :
    cout << "Regel 25 : Print Parameter1 nadat de functie werd aangeroepen, dan heeft deze de volgende Return-waarde : " << Parameter1 << endl << endl;
    
    system("pause");
}

Mijn vraag leek misschien van de orde van waarom is water nat maar laat ik het zo zeggen, ik had het niet verwacht dat de return niet de bewerkte versie van Parameter1 meegeeft.
Ik had ongeveer datzelfde in les 6.

http://www.ronkes.nl/oldprogrammeren/les6.html

code:

int Oppervlakte(int hoogte, int breedte)
{
    // bereken oppervlakte
    int myOppervlakte = hoogte * breedte;

    // geef oppervlakte terug
    return myOppervlakte;
}

waarom niet gewoon :

code:

int Oppervlakte(int hoogte, int breedte)
{
    // bereken oppervlakte
    Oppervlakte = hoogte * breedte;

    // geef oppervlakte terug
    return Oppervlakte;
}

Dat werkt dus niet.
Maar ja, de dingen zijn zoals ze zijn en is verder geen ramp maar was wel even zoeken om het te 'omzeilen'.
Knap daarom dat Daos dit vrijwel direkt bij naam weet te noemen.
Ik was de website al eerder tegengekomen https://www.tutorialspoint.com/cplusplus/index.htm , en zat nog te verzinnen welke ik als studie vervolg zou kiezen.
Deze krijgt nu extra punten.

Ps/
De website met lessen geeft van sommige ook de antwoorden.
Les 8 , waar dit topic mee ontstond, staat daar ook bij

http://www.ronkes.nl/oldprogrammeren/antwoorden.html

Mapje Machtsverheffen geeft dan de uitwerking van de UnitTest
Om de hoofdfunctie te starten heb ik er wel een stukje bij moeten schrijven :

code:

int main()
{
    // voer unit tests uit
    UnitTest();

    int grondtal, exponent;

    // wacht op enter
    cout << endl << endl;
    cout << "Wat is het grondtal ? ";
    cin >>  grondtal ;
    cout << endl << "Wat is de exponent ? ";
    cin >>  exponent;
    cout << endl << "De uitkomst van deze machtsverheffing = " << Macht( grondtal,  exponent) << endl << endl;
    system("pause");

    return 0;
}

[ Voor 14% gewijzigd door kitao op 08-01-2019 09:20 ]

[Rotterdammertje]

kitao schreef op dinsdag 8 januari 2019 @ 06:36:

code:

int Oppervlakte(int hoogte, int breedte)
{
    // bereken oppervlakte
    int myOppervlakte = hoogte * breedte;

    // geef oppervlakte terug
    return myOppervlakte;
}

waarom niet gewoon :

code:

int Oppervlakte(int hoogte, int breedte)
{
    // bereken oppervlakte
    Oppervlakte = hoogte * breedte;

    // geef oppervlakte terug
    return Oppervlakte;
}

Waar je denk ik mee worstelt is het concept van input en output van een functie. Een functie heeft input parameters, en geeft op basis van die input parameters een waarde terug. In de functie declaratie:

code:

int Oppervlakte(int hoogte, int breedte)

is Oppervlakte de naam van je functie, hoogte en breedte zijn de input parameters, en de eerste int is het type van de output waarde. De code in de functie bepaalt hoe de output waarde wordt berekend; het "return" statement geeft aan wat de output waarde van de functie uiteindelijk is.

In de code waar je de functie aanroept, geef je de input waarden mee. Deze input waarden worden gekopieerd en aan de functie meegegeven (dit is niet helemaal waar, maar voorlopig waar genoeg). De functie doet dan zijn dingetje, en geeft de berekende waarde terug. Deze berekende waarde wordt niet als een parameter terug gegeven! De parameters zijn puur input voor de functie (ook weer niet helemaal waar, maar voorlopig waar genoeg). C++ doet net alsof de functie zelf de berekende waarde krijgt. In je aanroepende code moet je dan nog wel wat met die waarde doen!

code:

int Oppervlakte(int hoogte, int breedte)
{
    // bereken oppervlakte
    int myOppervlakte = hoogte * breedte;

    // geef oppervlakte terug
    return myOppervlakte;
}

void DoeIets()
{
    int berekendeOppervlakte = Oppervlakte(25, 30);
}

In "DoeIets" wordt de functie Oppervlakte aangeroepen met parameters 25 en 30. Deze functie berekent de waarde 750. Deze waarde wordt daarna terug gegeven als het resultaat van de functie. In DoeIets wordt die waarde daarna opgeslagen in de variabele "berekendeOppervlakte".

waarom niet gewoon :

code:

int Oppervlakte(int hoogte, int breedte)
{
    // bereken oppervlakte
    Oppervlakte = hoogte * breedte;

    // geef oppervlakte terug
    return Oppervlakte;
}

Dit werkt niet, omdat "Oppervlakte" een functie is, en geen variabele. In C++ is het statement

code:

    Oppervlakte = hoogte * breedte;

ongeldig. Je kan geen waarde toekennen aan een functie. Een functie kan alleen een waarde teruggeven.

De reden dat je eerste programma niet werkte, is iets subtieler:

code:

int ivGrondtal;
int ivExponent;
int ivUitkomst;

// functie machtsverheffen
int Machtsverheffen( int ivGrondtal,  int ivUitkomst)
{
    for (int i = 1; i < ivExponent; i++)
    {
        ivUitkomst = ivUitkomst * ivGrondtal;
     }
    
    return ivUitkomst;
}

Hier definieer je eerst drie globale variabelen (ivGrondtal, ivExponent, en ivUitkomst). Deze variabelen zijn beschikbaar in je hele programma. Maar daarna definieer je in de functie Machtsverheffen ook twee parameters: ivGrondtal en ivUitkomst. Hoewel deze parameters dezelfde naam hebben als de globale variabelen, zijn het volkomen aparte dingen, met hun eigen geheugenlocatie. Als je in de functie Machtsverheffen de waarde van ivUitkomst wijzigt, dan wijzig je de waarde van de parameter ivUitkomst, niet de waarde van de globale variabele ivUitkomst. Dit wordt "shadowing" genoemd. De parameter ivUitkomst heeft als scope de functie Machtsverheffen, en is daardoor meer specifiek dan de globale variabele.

Vervolgens geef je de waarde van ivUitkomst wel terug als functie resultaat, maar in je aanroepende code negeer je het resultaat van de functie:

code:

    //roep functie aan
    Machtsverheffen(ivGrondtal, ivUitkomst);

Had je hiervan gemaakt:

code:

    //roep functie aan
    int ivNieuweUitkomst = Machtsverheffen(ivGrondtal, ivUitkomst);

dan had ivNieuweUitkomst de berekende waarde toegekend gekregen.

[kitao]

Rotterdammertje schreef op dinsdag 8 januari 2019 @ 09:19:
[...]


Waar je denk ik mee worstelt is het concept van input en output van een functie. Een functie heeft input parameters, en geeft op basis van die input parameters een waarde terug. In de functie declaratie:

[...]

Had je hiervan gemaakt:

code:

    //roep functie aan
    int ivNieuweUitkomst = Machtsverheffen(ivGrondtal, ivUitkomst);

dan had ivNieuweUitkomst de berekende waarde toegekend gekregen.

Heel duidelijk, tof

Bij dat gedeelte van Oppervlakte besefte ik ergens wel dat een computer, of mss beter gezegd de cpu, dat ieder adres slechts één waarde kan hebben. Dus als adres Functie Oppervlakte gebruikt wordt om die functie te definiëren dat die dan niet meer tegelijkertijd als opslagadres voor het eindresultaat kan dienen.
Maar wat ik vreemd vond is dat de parameter van de machtsverheffing functie wel te bewerken valt binnen die functie maar geen bewerkte waarde meekreeg in zn return.

Door jouw heldere uitleg en die van anderen snap ik nu een stuk beter hoe dat komt.
Bedankt daarvoor en in principe is mijn vraag hiermee opgelost

Ik heb nog wel een ander vraagje maar moet bekennen dat ik het nog niet zelf heb opgezocht.
Kan je in Visual Studio in één keer op alle coderegels Breakpoints zetten of gaat dit enkel door op één regel tegelijk te klikken ?

[Radiant]

kitao schreef op dinsdag 8 januari 2019 @ 09:49:
[...]

Ik heb nog wel een ander vraagje maar moet bekennen dat ik het nog niet zelf heb opgezocht.
Kan je in Visual Studio in één keer op alle coderegels Breakpoints zetten of gaat dit enkel door op één regel tegelijk te klikken ?

Je kan dan beter één breakpoint zetten op het punt waar je wil beginnen of op pauze klikken en daarna step into/step over gebruiken.

[Rmg]

Sowieso moet je functie aanroep niet

int Machtsverheffen( int ivGrondtal, int ivExponent) zijn

code:

// functie machtsverheffen
int Machtsverheffen( int ivGrondtal,  int ivUitkomst)
{
    for (int i = 1; i < ivExponent; i++)
    {
        ivUitkomst = ivUitkomst * ivGrondtal;
        cout << ivUitkomst << endl;
    }

    cout << endl << endl << "ivUitkomst vlak voor return = " << ivUitkomst << endl;
    
    return ivUitkomst;
}

[BoAC]

Daarnaast wil je nooit aan je input variabelen sleuten:

code:

// functie machtsverheffen
int Machtsverheffen( const int &ivGrondtal,  const int &ivExponent)
{
    int ivUitkomst = ivGrondtal;
    for (int i = 1; i < ivExponent; i++)
    {
        ivUitkomst = ivUitkomst * ivGrondtal;
        cout << ivUitkomst << endl;
    }

    cout << endl << endl << "ivUitkomst vlak voor return = " << ivUitkomst << endl;
    
    return ivUitkomst;
}

De compiler levert in dit geval performance winst op, omdat er geen 'kopie' behoeft gedaan te worden
https://www.learncpp.com/...g-arguments-by-reference/
In dit voorbeeld zijn globale variabelen niet nodig

[Verwijderd]

@BoAC Uiteraard is passing by const reference de beste optie. Alleen dan denk ik dat het wel goed is om dat even uit te leggen, de voorbeelden die TS volgt gaan daar geheel niet op in.

Op zich wel verassend dat referencing, pointers, noch templates en unique_ptr/shared_ptr behandeld wordt. Om echt iets nuttigs te maken zal hij na het doorwerken van deze voorbeelden dus op zoek moeten naar een wat uitgebreidere tutorial.

[ThomasG]

BoAC schreef op dinsdag 8 januari 2019 @ 10:49:
*knip*
De compiler levert in dit geval performance winst op, omdat er geen 'kopie' behoeft gedaan te worden
https://www.learncpp.com/...g-arguments-by-reference/
In dit voorbeeld zijn globale variabelen niet nodig

Nee. Als je pass-by-reference gebruikt heb je te maken met het doorgeven van een pointer (wat een reference is), en het de-referencen van de pointer binnen de functie. Dit doet de compiler voor je. Aangezien een integer op een 64 platform kleiner is dan een cpu-register (en dus kleiner dan een pointer), heb je er weinig tot geen voordeel van. Aangezien moderne compilers zorgen dat primites via pass-by-value worden geoptimaliseerd via cpu-registers, is pass-by-reference op integers eigenlijk gewoon langzamer.

Het gebruik van int & is te verdedigen, omdat je de waarde kunt aanpassen. int const & heeft geen enkel praktisch nut, en is zeker niet sneller.

[Verwijderd]

ThomasG schreef op dinsdag 8 januari 2019 @ 11:03:
[...]
Nee. Als je pass-by-reference gebruikt heb je te maken met het doorgeven van een pointer (wat een reference is), en het de-referencen van de pointer binnen de functie. Dit doet de compiler voor je. Aangezien een integer op een 64 platform kleiner is dan een cpu-register (en dus kleiner dan een pointer), heb je er weinig tot geen voordeel van. Aangezien moderne compilers zorgen dat primites via pass-by-value worden geoptimaliseerd via cpu-registers, is pass-by-reference op integers eigenlijk gewoon langzamer.

Het gebruik van int & is te verdedigen, omdat je de waarde kunt aanpassen. int const & heeft geen enkel praktisch nut, en is zeker niet sneller.

Goed punt, had ik nog niet eens over gedacht. Voor objecten op de heap is het echter wel degelijk een winst tov pass by value en veiliger dan pointers gebruiken.

[kitao]

Rmg schreef op dinsdag 8 januari 2019 @ 10:20:
Sowieso moet je functie aanroep niet

int Machtsverheffen( int ivGrondtal, int ivExponent) zijn

code:

// functie machtsverheffen
int Machtsverheffen( int ivGrondtal,  int ivUitkomst)
{
    for (int i = 1; i < ivExponent; i++)
    {
        ivUitkomst = ivUitkomst * ivGrondtal;
        cout << ivUitkomst << endl;
    }

    cout << endl << endl << "ivUitkomst vlak voor return = " << ivUitkomst << endl;
    
    return ivUitkomst;
}

ok, tnx
maar de functie werd in regel 46,47 aangeroepen, zie OP codes :

46 //roep functie aan
47 Machtsverheffen(ivGrondtal, ivUitkomst);

Radiant schreef op dinsdag 8 januari 2019 @ 09:53:
[...]

Je kan dan beter één breakpoint zetten op het punt waar je wil beginnen of op pauze klikken en daarna step into/step over gebruiken.

Prima tip, meteen getest en werkt goed.

Verwijderd schreef op dinsdag 8 januari 2019 @ 11:02:
@BoAC Uiteraard is passing by const reference de beste optie. Alleen dan denk ik dat het wel goed is om dat even uit te leggen, de voorbeelden die TS volgt gaan daar geheel niet op in.

Op zich wel verassend dat referencing, pointers, noch templates en unique_ptr/shared_ptr behandeld wordt. Om echt iets nuttigs te maken zal hij na het doorwerken van deze voorbeelden dus op zoek moeten naar een wat uitgebreidere tutorial.

ja, helemaal met je eens, zoals ik al schreef ik zat al te verzinnen voor een volgend reeks oefeningen.
Daos gaf al een goeie website maar die van BoAC ziet er zelfs nog iets beter uit. Die kon ik trouwens nog niet.
Ongeveer 5 jaar geleden wel deze proberen te volgen :

http://www.cplusplus.com/doc/tutorial/

maar werd me iets te moeilijk, bij Classes meen ik dat het schip strandde, en ging andere dingen doen.
Sindsdien niets meer aan gedaan tot een paar weken geleden. Dit wordt poging twee zeg maar.
.

[MSalters]

BoAC schreef op dinsdag 8 januari 2019 @ 10:49:

code:

// functie machtsverheffen
int Machtsverheffen( const int &ivGrondtal,  const int &ivExponent)

De compiler levert in dit geval performance winst op, omdat er geen 'kopie' behoeft gedaan te worden

Dat is wel heel erg 2010 stijl. Even afgezien van de eerdere opmerking over de grootte van integers versus adressen op 64 bits platformen, voor grote types is dit ook niet vanzelfsprekend optimaal. C++11 compilers maken geen kopie, als ze een "move" kunnen doen. Pass-by-value is expliciet een situatie waarin moves mogelijk zijn, mits het type uiteraard gemoved kan worden (Integers moven is zinloos, een kopie maken is net zo complex)

[Verwijderd]

MSalters schreef op dinsdag 8 januari 2019 @ 12:45:
[...]

Dat is wel heel erg 2010 stijl. Even afgezien van de eerdere opmerking over de grootte van integers versus adressen op 64 bits platformen, voor grote types is dit ook niet vanzelfsprekend optimaal. C++11 compilers maken geen kopie, als ze een "move" kunnen doen. Pass-by-value is expliciet een situatie waarin moves mogelijk zijn, mits het type uiteraard gemoved kan worden (Integers moven is zinloos, een kopie maken is net zo complex)

Als iemand die lang geleden c++ (lees c met classes) heeft gebruikt en redelijk recent pas met moderne c++ geconfronteerd is vindt ik dit nog redelijk verwarrend.

Ik heb wat presentaties over modern c++ van het internet gehaald en de concensus is dat pass by const ref gebruikt moet worden als een move te duur is. Wat ik echter niet kan vinden is in welke gevallen een move duur is, laat staan wanneer het te duur is. Met unique_ptr is het simpel

C++:

uitkomst = functie(std::move(uniquePointer));

omdat je dan geen andere optie hebt. Dat is alleen wel een bijzondre situatie omdat je na het uitvoeren van de functie de input 'kwijt bent' tenzij het op enige wijze onderdeel is van de return waarde.

[ Voor 6% gewijzigd door Verwijderd op 08-01-2019 13:19 ]

[MSalters]

Je kunt inderdaad niet op internet vinden welke classes een dure move hebben. Net zoals de copy constructor is de move constructor van een class potentieel user-defined, met een member-wise move als default. En voor de primitieve types is een move gelijk aan een copy.

(Na een C++ move is de toestand van het bron-object doorgaans ongespecificeerd; daarom is er geen verschil tussen copy en move voor primitieve types. "Ongewijzigd" valt ook binnen "ongespecificeerd. )

En inderdaad, een move-in van een unique_ptr betekent dat de resource geconsumeerd wordt. Dat hoef je dus niet in commentaar te beschrijven, C++11 maakt dat gedrag expliciet in de functie signature.

[ThomasG]

Wellicht is het handig om F.call: Parameter passing uit de C++ Core Guidelines eens door te lezen.

[EddoH]

MSalters schreef op dinsdag 8 januari 2019 @ 12:45:
[...]

Dat is wel heel erg 2010 stijl.

Een move is toch geen vervanging van const reference?
Als je een functie schrijft waar je een argument mee wilt geven die je niet gaat aanpassen of kopiëren, en het niet altijd een rvalue is, is een const reference nog altijd het meest efficiënt?

[Alain]

De code van mijn voorganger ziet er als volgt uit:

C++:

int getValue(double *value) { ... }

Waarbij de functie een error (negatief), ok (0) of busy (positief) terug geeft.

Ik had dit eigenlijk nooit gezien. Iemand enig idee waarom je het zo zou doen en niet gewoon de waarde teruggeven en eventueel een status als pointer?

[DroogKloot]

Het "return status, schrijf waarde naar pointer" patroon is vrij standaard. Je kunt de signature natuurlijk ook zo schrijven:

C:

double getValue(int* status)

... maar nu heb je het probleem dat de caller apart naar de waarde van status moet kijken om te bepalen of de double iets zinnigs bevat, en in de niet-zinnige situaties de callee alsnog een waarde moet bedenken die dan mogelijk verkeerd geinterpreteerd wordt. Bovendien kan value een of ander custom type zijn dat duur is om te kopiëren en/of initialiseren, wat in deze variant altijd* gebeurt.

* wanneer je het zonder move semantics moet stellen althans, zoals in plain C of C++ <= 03

[kitao]

Volgende vraag alweer en heb me voorgenomen niet te snel van Tweakers gebruik te maken maar hier ben ik al paar uurtjes mee bezig en zie nog geen uitweg, behalve misschien een heel andere opzet toepassen, waarover later meer.

Uit les 9 : Bewerkingen op strings

code:

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

void main()
{
    string myString = "Een string vol tekens.";
    cout << myString.find("X") << endl;

    if (myString.find("X", 0))
    {
        cout << "Gevonden.";
    }
    cout << endl << endl;
    system("pause");
}

Dit is dan het resultaat :




De if lus wordt gewoon uitgevoerd (??)
sterker nog, maakt niet uit wat ik tot nu toe heb ingevuld, of ik 0 verander tot 5 of X verander tot n, alles wordt gevonden.
Enige uitzondering die ik daarbij tegenkwam was met if (myString.find("E", 0)).
Dan wordt niet de if-lus uitgevoerd.

De andere opzet waar ik het over had staat hier als example :

http://www.cplusplus.com/reference/string/string/find/

Die moet ik eigenlijk eerst nog goed doornemen maar omdat het een andere methode is weet ik dan nog niet waar het mis gaat.

Alvast bedankt.

[.oisyn]

Alain schreef op dinsdag 8 januari 2019 @ 23:05:
Ik had dit eigenlijk nooit gezien. Iemand enig idee waarom je het zo zou doen en niet gewoon de waarde teruggeven en eventueel een status als pointer?

Of je gebruikt gewoon een struct, std::optional of std::variant (of straks de beste optie: std::expected) als je meer wil returnen dan in een enkele primitive past. Een andere optie is het gebruik van exceptions.

---

@kitao
Je antwoord wordt redelijk duidelijk als je gewoon de documenatie van find() leest. Het returnt geen bool. Wat returnt het wel?

[ Voor 20% gewijzigd door .oisyn op 09-01-2019 17:57 ]

[ThomasG]

find returned geen boolean, maar unsigned integer dat een positie voorstelt. Als het stukje tekst niet gevonden wordt, returned het string::npos, wat gelijk is aan 2^32-1, ofwel 4294967295. Als het wel gevonden is, returned het de positie, waarbij de eerste positie 0 is.

If-statements, of eigenlijk: condities, werken natuurlijk met true of false en niet met integers. Maar van oudsher kun je er in C++ een integer in stoppen, het getal 0 staat gelijk aan false, en vanaf 1 en hoger als true.

In jouw voorbeeld wordt X niet gevonden in de string, en returned daarom string::npos. E word wel gevonden, maar omdat het in dit geval het eerste character is (ofwel, de 0e positie), returned het 0.

Op de pagina die jij gelinkt hebt (http://www.cplusplus.com/reference/string/string/find/) staat nota bene een voorbeeld hoe je find correct gebruikt (maar helaas geen uitleg waarom).

[ Voor 0% gewijzigd door ThomasG op 09-01-2019 18:00 . Reden: typfout ]

[.oisyn]

ThomasG schreef op woensdag 9 januari 2019 @ 17:57:
het getal 0 staat gelijk aan true, en vanaf 1 en hoger als true.

Gevaarlijke definitie (en dan neem ik gewoon even aan dat je bij de eerste "true" eigenlijk "false" bedoelt ). Wat dan bij negatieve getallen?

Voor alle primitieven geldt: 0/nullptr convert naar false, de rest naar true.

[kitao]

ThomasG schreef op woensdag 9 januari 2019 @ 17:57:
find returned geen boolean, maar unsigned integer dat een positie voorstelt. Als het stukje tekst niet gevonden wordt, returned het string::npos, wat gelijk is aan 2^32-1, ofwel 4294967295. Als het wel gevonden is, returned het de positie, waarbij de eerste positie 0 is.

[...]

Op de pagina die jij gelinkt hebt (http://www.cplusplus.com/reference/string/string/find/) staat nota bene een voorbeeld hoe je find correct gebruikt (maar helaas geen uitleg waarom).

Helemaal bedankt voor je antwoord. Ik ga met dat voorbeeld verder want ik maak hier engzins uit op dat find in genoemde les 9 niet correct wordt gebruikt, wat ik natuurlijk niet verwacht had.
Morgen als ik het cplusplus voorbeeld heb doorgenomen zal ik ook proberen de hint van .oisyn te beantwoorden, alhoewel in jouw reactie daar ook al op in wordt gegaan. Dat is dan alvast mooi meegenomen. Tnx.

[ Voor 17% gewijzigd door kitao op 09-01-2019 18:12 ]

[ThomasG]

.oisyn schreef op woensdag 9 januari 2019 @ 17:59:
[...]

Gevaarlijke definitie (en dan neem ik gewoon even aan dat je bij de eerste "true" eigenlijk "false" bedoelt ). Wat dan bij negatieve getallen?

Voor alle primitieven geldt: 0/nullptr convert naar false, de rest naar true.

Dat was een typefout Maar inderdaad, wat er werkelijk gebeurd als je een primitive in een conditie stopt is kijken of het niet gelijk is aan 0.

C++:

int foo = 42;
if (foo) {
// is eigenlijk:
if (foo != 0) {

Dus:

C++:

if (myString.find("X")) {
// is eigenlijk:
if (myString.find("X") != 0) {
// tenzij je er het volgende van maakt:
if (myString.find("X") != std::string::npos) {

[SuperJoker]

Leer jezelf aan om het gewoon uit te schrijven. En als je het puristisch juist wil doen, doe je het andersom.

Dus niet:

C++:

if (foo != 0) 

maar:

C++:

if (0 != foo)

Functioneel maakt het geen moer uit, het is meer een anti-bug ding.

Je zou de eerste niet zijn die per ongeluk bij een vergelijking '=' typt ipv '==' of '==='. Het voordeel van de conditie omdraaien, is dat je dan een compiler error krijgt. Dat kan je later vele uren debuggen schelen, omdat het ook typisch iets is waar je heel snel overheen kijkt.

[kitao]

ThomasG schreef op woensdag 9 januari 2019 @ 18:12:
[...]
Dat was een typefout Maar inderdaad, wat er werkelijk gebeurd als je een primitive in een conditie stopt is kijken of het niet gelijk is aan 0.

C++:

int foo = 42;
if (foo) {
// is eigenlijk:
if (foo != 0) {

Dus:

C++:

if (myString.find("X")) {
// is eigenlijk:
if (myString.find("X") != 0) {
// tenzij je er het volgende van maakt:
if (myString.find("X") != std::string::npos) {

Prima hoor. Heb het inmiddels aangepast en werkt nu.

code:

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

void main()
{
    string myString = "Een string vol tekens.";
    cout << myString.find("x") << endl;

    if (myString.find("x", 0) != string::npos)
    {
        cout << endl <<"Gevonden.";
    }
    else
    {
        cout << endl << "Niet Gevonden.";
    }
    cout << endl << endl;
    system("pause");
}

Maar dat het werkt is niet het belangrijkste, ik begrijp door alle uitleg nu ook wat er gebeurt, mede dankzij dit :
[het getal 0 staat gelijk aan false, en vanaf 1 en hoger als true.

dat wist ik nog niet.

@.oisyn
Bedankt voor de referentie link, ben ze inmiddels aan het verzamelen in mapje.

@SuperJoker
Heb meteen ook geprobeerd om een = weg te laten en dan zonder de conditie om te draaien maar kreeg hier wel een foutmelding. (?)

[SuperJoker]

Kijk meteen de voordelen van wat ik zei.

Dat je een foutmelding krijgt is totaal terecht. Immers je probeert iets toe te kennen aan een functie. Dat kan niet.

Hier zie je gelijk het voordeel van deze notatiewijze. Je krijgt gelijk een foutmelding om je oren.

Je ziet ook 'left operand must be l-value'. Je hebt l values en r values, l values kunnen links van de operator staan, r values niet, die kunnen alleen rechts staan.

[ Voor 14% gewijzigd door SuperJoker op 09-01-2019 23:28 ]

[.oisyn]

SuperJoker schreef op woensdag 9 januari 2019 @ 23:27:
Dat je een foutmelding krijgt is totaal terecht. Immers je probeert iets toe te kennen aan een functie. Dat kan niet.

find is een functie, find(...) is een functie-aanroep, met een bepaald resultaat. Je kunt best iets assignen aan het resultaat van een functie-aanroep, vermits dat resultaat een lvalue is, of een object van class-type.

Vooral dat laatste is een beetje raar, maar dit compilet:

C++:

struct S { };
S foo();

void bar()
{
    S s;
    foo() = s;
}

foo() returnt een temporary object wat in principe gewoon assignable is.

kitao schreef op woensdag 9 januari 2019 @ 20:24:
@.oisyn
Bedankt voor de referentie link, ben ze inmiddels aan het verzamelen in mapje.

cppreference.com is echt de go-to site om details op te zoeken . Enorm gedetailleerd en wordt actief up to date gehouden met alle nieuwe ontwikkelingen (je kunt er ook al veel dingen over C++20 lezen), en er staat precies bij vanaf welke versie van C++ iets geldt.

Om gewoon met dingen te spelen heb je de compiler explorer van Matt Godbolt: godbolt.org. Ondersteunt tal van verschillende compilers en laat de gegenereerde assembly zien. Voor standard compliance kun je het beste de x64 trunc versie van GCC of Clang pakken (Clang produceert over het algemeen betere errormeldingen), maar wel zorgen dat je -std=c++17 opgeeft als argument voor de compiler (en -O2 of -O3 voor optimalisaties als je geïnteresseerd bent in de gegenereerde assembly)

[ Voor 44% gewijzigd door .oisyn op 10-01-2019 08:55 ]

[SuperJoker]

Geheel waar, en in dit geval is er sprake van een constante dus is het omdraaien van de waardes niet nodig en zelfs ongewenst, maar ik dacht, laat ik het verder even niet uitwerken. Het ging mij even om het principe.

[kitao]

.oisyn schreef op woensdag 9 januari 2019 @ 23:52:
[...]
cppreference.com is echt de go-to site om details op te zoeken . Enorm gedetailleerd en wordt actief up to date gehouden met alle nieuwe ontwikkelingen (je kunt er ook al veel dingen over C++20 lezen), en er staat precies bij vanaf welke versie van C++ iets geldt.

Om gewoon met dingen te spelen heb je de compiler explorer van Matt Godbolt: godbolt.org. Ondersteunt tal van verschillende compilers en laat de gegenereerde assembly zien. Voor standard compliance kun je het beste de x64 trunc versie van GCC of Clang pakken
[...]

Dat laatste gedeelte zegt me niet zo veel maar heb wel de comp.expl. bekeken en stukje getest.
Kan inderdaad later goed van pas komen, bedankt.

Ben nu al diverse uren bezig om een string te returnen vanuit een functie maar mijn basis is nog te weinig om het goed op te bouwen. Natuurlijk wel gezocht maar kom veel uitleg tegen met dingen die ik nog niet gehad heb. Het is niet mijn bedoeling om hele ingewikkelde vragen te stellen met veel uitgebreide uitleg die ik toch niet snap maar mss wel leuk om even oppervlakkig naar te kijken.

Ik heb dit programma geschreven (les 9 , link in code) :

code:

/*
2. Schrijf een functie die een string als invoer krijgt en als uitvoer 
het omgekeerde van die string geeft.
Oefening komt uit :
http://www.ronkes.nl/oldprogrammeren/oefeningen9.html
*/
#include <iostream>
#include <string>
using namespace std;

string str1;
string str2;
string str3;
int Positie = 0;

int Functie(string stri1)
{
    if (str1 == "")
    {
        cout << endl << "Je hebt een lege string ingevoerd" << endl;
    }

    Positie = str1.length();
    Positie--;

    for (int i = Positie; i >= 0; i--)
    {
        str2 = str1.at(Positie);
        str3 += str2;
        Positie--;
    }
    cout << endl << "Dit is str3 in Functie :   " << str3 << endl;

    return 0;
}

int main()
{
    cout << "Geef om te draaien woord ?   ";
    getline(cin, str1);

    Functie(str1);

    cout << endl << "Dit is de str3 vanuit main, " << endl;
    cout << "na terugkeer uit Functie : " << str3 << endl << endl;
    system("pause");
}

Daar komt dan dit uit :




Op zich ben ik daar best tevreden mee maar heb eigenlijk geen return 0; nodig maar een return string.
(dit ivm unit testen uit die opgave die niet in de code staat opgenomen)


verander ik regel 34 van
return 0;
naar
return str3;

en regel 45 van
cout << endl << "Dit is str3 in Functie : " << str3 << endl;
naar
cout << endl << "Dit is str3 in Functie : " << Functie(str1) << endl;

dan komt deze foutmelding :

Error C2440 'return': cannot convert from 'std::string' to 'int' Line 34


Return string zoeken op internet gaf wel verschillende resultaten maar zoals gezegd, kan ze nog niet allemaal bevatten, zoals deze http://www.cplusplus.com/forum/beginner/91991/.

Uiteindelijk komt het er dan op neer om van de verschillende uitlegversies er eentje te gaan proberen en dat heb ik bij deze gedaan, is in 5 minuten video vorm , zie link onder /* code.

code:

/*
Uitleg video op
https://www.youtube.com/watch?v=V9uWJJ6owMQ
*/

#include <iostream>
#include <string>
using namespace std;
string & ReturnString(string & n);

int main(void)
{
    string myname = "kitao";
    cout << "Mijn originele naam is :  " << myname << endl;
    cout << "De naam is veranderd tot : " << ReturnString(myname) << endl;
    system("pause");

    return 0;
}

string & ReturnString(string & n);
{
    n.clear();
    n = "piet";
    return n;
}

Dat geeft dan weer deze foutmelding :

Error C2447 '{': missing function header (old-style formal list?) Line 23

Raar, want de video is niet oud, uit feb 2016 en gebruikt ook visual studio zo te zien.
Er staan weinig reacties onder maar geen met de opmerking dat het niet werkt.

Paar keer nagekeken maar weet vrijwel 99,9% zeker dat mijn gemaakte kopie van zijn programma identiek is. Maar loopt dus toch vast. Overigens weet ik dan eigenlijk nog niet wat er precies gebeurt maar voor nu zoek ik een simpele manier om een string te returnen.
Had niet gedacht dat het returnen van een string nogal behoorlijk ingewikkeld zou blijken.
Les 9 lijkt wel een uitgewerkt antwoord te hebben maar die bekijk ik pas op het allerlaatste moment.

http://www.ronkes.nl/oldprogrammeren/antwoorden.html

[EddoH]

Kijk eens goed naar je functie definitie. kuch, iets met puntkomma, kuch

Het returnen van dezelfde reference die je als functieargument meegeeft is overigens weinig nuttig.

[ Voor 69% gewijzigd door EddoH op 10-01-2019 21:19 ]

[kitao]

EddoH schreef op donderdag 10 januari 2019 @ 21:16:
Kijk eens goed naar je functie definitie. kuch, iets met puntkomma, kuch

Het returnen van dezelfde reference die je als functieargument meegeeft is overigens weinig nuttig.

regel 21

Mijn 99,9% was dus eigenlijk 0,09%

Heb het getest en gaat nu goed.

Kan excuusje opvoeren, bij het invoeren van regel 9 kreeg ik al een groen golf lijntje onder string & ReturnString(string & n);
Dacht dat het, gezien de foutmelding old style uit de library van <string> was verdwenen.
Zo noemen ze dat geloof ik, <string> is een library , meen ik nog uit mn arduino tijd te herinneren, ook 5 jaar geleden.
In ieder geval, hartstikke bedankt, kan nu morgen met frisse blik en werkende string return weer verder.
Aangaande functieargument en reference, zover ben ik nog niet om daarover in discussie te gaan maar vind het natuurlijk niet erg als anderen daar wel op in gaan.

ps/
zie nog een foutje in de 1e code van het woord omkeer programma in mijn vorige post.

16 int Functie(string stri1)
moet zijn
int Functie(string str1)

maar blijkt voor de uitvoering geen verschil te maken. (?)

[ Voor 12% gewijzigd door kitao op 11-01-2019 00:58 ]

[farlane]

EddoH schreef op donderdag 10 januari 2019 @ 21:16:
Het returnen van dezelfde reference die je als functieargument meegeeft is overigens weinig nuttig.

Method chaining?

[EddoH]

farlane schreef op vrijdag 11 januari 2019 @ 15:16:
[...]

Method chaining?

Zit wat in, alleen ik denk niet dat dat de intentie was
Misschien had ik 'in deze context' er bij moeten zetten.

[farlane]

EddoH schreef op vrijdag 11 januari 2019 @ 15:43:
[...]
Zit wat in, alleen ik denk niet dat dat de intentie was
Misschien had ik 'in deze context' er bij moeten zetten.

Ik heb zitten twijfelen of ik wel zo bijdehand zou moeten zijn. Ik vond van wel.

[.oisyn]

Verwijderd schreef op dinsdag 8 januari 2019 @ 11:09:
[...]

Voor objecten op de heap is het echter wel degelijk een winst tov pass by value en veiliger dan pointers gebruiken.

Dit wil ik toch nog even nuanceren. Het is een ontzettend gevaarlijke uitspraak. Ja, het kopiëren van een object kan mogelijk duur zijn, maar dat is maar 1 kant van het verhaal. Het probleem met references is dat de onderliggende waarde zomaar kan wijzigen, bijvoorbeeld door een write naar een andere reference (aliasing), of na het aanroepen van een functie waarvan de compiler de inhoud niet weet.

Hierdoor zijn er tal van optimalisaties ineens niet meer mogelijk, en zit er voor de compiler niets anders op dan de betreffende waarde steeds opnieuw uit te lezen nadat hij mogelijk veranderd is. Bij het hebben van een eigen kopie binnen de scope van de functie kan ontzettend veel voordeel gehaald worden, wat misschien wel meer oplevert dan wat de kopie zelf kost.

[kitao]

Was net in dit topic even aan het terugkijken voor een eerder geplaatste link.
Maar nu ik hier toch ben, het programma Visual Studio 2017 begint bijdehand te doen.

string.lenght() pakt die ene keer wel, andere keer niet

vergelijk regel 23, 34 , 35 , 36




Heb daarna regel 35 gekopie-plakt op regel 34 , ge-edit tot hetzelfde als wat er nu in de afbeelding op regel 34 staat en het rode error lijntje, waardoor die ook niet compileert trouwens, is dan weer weg.
Zit dan ergens hikje in het programma volgens mij.

Zou ook handig zijn als bij doorlopen van het programma met step into de prompt kan worden vastgepind ?

[Verwijderd]

.oisyn schreef op vrijdag 11 januari 2019 @ 17:34:
[...]

Dit wil ik toch nog even nuanceren. Het is een ontzettend gevaarlijke uitspraak. Ja, het kopiëren van een object kan mogelijk duur zijn, maar dat is maar 1 kant van het verhaal. Het probleem met references is dat de onderliggende waarde zomaar kan wijzigen, bijvoorbeeld door een write naar een andere reference (aliasing), of na het aanroepen van een functie waarvan de compiler de inhoud niet weet.

Hierdoor zijn er tal van optimalisaties ineens niet meer mogelijk, en zit er voor de compiler niets anders op dan de betreffende waarde steeds opnieuw uit te lezen nadat hij mogelijk veranderd is. Bij het hebben van een eigen kopie binnen de scope van de functie kan ontzettend veel voordeel gehaald worden, wat misschien wel meer oplevert dan wat de kopie zelf kost.

Goed punt, zo diep zit ik helaas (gelukkig?) niet in de materie. Ik doe tegenwoordig veel meer met C# en c++ lag jaren in het verleden. Alleen ben ik nu druk met OpenCL op Linux en heb ik voor de host code teruggegrepen op c++. Ophalen en voorbereiden van de iinput data voor het doorrekenen, data structures van 1GB+ zijn niet ongewoon, dan wil je echt geen onnodige kopiën hebben.

Overigens is die data omvang ook een reden voor c++, werkt in C# niet echt lekker, je ziet letterlijk wanneer de garbage collector aan de slag gaat, de berekeningen komen bijna tot stilstand.

[EddoH]

kitao schreef op vrijdag 11 januari 2019 @ 17:44:
Was net in dit topic even aan het terugkijken voor een eerder geplaatste link.
Maar nu ik hier toch ben, het programma Visual Studio 2017 begint bijdehand te doen.

string.lenght() pakt die ene keer wel, andere keer niet

vergelijk regel 23, 34 , 35 , 36

[Afbeelding]


Heb daarna regel 35 gekopie-plakt op regel 34 , ge-edit tot hetzelfde als wat er nu in de afbeelding op regel 34 staat en het rode error lijntje, waardoor die ook niet compileert trouwens, is dan weer weg.
Zit dan ergens hikje in het programma volgens mij.

Ga je nu Visual Studio de schuld geven van je eigen spelfouten?

Dit is overigens waarom code completion gebruiken/instellen in je IDE een goed idee is.

[farlane]

SuperJoker schreef op woensdag 9 januari 2019 @ 18:16:
Leer jezelf aan om het gewoon uit te schrijven. En als je het puristisch juist wil doen, doe je het andersom.

Dus niet:

C++:

if (foo != 0) 

maar:

C++:

if (0 != foo)

Het mag dan de kans op een bepaald type bug verkleinen, de mental capacity die het mij kost wanneer ik het lees maakt dat ik er slecht tegen kan. Nu is == en != nog te doen, maar < en > dan maakt het voor mij net negatieve logica. Kills my brain

[.oisyn]

Maar bij < en > (en <= en >=) hoeft het natuurlijk ook niet hè . Maar ik ben ook geen fan. Ik kan me de laatste keer niet heugen dat ik deze fout heb gemaakt, dus dan vind ik leesbaarheid een belangrijker punt.

[ Voor 53% gewijzigd door .oisyn op 11-01-2019 21:41 ]

[Matis]

Daarbij komt nog dat tegenwoordig een beetje compiler of SCA tool dit gewoon oppikt en je er (minstens) en warning op geeft.

[kitao]

*heel verhaal over length() verwijderd door kitao*
ik heb echt een brilletje nodig hoewel het er op lijkt dat het erger is als dat, namelijk blinde vlekken die me zelfs na minuten kijken blijkbaar niet opvallen. Geen goed begin om mee te gaan leren programmeren.

EddoH bedankt, ik zal meer vd auto complete gebruik maken, dankzij jouw post waarna ik deze video tegenkwam met daarin een paar sneltoetsen zoals ctrl+spacebar, heb er dus toch nuttige dingen van opgestoken.

YouTube: Visual Studio tutorial: Using IntelliSense effectively | lynda.com


Zal zelf eens verder zoeken hoe ik het prompt scherm in beeld kan blijven houden als ik step into gebruik.
Deze verdwijnt namelijk bij iedere klik naar de taskbar.

[ Voor 200% gewijzigd door kitao op 12-01-2019 09:30 ]

[Mijzelf]

kitao schreef op zaterdag 12 januari 2019 @ 08:40:
Zal zelf eens verder zoeken hoe ik het prompt scherm in beeld kan blijven houden als ik step into gebruik.
Deze verdwijnt namelijk bij iedere klik naar de taskbar.

Het makkelijkst is een dual monitor setup.

[.oisyn]

Matis schreef op zaterdag 12 januari 2019 @ 06:57:
Daarbij komt nog dat tegenwoordig een beetje compiler of SCA tool dit gewoon oppikt en je er (minstens) en warning op geeft.

Het is niet een warning die snel gegeven wordt ivm legitiem gebruik. Je moet wel moeite doen om 'm aan te zetten.

[kitao]

Mijzelf schreef op zaterdag 12 januari 2019 @ 11:25:
[...]

Het makkelijkst is een dual monitor setup.

Bedankt, dat is een goeie tip, het blijft staan en ik kan tijdens het 'steppen' mee blijven kijken.
Had ik eigenlijk zelf al moeten opkomen om te proberen want is niet voor het eerst dat ik twee programma's naast elkaar zet.




Nadeel is enigzins dat alles stuk kleiner wordt, ik zocht eigenlijk een manier om de output window vast te pinnen terwijl het visual studio scherm maximaal blijft.
Kwam dan o.a. hier uit
https://visualstudio.user...o-stay-open-on-off-settin
Toegepast en cons.window blijft na einde dan wel open maar met 'steppen' helaas niet en een makkelijke oplossing hiervoor heb ik niet gevonden.


Zoals op deze manier blijft het namelijk niet staan :




Bij klik op step into verdwijnt de window naar taskbar.

Desondanks prima verbetering met duo-monitor, tnx.

Op zich had deze vraag niet veel met programmeren te maken maar wou je toch even laten weten wat het resultaat is geworden.

Kan wel een programmeer vraagje verzinnen maar het is niet zo dat ik er door 'vast loop'.

Ik zie voorbeelden waar geen using namespace std; wordt gebruikt en dan in plaats van bijvoorbeeld gewoon cout is het nodig om std::cout te gaan schrijven.
Dus vroeg me af waarom niet iedereen using namespace std gebruikt.

[Mijzelf]

kitao schreef op zaterdag 12 januari 2019 @ 15:38:
Nadeel is enigzins dat alles stuk kleiner wordt, ik zocht eigenlijk een manier om de output window vast te pinnen terwijl het visual studio scherm maximaal blijft.

Ik bedoelde eigenlijk letterlijk 2 monitors.

Ik zie voorbeelden waar geen using namespace std; wordt gebruikt en dan in plaats van bijvoorbeeld gewoon cout is het nodig om std::cout te gaan schrijven.
Dus vroeg me af waarom niet iedereen using namespace std gebruikt.

Namespaces hebben een functie, namelijk om collisions in naamgeving te voorkomen. Met 'using namespace std' mag je zelf geen 'cout' meer aanmaken. Nou is dat niet zo'n probleem, maar wat als een van jouw globale functies/variabelen in een latere versie van de standard libraries ook in std zit? Dan heb je een conflict en compileert het niet meer.

[kitao]

Mijzelf schreef op zaterdag 12 januari 2019 @ 18:30:
[...]

Ik bedoelde eigenlijk letterlijk 2 monitors.

Ja dat dacht ik al maar mijn financiële situatie is bedroevend. Maar jouw tip werkte prima, tnx.
Om die reden ben ik ook met een gratis internet cursus bezig die af en toe wat stappen overslaat.
Omdat ik nog niet naar de antwoorden had gekeken onstond eerder in dit topic mijn aanname dat het returnen van een string nogal ingewikkeld is (uren mee zoet geweest)
Heb inmiddels mijn uitwerkingen van les 9 nagekeken en blijkt het heel simpel te wezen.
Het 'voorvoegsel' int Functie() veranderen naar string Functie() en return myString; gaat ineens zonder problemen.
Hier is de les 9 te vinden voor wie het interesseert.
http://www.ronkes.nl/oldprogrammeren/antwoorden.html

Namespaces hebben een functie, namelijk om collisions in naamgeving te voorkomen. Met 'using namespace std' mag je zelf geen 'cout' meer aanmaken. Nou is dat niet zo'n probleem, maar wat als een van jouw globale functies/variabelen in een latere versie van de standard libraries ook in std zit? Dan heb je een conflict en compileert het niet meer.

Had die vraag erbij verzonnen en nog niet zelf opgezocht, trefwoord 'using namespace disadvantage' levert o.a. dit op : https://www.geeksforgeeks...-considered-bad-practice/
Dat is de lange versie van jouw antwoord zeg maar.
Toch was het niet enkel luiheid om die vraag te stellen, ik zat namelijk te tobben met waarom std::cout wel vervangen kan worden door cout mits 'using' wordt gebruikt , terwijl string::npos niet vervangen kan worden door string npos hoewel #include<string> toch boven main() staat.
Of logischer een andere variant die ik probeerde:
std::cout kan met 'using' wel cout worden
maar
string::npos kan met #include<string> geen npos worden.

En opvallend is dat in het antwoord van les 9 (mapje Aeneas) maar liefst drie keer dit voorkomt :
if (myIndex != string.npos)
Hetgeen bij mij dus een error oplevert.
Heb inmiddels gevonden dat dit wel gaat :
string string = "Hallo";
if (myIndex != string.npos)
Maar zo heeft de cursus auteur het m.i. niet bedoeld aangezien hij geen string met de naam string heeft geïni-tialiseerd en 3x dezelfde schrijffout lijkt me ook onwaarschijnlijk.
Ik vermoed hier een verouderde schrijfwijze ?
Deze vraag is lastig te vinden, zoeken op string.npos levert maar één resultaat, de rest is allemaal string::npos.
Lijkt triviaal maar met zulk soort dingetjes kan ik me een tijd mee bezighouden.

[ Voor 3% gewijzigd door kitao op 13-01-2019 16:55 . Reden: spelfouten ]

[EddoH]

Een include is iets anders dan using. Zie documentatie.
Verder is string::npos een static member, geen namespace.

Zie voor gebruik:
http://www.cplusplus.com/reference/string/string/npos/
http://www.cplusplus.com/forum/beginner/233668/

[Mijzelf]

mijn financiële situatie is bedroevend.

Bij een kringloop winkel zie je vaak 'oude' 3:4 LCD monitoren voor 1 of 2 tientjes.

[farlane]

.oisyn schreef op vrijdag 11 januari 2019 @ 21:33:
Maar bij < en > (en <= en >=) hoeft het natuurlijk ook niet hè . Maar ik ben ook geen fan. Ik kan me de laatste keer niet heugen dat ik deze fout heb gemaakt, dus dan vind ik leesbaarheid een belangrijker punt.

Nee klopt, maar het ligt voor de hand (en is mijn ervaring) dat alle relational operators dan op die manier geschreven gaan worden.

[kitao]

Mijzelf schreef op zondag 13 januari 2019 @ 20:34:
Bij een kringloop winkel zie je vaak 'oude' 3:4 LCD monitoren voor 1 of 2 tientjes.

Dat valt zeker te overwegen, bedankt.

EddoH schreef op zondag 13 januari 2019 @ 19:19:
Een include is iets anders dan using. Zie documentatie.
Verder is string::npos een static member, geen namespace.

Zie voor gebruik:
http://www.cplusplus.com/reference/string/string/npos/
http://www.cplusplus.com/forum/beginner/233668/

Ja bedankt, die twee begrippen moet ik inderdaad nog uitzoeken, had inmiddels wel de verschillen in schrijfwijze gezien van het aanroepen van #include en namespace.
Eigenlijk stond er ook geen string::npos maar std::string::npos in het example.
Maar vind het verder nog steeds een raadsel waarom de cursus auteur if (myIndex != string.npos) heeft toegepast want dat compileert bij mij niet.

Ben inmiddels bij les 10 met titel Verzamelingen: http://www.ronkes.nl/oldprogrammeren/les10.html
Deze oefening zit erbij :
2. Maak een vector met daarin een vector, zodat je een tabel krijgt.
Schrijf de tabel naar het scherm.
Hieronder zie je hoe je zo'n twee-dimensionale vector moet declareren.
vector<vector<int> > myTable;

Bovenstaande hint bleek iets te summier, eerst geprobeerd met enkel die info de oefening te maken maar dat lukte niet. Dus ben elders gaan spieken. Het principe heb ik geloof ik redelijk door nu, maar nog niet dat ik het zonder naslag zo op kan schrijven. Er is wel iets dat ik enigzins teleurstellend vind.
Dit programma levert als resultaat een rijtje van 6 getallen op :

code:

#include<iostream>
#include<vector>
using namespace std;
int main(){
    vector<int>Vector;
    int N = 0;
    cout << "Voer 6 getallen in   \n\n";
        for (int i = 0; i < 6; i++) {
        cin >> N;
        Vector.push_back(N);
    }
    cout << "\n\nDit is de getallen Verzameling :\n\n";
        for (int i = 0; i < 6; i++) {
        cout << Vector.at(i) << "\t";
    }
    cout << "\n\n";
    system("pause");
}

Onderstaand programma levert als resultaat een tabel op met twee rijen en drie kolommen :

code:

//https://www.quora.com/How-do-I-create-a-2D-vector-array-using-std-vector
// http://www-h.eng.cam.ac.uk/help/tpl/languages/C++/vectormemory.html
#include<iostream>
#include<vector>
using namespace std;
int main(){
    vector<vector<int> > VectorVector;
    int k;
    cout << "Voer 6 getallen in   \n\n";
    for (int i = 0; i < 2; i++) {
        VectorVector.push_back(vector<int>());
        for (int j = 0; j < 3; j++)     {
            cin >> k;
            VectorVector[i].push_back(k);
        }
    }
    cout << "\n\nDit is de getallen Verzameling :\n\n";
    for (int i = 0; i < 2; i++)     {
        for (int j = 0; j < 3; j++)
        {
            cout << VectorVector[i][j] << "\t";
        }
        cout << endl;
    }
    cout << endl << endl;
    system("pause");
}

Maar dat resultaat staat of valt met het wel of niet aanwezig zijn van regel 23, cout << endl;
Haal ik die namelijk weg dan is het resultaat van prog2 identiek aan prog1.
Toen ik dat voor het eerst merkte had ik het gevoel van valsspelen.
Ik zie wel het nut in van cout << VectorVector[i][j] , zo kan je bepaalde gedeeltes uit de verzameling opvragen en printen. Maar had ergens verwacht dat er een soort van allesomvattende cout << VectorVector; zou zijn waardoor de verzameling in zn geheel meteen in tabelvorm zou worden geprint.
Die is er waarschijnlijk niet ?

[kitao]

Dit wordt meer een algemene vraag, apart van de vorige anders wordt die te lang.
Zelf heb ik geen programmeurs in mijn kennissenkring en als hobbyist ook geen scholing voor gedaan.
Merk nu wel dat ik aan het kopie/plak blokkendoos programmeren ben en eigenlijk puur afgaand van wat er op het output schermpje verschijnt.
Kopie/plak uit voorbeelden die zo weinig mogelijk voor mij nieuwe dingen bevatten en het vinden daarvan kan soms enige tijd duren.
En veel geschuif binnen het programma als het resultaat afwijkt van hetgeen er moet komen.

Met daarbij soms verrassende dingen, zo verwachtte ik dat Vector.at(0) de eerste letter zou geven maar in plaats daarvan werd het eerste woord geprint.
Voorbeeld van bij elkaar geblokt programmaatje uit drie verschillende websites :

code:

/*
4. Schrijf een programma dat een zin vraagt aan de gebruiker, 
alle woorden in de zin stuk-voor-stuk in een vector zet 
en daarna de woorden genummerd onder elkaar op het scherm zet.
*/
#include<iostream>
#include<string>
#include<vector>
#include <sstream>
using namespace std;

string zin;
int y;
vector<string>Vector;

int main()
{
    cout << "schrijf een zin \n\n";
    getline(cin, zin);  
    cout << endl << endl;
    system("pause");
    cout << endl;

    istringstream ss(zin);      // gevonden op http://www.cplusplus.com/faq/sequences/strings/split/
    while (!ss.eof())           // blijf splitten tot einde string
    {
        string x;               // here's a nice, empty string
        getline(ss, x, ' ');    // splits de string op de spaties
    //  cout << x << endl;      // print it out, EVEN IF WE ALREADY HIT EOF
        
        Vector.push_back(x);    // zet iedere aparte split in vector
                                // gevonden op http://www.ronkes.nl/oldprogrammeren/les10.html
        y += 1;                 // y wordt gebruikt als display nummertje voor de woorden

        for (int i = 0; i < Vector.size(); i++) // doorloop vector
                                                // ieder woord krijgt blijkbaar eigen positie in de Vector
        {
            cout << y << " " << Vector.at(i) << endl;   // print het woord op positie i 
            Vector.erase(Vector.begin());               // maak de Vector leeg voor het volgende woord
                                                        // gevonden op http://www.cplusplus.com/reference/vector/vector/erase/
        }
    }
    cout << endl;
    system("pause");
}

met deze output :



Ik vraag me nu af of anderen op deze manier ook programmeren hebben geleerd en of de kopie/plak methode gangbaar gebruik is ?
Zou misschien beter zijn een basis setje 'steentjes' te hebben en dan eerst daarmee wat gaan schuiven voordat er een nieuw setje bij komt ?
Probleem is dat bij deze korte en gratis online cursus er m.i. te weinig steentjes zijn om de oefening mee te voltooien. Iemand die uit ervaring een meer gestructureerde, goedkope (en legale) cursusboek of online tutorial weet , dan hoor ik dat graag.

[ Voor 1% gewijzigd door kitao op 15-01-2019 15:04 . Reden: code iets overzichtelijker gemaakt ]

[.oisyn]

Ik vind je code maar raar. Elke iteratie van de buitenste while ga je een woord toevoegen aan de vector, vervolgens loop je binnen die iteratie over de elementen van de vector en verwijder je de elementen. Je vector bevat dus altijd hooguit maar 1 element.

Die for-lus is ook raar. Je verwijdert steeds het eerste element bij elke iteratie (waardoor het element op plek 1 natuurlijk op plek 0 terecht komt), maar je gebruikt wel steeds i om de vector te indexeren. Dan ga je natuurlijk elementen missen als er daadwerkelijk meerdere elementen in staan.

En waarom verwacht je dat Vector.at(i) het i'de teken teruggeeft? Het is toch een vector van woorden?

[kitao]

.oisyn schreef op dinsdag 15 januari 2019 @ 14:04:

Ik vind je code maar raar.

Elke iteratie van de buitenste while ga je een woord toevoegen aan de vector, vervolgens loop je binnen die iteratie over de elementen van de vector en verwijder je de elementen. Je vector bevat dus altijd hooguit maar 1 element.

Ja, dat vond ik ook.

Maar kan niet alles reproduceren wat ik daarvoor heb geprobeerd.
Kijkend op de output window zag ik dat zonder leegmaken bij iedere while loop er een woord bijkwam.
dus bij while loop 0 werd er 1 Goede geprint
en bij while loop 1 werd er 2 Goede middag geprint etc.
Heb bovendien moeite met het begrip iteratie.

Die for-lus is ook raar. Je verwijdert steeds het eerste element bij elke iteratie (waardoor het element op plek 1 natuurlijk op plek 0 terecht komt), maar je gebruikt wel steeds i om de vector te indexeren. Dan ga je natuurlijk elementen missen als er daadwerkelijk meerdere elementen in staan.

Dat bedoelde ik dus met puur op output window afgaan.
Heb willekeurig ergens een lange zin geplukt, die als invoer geplakt maar toch werd ieder apart woord op nummervolgorde geprint. Had niet het idee dat er iets gemist werd ? Of bedoel je iets anders ?

Moet er wel bij zeggen dat ik mijn uitwerking nog niet met het antwoord heb vergeleken.
http://www.ronkes.nl/oldprogrammeren/antwoorden.html
Maar ja, de volgende twee en laatste lessen hebben geen antwoorden en mede daarom was mijn vraag of iemand nog een goede tutorial kan aanraden.

En waarom verwacht je dat Vector.at(i) het i'de teken teruggeeft? Het is toch een vector van woorden?

niet bij declaratie vector<int>Vector; meen ik ?
heb er zelf als vermoeden maar vector<string>Vector; van gemaakt zonder eigenlijk te weten wat er dan gebeurt.

[.oisyn]

kitao schreef op dinsdag 15 januari 2019 @ 15:24:
[...]


Ja, dat vond ik ook.

Maar kan niet alles reproduceren wat ik daarvoor heb geprobeerd.
Kijkend op de output window zag ik dat zonder leegmaken bij iedere while loop er een woord bijkwam.
dus bij while loop 0 werd er 1 Goede geprint
en bij while loop 1 werd er 2 Goede middag geprint etc.
Heb bovendien moeite met het begrip iteratie.

Omdat je bij ieder woord over de hele vector heenloopt. Waarom loop je niet gewoon pas over de vector heen als je alle woorden hebt verzameld, dus buiten de while loop?

niet bij declaratie vector<int>Vector; meen ik ?

Een vector<int> is een vector van ints. Nu gebruik je een vector van strings. En wat je eraan toevoegt met push_back() is ook een string, namelijk het woord dat je toevoegt.

heb er zelf als vermoeden maar vector<string>Vector; van gemaakt zonder eigenlijk te weten wat er dan gebeurt.

Misschien moet je eerst proberen de code te begrijpen ipv gewoon maar wat bij elkaar copy-pasten

[kitao]

.oisyn schreef op dinsdag 15 januari 2019 @ 15:32:

Misschien moet je eerst proberen de code te begrijpen ipv gewoon maar wat bij elkaar copy-pasten

ja, dat idee had ik ook al
beetje erop los knippen en plakken totdat het output schermpje de gewenste vorm aanneemt is dus niet de juiste methode.
"Snap het dan" helpt daarentegen ook niet veel.
Maar bedankt voor je tips .oisyn ,zal ze morgen nog eens goed doorlezen.

[farlane]

kitao schreef op dinsdag 15 januari 2019 @ 05:58:
[...]
Maar vind het verder nog steeds een raadsel waarom de cursus auteur if (myIndex != string.npos) heeft toegepast want dat compileert bij mij niet.

Weet niet of het kwartje inmiddels gevallen was, maar std::string::npos is een static member van de class string (die in de std namespace leeft).

Static members kunnen met <classname>::<membername> worden aangesproken ( hier dus string::npos ) wat wat mij betreft de cleanste manier is, maar ook via een object van dat type (my_string.npos) wat jij dus doet als je je std::string object 'string' gaat noemen.

Je voelt aan je water dat dat laatste geen goed idee is neem ik aan?

[kitao]

farlane schreef op dinsdag 15 januari 2019 @ 22:33:
Weet niet of het kwartje inmiddels gevallen was, maar std::string::npos is een static member van de class string (die in de std namespace leeft).
Static members kunnen met <classname>::<membername> worden aangesproken ( hier dus string::npos ) wat wat mij betreft de cleanste manier is, maar ook via een object van dat type (my_string.npos) wat jij dus doet als je je std::string object 'string' gaat noemen.
Je voelt aan je water dat dat laatste geen goed idee is neem ik aan?

Dat was om te testen farlane, de auteur gaf namelijk dit in zn antwoord : if (myIndex != string.npos).
maar dat draait bij mij niet, dus was er (tijdelijk) over verbaasd.

.oisyn schreef op dinsdag 15 januari 2019 @ 15:32:
Omdat je bij ieder woord over de hele vector heenloopt. Waarom loop je niet gewoon pas over de vector heen als je alle woorden hebt verzameld, dus buiten de while loop?

Op deze manier bedoel je ?

code:

#include<iostream>
#include<string>
#include<vector>
using namespace std;
string Zin, Zin2;
vector<string>Vec;
int main(){
    cout << "geef zin " << endl;
    getline(cin, Zin);  getline(cin, Zin2);
    Vec.push_back(Zin); Vec.push_back(Zin2); // laad eerst de vector op
    // doe er pas na het opladen bewerkingen mee, zoals bijvoorbeeld ..
    for (int i = 0 ; i < Vec.size() ; ++i)  {
        cout << Vec[i] << endl; }
    system("pause");}

Nog even terugkomend op mijn opmerking dat ik mijn code ook maar vreemd vond, dat was meer in de zin van dat het vast niet de bedoeling was om in het antwoord allerlei dingen erbij te plukken die nog niet behandeld waren in die lessen serie. Voor mij zijn de meeste codes nog hiërogliefen waarvan lastig te zien is of zo'n code elegant of geforceerd is. Heb inmiddels wel het antwoord van de auteur bekeken en deze gecompacteerd

code:

// les 10 oef 4 http://www.ronkes.nl/oldprogrammeren/oefeningen10.html
// les 10 antw 4 http://www.ronkes.nl/oldprogrammeren/antwoorden.html
#pragma warning ( disable : 4786 )  // schakel waarschuwing 4786 uit
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main()
{
    string myZin;       // vraag om invoer
    cout << "Voer een zin in: ";
    getline(cin, myZin);
    vector<string> myWoorden;   // doorloop zin letter voor letter
    int myBegin = 0;
    for (int i = 0; i < myZin.length(); i++)
    {
        if (myZin.at(i) == ' ')     // is dit een spatie?
        {
            string myWoord = myZin.substr(myBegin, i - myBegin);    // ja, haal woord uit zin
            myWoorden.push_back(myWoord);           // sla woord op in vector
            myBegin = i + 1;            // onthoud begin van volgende woord
        }
    }
    myWoorden.push_back(myZin.substr(myBegin, myZin.length() - myBegin));   // voeg laatste woord toe aan vector
    for (int j = 0; j < myWoorden.size(); j++)  // doorloop vector
    {
        cout << j + 1 << ". " << myWoorden.at(j) << endl;       // schrijf woord naar scherm
    }
    cout << endl;   // wacht op enter
    system("pause");
    return 0;
}
#pragma warning ( default: 4786 )   // schakel waarschuwing 4786 weer in

Bij deze heb ik dan vanwege regel 24 e.v. (laatste woord opvegen) wel het gevoel van gekunsteld maar heb nog niet zelf geprobeerd om met de beschikbare 'steentjes' het beter te doen, als dat al mogelijk is, want wil tegelijkertijd ook graag verder met het volgende hoofdstuk.
Dit komt eruit :


Vanwege dubbele spatie een lege lijn op 3. Maar dat gebeurt ook met mijn programmaatje.
Ik merk trouwens op (zonder bijdehand te willen doen) dat de vector in regel 20 ook binnen 2 loops wordt gevuld ?
En nog hartelijk bedankt trouwens voor de moeite die jij en anderen nemen en/of genomen hebben om dit even door te nemen.

O ja nog iets
de #pragma regels (?) op 3 en 33, die kunnen weg, had bij mij tenminste geen invloed.

[farlane]

kitao schreef op woensdag 16 januari 2019 @ 14:23:
[...]
Dat was om te testen farlane, de auteur gaf namelijk dit in zn antwoord : if (myIndex != string.npos).
maar dat draait bij mij niet, dus was er (tijdelijk) over verbaasd.

Dat was me duidelijk, maar de test die je deed gaf (impliciet) aan dat je niet de betekenis ken(t/de) van een static member.

[kitao]

farlane schreef op woensdag 16 januari 2019 @ 18:55:
Dat was me duidelijk, maar de test die je deed gaf (impliciet) aan dat je niet de betekenis ken(t/de) van een static member.

Dat klopt, en ik beheers dat begrip nog steeds niet goed. Static Members of a C++ Class doorgelezen maar op dit moment wacht ik nog even met classes, na wat meer basis komt dat vast nog voorbij neem ik aan.

Kwam vandaag while (cin.good()); tegen en is op zich best te bevatten totdat ik probeerde die op de watchlist te krijgen. Dat lukte maar er kan daarvan geen waarde in beeld worden gebracht ?
Heb twee pagina's doorgelezen, hfdst 1.11 en 1.11a van https://www.learncpp.com/ en hier en daar wat rondgekeken maar ben er op dit punt niet verder mee gekomen.

Visual Studio snip

code:

#include <iostream>
using namespace std;
void main()
{
    int myInput;
    do  
    {
        cin >> myInput;
    } 
    while (cin.good());
    // cin.good() geeft false als de invoer ongeldig is.
    system("pause");
}

Ps/
Liep vervolgens tegen een geskipte cin aan, heeft me drie uur gekost
Fragmentje met oplossing, via http://www.cs.technion.ac...q/istream-and-ignore.html

code:

    cout << "toets b om opnieuw te beginnen \n";
    cin >> d;    // cin doet het hier prima !!!!!!
    if (d == "a")   
    {
        cout << "toets een niet-getal om naar het menu te gaan \n";
        do      
        {
            cout << "geef getal   ";
            cin >> Input; // Input is een Int.
            Som += Input;
            cout << "De som =  " << Som << endl;
        } while (cin.good());   
    }
    cout << "geef je nieuwe keuze : a of b ? \n";
    //  cin >> d;      wordt geskipt ?????????????????

    // Oplossing :
    // How can I get cin to skip invalid input characters?
    // http://www.cs.technion.ac.il/users/yechiel/c++-faq/istream-and-ignore.html
    // #include <limits> moet vermeld staan boven main

    cin.clear();
    cin.ignore(numeric_limits<streamsize>::max(), '\n');
    cin >> d;

Hier stond nog een suggestie maar die deed het niet :

You can only input one word into a cin. Instead, use getline(cin, string name); If it still doesn't work, add a cin.ignore(); before your getline(cin, string name);, like this:
string country;
cout << "Now please enter the country you are in at the moment:\n\n";
cin.ignore();
getline(cin, country);
This will now definitely work.

Waarom dat laatste niet lukt weet ik echter niet.

Ps2/
Mijn vraag over een passende cursus is inmiddels gevonden. Ik had wel iets duidelijker kunnen zijn, ik bedoelde eentje met oefeningen én antwoorden.
Voorlopig kan ik met deze drie verder :

Cursus
http://liacs.leidenuniv.nl/~kosterswa/lst/lst.pdf
http://liacs.leidenuniv.nl/~kosterswa/lst/
antwoorden
http://liacs.leidenuniv.nl/~kosterswa/lst/uitw.txt

Video Cursus
https://github.com/TPayne...ee/master/LLCPP_Solutions
Let's Learn C++ ~ Basics: 1 of 14
YouTube: Let's Learn C++ ~ Basics: 1 of 14 ~ Visual Studio Setup + My First ...

Vampire Studios (snelcursus, zonder oef en antw)
http://members.chello.nl/~s.pampiermole/index.html

en
http://www.ronkes.nl/oldprogrammeren/index.html

[ Voor 53% gewijzigd door kitao op 18-01-2019 02:26 ]

[kitao]

Mijn volgende vraag is hopelijk iets uitdagender voor de gevorderden of pro's

Kwam onderstaande functie tegen in hfdst. 3.3 van http://liacs.leidenuniv.nl/~kosterswa/lst/lst.pdf
Is lesmateriaal dat nogal grote stappen neemt en gaat nu over call-by-value en call-by-reference.
Dit is de code :

C++:

void Alias (int r, int & s ) {
int t;
t = 3;
r = r + 2;
s = s + r + t;
t = t + 1;
r = r - 3;
cout << r << s << t << endl;
} 
int main ( ) {
int t = 12;
Alias (t,t);
cout << t << endl;
return 0;
}

Dit is de functie : void Alias(int r, int s) { }
De bedoeling was om na te gaan wat er gebeurt met het toevoegen van een &.
Er zijn dan vier mogelijkheden
1. void Alias(int r , int s)
2. void Alias(int & r , int s)
3. void Alias(int r , int & s)
4. void Alias(int & r , int & s)

Vanuit main wordt deze functie aangeroepen met Alias (t,t);
De 'return' van functie Alias in main wordt resp.
1. geen 'return' , t main blijft t main
2. t in main wordt r
3. t in main wordt s
4. t in main wordt ...... r of s ? (<<<<< dit is mijn vraag)

Is voor mij niet te zien en weet ook niet hoe dit zichtbaar te maken op dit moment.
Terwijl ik aanneem dat r en s toch aparte geheugenlocaties hebben.

Hieronder staat mijn test code voor wie het zelf wil nagaan :

C++:

#include <iostream> 
using namespace std;

void Alias(int  r, int  s) {
    cout << "Alias(int r, int s)    " << endl << endl;
    int t;
    t = 3;
    r = r + 100;
    cout << "Tussenresultaten in Alias \n\n Ar = " << r;
    cout << "    As = " << s;
    s = s + r + t;
    cout << "    Ar = " << r;
    cout << "    As = " << s;
    t = t + 1;
    cout << "    At = " << t;
    r = r - 10;
    cout << "    Ar = " << r ;
    cout << "    As = " << s;
    s = s + 300;
    cout << "    Ar = " << r;
    cout << "    As = " << s << endl << endl;
    cout << "Eindresultaat van Alias \n\n  " ;

    cout << "Ar , As , At    respectievelijk  =  " << r << "\t" << s << "\t" << t << endl << endl;
    
   // return 0;

}

int main() {
    int t = 20;
    Alias(t, t);
    cout << "Eindresultaat van t in main \n\n  ";

    cout << "Main t =  " <<  t << endl;

    cout << endl << endl;
    system("pause");
    return 0;
}

Ik wou de testcode eigenlijk onder een spoiler zetten om de post (visueel) te verkorten maar dat gaat niet geloof ik ?

Eerder had ik het over de 'return' van de functie Alias.
Maar weet niet of dit terecht is, geeft namelijk ''return value does not match the function type c++''.

[Daos]

In geval 4 zijn r en s allebei een referentie naar t in main. Verander je r, dan verandert t in main en dus ook s. Het is een en hetzelfde plekje geheugen.

Probeer maar eens:

C++:

#include <iostream> 
using namespace std;

void Test(int &r, int &s) {
    r = 10;
    cout << s << endl;
}

int main() {
    int t = 20;
    Test(t, t);

    system("pause");
    return 0;
}

[kitao]

Daos schreef op zaterdag 19 januari 2019 @ 23:06:
In geval 4 zijn r en s allebei een referentie naar t in main. Verander je r, dan verandert t in main en dus ook s. Het is een en hetzelfde plekje geheugen.

Probeer maar eens:

C++:

#include <iostream> 
using namespace std;

void Test(int &r, int &s) {
    r = 10;
    cout << s << endl;
}

int main() {
    int t = 20;
    Test(t, t);

    system("pause");
    return 0;
}

Ok, dus mijn aanname van verschillende geheugenplekken was verkeerd, ik ging aanvankelijk uit van 4 geheugenplekken, namelijk t main , t Alias , r Alias en s Alias.

En ik kwam pas na het plaatsen van mijn vraagpost op het idee om de variabelen op de watchlist te zetten.

Ben er inmiddels meermaals doorheen gestapt en zie dan het volgende :
Variabele t blijft zowel in main als in Alias hetzelfde (hetgeen betekent dat ik de scope van een lokale variabele minder goed begrepen heb als gedacht, zoals hier een voorbeeld daarvan :
https://cscircles.cemc.uwaterloo.ca/11b-variable-scope-nl/
maar dat is ander onderwerp)

Want de beide t's bewegen met elkaar mee.

Variabelen r en s zijn wel verschillend totdat dit (int &r, int &s) wordt opgenomen in de code.
Pas dan worden r en s één geheugenplaats begrijp ik eruit.

Hartelijk dank

[ Voor 4% gewijzigd door kitao op 20-01-2019 00:19 . Reden: typ ]

[Daos]

Dat in jouw voorbeeld bij (int &r, int &s) r en s naar hetzelfde geheugenplekje verwijzen komt door de aanroep Alias(t, t). r en s zijn dan allebei een referentie naar t in main.

Als je zoiets doet:

C++:

#include <iostream> 
using namespace std;

void Test(int &r, int &s) {
    r = 10;
    cout << s << endl;
}

int main() {
    int t = 20;
    int u = 30;
    Test(t, u);

    system("pause");
    return 0;
}

dan verwijst r naar t en s naar u. Verander je r in de functie Test, dan verandert s deze keer niet omdat die naar een ander plekje in het geheugen verwijst; namelijk u in main.

edit:
Ik denk dat je het principe van references nog niet helemaal begrijpt. Een reference heeft geen eigen opslag. Het is een verwijzing naar een andere plek. (Onder de motorkap wordt er wel wat opgeslagen: het adres van die andere plek, maar daar kan je niet bijkomen vanuit je programma)

C++:

// reserveert in het geheugen ruimte voor een int en stopt daar 10 in.
int a = 10;

// maakt een verwijzing naar a; b heeft geen eigen opslag.
int &b = a;

// omdat b naar a verwijst, verandert a ook naar 20.
b = 20;

Parameters bij functies werken op ongeveer dezelfde manier:

C++:

void TestValue(int x) {
    // x heeft eigen opslag in het geheugen. De waarde wordt er in gekopieerd 
    // bij het aanroepen van de functie.    
    x = 10;
}

void TestReference(int &x) {
    // x is een verwijzing naar de variabele die meegegeven wordt bij het 
    // aanroepen van de functie; x heeft geen eigen opslag.
    x = 10;
}

[ Voor 43% gewijzigd door Daos op 20-01-2019 01:17 ]

[kitao]

Daos schreef op zondag 20 januari 2019 @ 00:40:
Dat in jouw voorbeeld bij (int &r, int &s) r en s naar hetzelfde geheugenplekje verwijzen komt door de aanroep Alias(t, t). r en s zijn dan allebei een referentie naar t in main.

Als je zoiets doet:

C++:

#include <iostream> 
using namespace std;

void Test(int &r, int &s) {
    r = 10;
    cout << s << endl;
}

int main() {
    int t = 20;
    int u = 30;
    Test(t, u);

    system("pause");
    return 0;
}

dan verwijst r naar t en s naar u. Verander je r in de functie Test, dan verandert s deze keer niet omdat die naar een ander plekje in het geheugen verwijst; namelijk u in main.

edit:
Ik denk dat je het principe van references nog niet helemaal begrijpt. Een reference heeft geen eigen opslag. Het is een verwijzing naar een andere plek. (Onder de motorkap wordt er wel wat opgeslagen: het adres van die andere plek, maar daar kan je niet bijkomen vanuit je programma)

C++:

// reserveert in het geheugen ruimte voor een int en stopt daar 10 in.
int a = 10;

// maakt een verwijzing naar a; b heeft geen eigen opslag.
int &b = a;

// omdat b naar a verwijst, verandert a ook naar 20.
b = 20;

Parameters bij functies werken op ongeveer dezelfde manier:

C++:

void TestValue(int x) {
    // x heeft eigen opslag in het geheugen. De waarde wordt er in gekopieerd 
    // bij het aanroepen van de functie.    
    x = 10;
}

void TestReference(int &x) {
    // x is een verwijzing naar de variabele die meegegeven wordt bij het 
    // aanroepen van de functie; x heeft geen eigen opslag.
    x = 10;
}

Ik denk dat je het principe van references nog niet helemaal begrijpt.
Een reference heeft geen eigen opslag.
Het is een verwijzing naar een andere plek.

Dat verklaart al veel, bedankt.
Het klopt, ik ben nog niet zover. De pdf hfdstk 3.3 waar ik het uithaalde verwijst naar inhoud van een boek dat ik niet heb. Is misschien beter om dat lesmateriaal even te laten voor wat het is, maakt te grote stappen.
Heel lang geleden ben ik ooit eens met deze bezig geweest

Z80

Vandaar mijn interesse welke geheugenadres, r of s, nu zn inhoud overdroeg aan t in geval &r én &s.
Ook na plaatsing op de watchlist was dit niet te zien.
Maar ik begrijp nu beter wat je bedoelt , het zijn referenties en heb op dit moment even geen andere vragen, want dit verklaart dan waarschijnlijk ook meteen waarom het verhaal van de scope van een lokale variabele (t in main en t in Alias) niet op ging.

De eerder genoemde video serie ben ik aan het volgen en dat gaat beter zonder hiaten.

[kitao]

Vervolg op mijn vorige post, omdat er wat nieuws bij zit geen edit toegepast.
@Daos
Ben inmiddels tegen het onderwerp aangelopen, call by value, pointer en reference met een paar voorbeelden hier https://www.tutorialspoint.com/cplusplus/cpp_functions.htm. Echt helemaal helder is het nog niet en vereist nog wat oefeningen, waar deze video over reference goed van pas komt, maar het vorige draadje was wel aanleiding om te kijken naar machinetaal. Kwam daarbij nasm en masm tegen. Nasm heeft een mooie tutorial op dezelfde site maar vereist Linux zover ik begrepen heb. Had eerder Mint op een lap staan, heb die achteraf van de partitie verwijderd en lap ligt nu in coma dus heb daar van afgezien en voor masm gekozen.

Voor wie dat als beginner ook wil proberen met Visual Studio raad ik een installatie video van professor Hank aan :

YouTube: Assembly Tutorial: Compiling Your First Assembly Program Using Visu...

In zijn afspeellijsten zijn zover ik gezien en doorlopen heb echter maar 6 vervolgvideo's over masm.
Zoeken binnen dit forum op nasm en masm levert wel resultaten maar zijn minstens een jaar oud.
Die programmeertalen schijnen dus niet erg te leven. Weet iemand daar misschien een reden voor ?

[ Voor 3% gewijzigd door kitao op 22-01-2019 23:45 . Reden: video over reference toegevoegd ]

[farlane]

Que? Wat wil je leren dan, C++ of assembly? Wat is de moeiijkheid waar je tegenaan loopt?

[kitao]

farlane schreef op dinsdag 22 januari 2019 @ 23:19:
Que? Wat wil je leren dan, C++ of assembly? Wat is de moeilijkheid waar je tegenaan loopt?

Ik zat te denken om ze gelijk op te laten lopen, net als in de schoolbanken, het ene uur rekenen en het andere geschiedenis. Maar met mijn vraag bedoelde ik eigenlijk of het geen onnodige moeite is om een beter begrip te krijgen van C++ onder de motorkap en waarom er zo weinig belangstelling voor lijkt te zijn. Want als ik erop zoek dan zie ik het eerste topic over Nasm ergens in feb 2016 en Masm was nog verder terug geloof ik (afgezien van Devschuur). En op internet vergeleken met C++ is het lesmateriaal ook lang niet zo vers en niet zo veel heb ik het idee. Een echt technische vraag heb ik nu niet, mijn vorige post was ook bedoeld dat als een bezoeker zoekt binnen dit forum op masm dat er dan een m.i. goede en actuele, maar beknopte instructie video-serie is om mee te starten.

@Radiant hierna
Ik heb na een tijd zoeken (en vergelijken) inmiddels iets gevonden waar ik voorlopig mee vooruit zou kunnen. Heb nog niet helemaal getest of het goed gaat draaien op mijn versie van ide, vs17, maar het lijkt wel dezelfde syntax te hebben. Is ook een serie van video's , welke methode mij meer schijnt te liggen als tekstmateriaal. Eerste twee video's zijn geluids-kwalitatief pet maar wordt daarna stuk beter.

YouTube: x64 Assembly and C++ Tutorial 0: Setting Up x64 Assembly in Visual S...

Bedankt voor je tips, zal ze eens opzoeken.

[ Voor 27% gewijzigd door kitao op 23-01-2019 10:20 ]

[Radiant]

Assembly is gewoon niet zo veelgebruikt om in te ontwikkelen, en met een goede reden.

Persoonlijk heb ik assembly geleerd door juist te gaan reverse engineeren en (binary) CTFs te doen in mijn vrije tijd, daar leer je tegelijkertijd assembly maar ook secure coding, exploits schrijven, de Windows/Linux API van, etc. Er is ook een hoop goede literatuur over (Reverse Engineering for Beginners van Yurichev, RE101 van Malware Unicorn, Practical Malware Analysis, Azeria Labs (voor ARM), etc).

[farlane]

kitao schreef op woensdag 23 januari 2019 @ 00:04:
Ik zat te denken om ze gelijk op te laten lopen, net als in de schoolbanken, het ene uur rekenen en het andere geschiedenis. Maar met mijn vraag bedoelde ik eigenlijk of het geen onnodige moeite is om een beter begrip te krijgen van C++ onder de motorkap en waarom er zo weinig belangstelling voor lijkt te zijn.

De basics zijn handig om te kennen (voor alle talen) omdat je dan bepaalde concepten sneller kunt plaatsen, maar daar hoef je geen x86 assembly voor te kunnen.

Assembly leren als je het concept pointers/references voor jezelf niet duidelijk krijgt, tja ...... /shrug

[kitao]

farlane schreef op woensdag 23 januari 2019 @ 19:00:

De basics zijn handig om te kennen (voor alle talen) omdat je dan bepaalde concepten sneller kunt plaatsen, maar daar hoef je geen x86 assembly voor te kunnen.

Assembly leren als je het concept pointers/references voor jezelf niet duidelijk krijgt, tja ...... /shrug

ik kwam nog een ander forum tegen, zit in mapje
A protected forum where programmers learning assembler can ask questions in a sensible and safe atmosphere without being harassed or insulted. This is also targetted at experienced programmers from other languages learning assembler that don't want to be treated like kids.

zie ook http://masm32.com/board/index.php

Vind prima dat je reageert, krijg ik tenminste niet het idee tegen een muur aan te lullen , maar om dan te beweren dat ik hazen hoeken sla omdat ik het niet onder de knie krijg, is allicht iets een te snelle conclusie.
Voor mij is het hobby, maakte op mn 12e een radiootje van een wc-rol kokertje en ben een aantal jaren daarna verder gegaan met weerstand , fietslampje en batterij. En voor je het weet ben je toe aan de 1e chip met 3 and poortjes. En daarna is het geen electronica meer maar zit je codes bij elkaar te schrapen. Waaronder machinetaal, zoals ook af te leiden was van mijn vorige post over de z80.

Dus heb wel enig idee wat er aan de gang is, ben niet helemaal nieuw op deze e-wereld. Probleem met mij is dat ik steeds mn aandacht verlies en er gaten vallen van een jaar of 5. Niet helemaal stilstand maar andere interesses, maar wel als gevolg dat ik vrijwel vanaf 0 weer moet herbeginnen.

Een prof-programmeur zal ik nooit worden maar heb best wel enige vooruitgang geboekt met references.
Niet dat ik het perse heb opgezocht nav de vorige post maar omdat het voorbij kwam in mijn voorgenomen te volgen websites. (stuk of 4 inmiddels, incl assembler)
Kan echter geen huizen bouwen binnen een dag.
En word ook een dagje ouder dus alles is niet zo scherp meer.

#Radiant, zie edit vorige post

[ Voor 5% gewijzigd door kitao op 23-01-2019 22:37 . Reden: typ ]

[farlane]

kitao schreef op woensdag 23 januari 2019 @ 21:30:
[...]
Vind prima dat je reageert, krijg ik tenminste niet het idee tegen een muur aan te lullen , maar om dan te beweren dat ik hazen hoeken sla omdat ik het niet onder de knie krijg, is allicht iets een te snelle conclusie.

Je lijkt te impliceren dat ik je mentale capaciteiten in twijfel trek. Dat is in zijn geheel niet aan de orde.

Ik trek wel je leermethode in twijfel. Je hebt vragen over references in C++ en dwaalt af naar assembly, dat lijkt mij niet efficient.

Probleem met mij is dat ik steeds mn aandacht verlies en er gaten vallen van een jaar of 5.
Niet helemaal stilstand maar andere interesses

Case in point

[kitao]

farlane schreef op woensdag 23 januari 2019 @ 22:37:

Je lijkt te impliceren dat ik je mentale capaciteiten in twijfel trek. Dat is in zijn geheel niet aan de orde.

Ik trek wel je leermethode in twijfel. Je hebt vragen over references in C++ en dwaalt af naar assembly, dat lijkt mij niet efficient.

Case in point

ok,
het is waar, ik vroeg of erbij nemen van assembly geen verspilde moeite was
mov aex, a8h of int a = 1; verbeteren beiden geen begrip, dat is wel zo.
hoop enkel dat c++ (of andere talen) niet al te abstract raken en iedere connectie met de 'chip' vervaagt.
ben momenteel niet aan het solderen of knopen, maar wil het electronica deel ook niet helemaal uit het zicht raken.

[farlane]

"Verspilde moeite" is het sowieso niet als je het leuk vind; je leert wat en dat is altijd nuttig.

Als je doel is om C++ te leren programmeren is het dat wel, bijna.

Bij C (en in misschien wat mindere mate C++) sijpelt nog genoeg van de machine door (leaky abstractions anyone) om niet de verbinding met die hardware te laten 'vervagen' als je het mij vraagt, zeker als je het combineert met microcontrollers.

Denk je zelf van niet ook prima, houd het dan lekker bij assembly en voel je niet bezwaard

[.oisyn]

Assembly leren om references te leren begrijpen lijkt mij ook niet bijzonder nuttig. Het zal je ongetwijfeld de gewenste inzichten geven, maar dat leidt op dit moment gewoon teveel af.

Wat je misschien beter kan doen is references even wegleggen en je concentreren op pointes. Onder water zijn ze exact hetzelfde, alleen zijn de operaties die je ermee doet veel explicieter. En voor de low-level inzichten kun je ook gewoon de debugger erbij pakken. Open een memory view in Visual Studio en ga kijken naar hoe variabele in het geheugen staan.

Als je pointers onder de knie hebt is de stap naar references een hele kleine; het is niets anders dan syntactische suiker om niet steeds die * (dereference) en & (adress of) operatoren te hoeven gebruiken.

[kitao]

farlane schreef op woensdag 23 januari 2019 @ 22:55:
"Verspilde moeite" is het sowieso niet als je het leuk vind; je leert wat en dat is altijd nuttig.

Als je doel is om C++ te leren programmeren is het dat wel, bijna.

Bij C (en in misschien wat mindere mate C++) sijpelt nog genoeg van de machine door (leaky abstractions anyone) om niet de verbinding met die hardware te laten 'vervagen' als je het mij vraagt, zeker als je het combineert met microcontrollers.

Denk je zelf van niet ook prima, houd het dan lekker bij assembly en voel je niet bezwaard

Dat is zo, gaat natuurlijk ook om het plezier en dat heb ik er momenteel wel in.
En afgezien van basic op de C64 ben ik idd via micro's bij programmeren beland , en gestrand eigenlijk. Was eens bezig met een rf-kaart en daar hing best een complexe code aan vast en om enigzins dingen in te kunnen stellen (hetgeen pas lukte na andere Tweakers te vragen) is het wel handig om meer kennis vh programma te hebben. De mC ligt in de kast maar kan ook vrij uitgebreid virtueel (simulatie) gebruikt worden zag ik.

.oisyn schreef op woensdag 23 januari 2019 @ 23:24:
Assembly leren om references te leren begrijpen lijkt mij ook niet bijzonder nuttig. Het zal je ongetwijfeld de gewenste inzichten geven, maar dat leidt op dit moment gewoon teveel af.

Wat je misschien beter kan doen is references even wegleggen en je concentreren op pointers. Onder water zijn ze exact hetzelfde, alleen zijn de operaties die je ermee doet veel explicieter. En voor de low-level inzichten kun je ook gewoon de debugger erbij pakken. Open een memory view in Visual Studio en ga kijken naar hoe variabelen in het geheugen staan.

Als je pointers onder de knie hebt is de stap naar references een hele kleine; het is niets anders dan syntactische suiker om niet steeds die * (dereference) en & (adress of) operatoren te hoeven gebruiken.

Ok, goede tips, bedankt. Ipv de volgende stap nemen eerst nog even blijven concentreren op pointers. De memory view was mij tot nu toe onbekend dus dat is meteen mooi meegenomen. Ik had het eerder over een video serie van Hank Stalica en van Creel. Via de eerste heb ik masm opgestart maar nu blijkt dat ik bij de tweede voorbeelden krijg met mov rax maar dat pakt niet bij mij, wel mov eax.



Heb in visual het keuze menu links naast de startknop Loc Win Debugger al van x86 op x64 gezet maar leek niet veel verbetering daarin te geven.

Ps/
Bovenstaande is inmiddels opgelost, in dat zelfde keuze menu veldje zit een config manager, in video 0 vd serie meer uitleg (rond min 5).
Bovenstaand plaatje komt van deze web, gaat over mixen van C en Assembly
https://picoledelimao.git...27/mixing-assembly-and-c/
Zit nog een verwijzing in naar een online pdf, ziet er ook best goed uit
http://download-mirror.sa...GroundUp-1-0-booksize.pdf

[ Voor 16% gewijzigd door kitao op 24-01-2019 10:56 ]

[kitao]

In welk jaar leven wij ?

Was aan het oefenen met het volgende :
https://erlerobotics.gitb...s/exercises_pointers.html

code:

int n; 
  cout<<"Enter number of values:";
  cin>>n;

  cout<<"Enter values in array:\n";
  int arr[n];
  for(i=0;i<n;i++) {

   cin>>arr[i];
  }

dit geeft een error op lijn int arr[n];

Error (active) E0028 expression must have a constant value

Via deze kunnen oplossen met

code:

int n;
cin >> n;
int *array = new int[n];

https://stackoverflow.com...create-an-array-of-size-n

Maar kwam (ook elders) opmerkingen tegen dat het per C++ versie verschilt , en zelfs per compiler, of er wel of niet VLA's zijn toegestaan.
https://www.geeksforgeeks...length-arrays-in-c-and-c/

Een microsoft overzicht ...
https://support.microsoft...ported-visual-c-downloads
.. zegt dat Visual Studio 2013 versie C++ 12.0 heeft, achter VS15 staat niks, maar dat is volgens mij versie 14.0 en achter VS17 staat ook niks (heb zelf de community versie). Welke C++ versie is dat ?

En vallen dit soort dingen vaker te verwachten bij meerdere commando's of is deze VLA (variabele lengte array) een uitzondering ?

[farlane]

kitao schreef op vrijdag 25 januari 2019 @ 10:27:
In welk jaar leven wij ?

Was aan het oefenen met het volgende :
https://erlerobotics.gitb...s/exercises_pointers.html

code:

int n; 
  cout<<"Enter number of values:";
  cin>>n;

  cout<<"Enter values in array:\n";
  int arr[n];
  for(i=0;i<n;i++) {

   cin>>arr[i];
  }

En vallen dit soort dingen vaker te verwachten bij meerdere commando's of is deze VLA (variabele lengte array) een uitzondering ?

VLA's zijn geen onderdeel van C++, maar wel C(99). Een van de aspecten van C die niet zijn overgenomen in de C++ standaard. Ze worden wel door de GCC (en misschien andere compilers) als extensie ondersteund in C++

[ Voor 6% gewijzigd door farlane op 25-01-2019 22:14 ]

[.oisyn]

Die Visual Studio versies die je noemt hebben niets met de C++ standaard te maken, het zijn gewoon de interne versienummers van VS zelf.

Wat C++ zelf betreft zijn er een aantal "versies": 98, 03, 11, 14 en 17. Over het algemeen doen de grote compilerbouwers allemaal wel hun best om zoveel mogelijk van de recentste standaard te implementeren, en zelfs al gedeeltes van de draft van de aankomende standaard (C++20).

VLA's staan echter in geen van die standaarden, zoals farlane ook zegt. Typisch gebruik je in deze situatie gewoon een std::vector<int>

[ Voor 6% gewijzigd door .oisyn op 25-01-2019 23:11 ]

[kitao]

.oisyn schreef op vrijdag 25 januari 2019 @ 23:10:
Die Visual Studio versies die je noemt hebben niets met de C++ standaard te maken, het zijn gewoon de interne versienummers van VS zelf.

oeps
de nummers lijken op elkaar, zelfde bereik ongeveer van 10 tot 15.

Wat C++ zelf betreft zijn er een aantal "versies": 98, 03, 11, 14 en 17. Over het algemeen doen de grote compilerbouwers allemaal wel hun best om zoveel mogelijk van de recentste standaard te implementeren, en zelfs al gedeeltes van de draft van de aankomende standaard (C++20).

Ik heb het nog eens nagekeken maar ben ergens in een doolhof beland geloof ik.
Heb mijn msvc begin januari op de pc gezet, maar als ik cout << cplusplus; opvraag krijg ik 199711 hetgeen met C98 zou overeenkomen. Zag ook nog dingen over zwitchen tussen versies maar dat durf ik niet.
Ik laat het hier bij en wacht gewoon op de volgende error melding als iets niet compileert.

https://stackoverflow.com...-default-for-a-c-compiler
MSDN: MSVC now correctly reports __cplusplus | Visual C++ Team Blog

farlane schreef op vrijdag 25 januari 2019 @ 22:12:
VLA's zijn geen onderdeel van C++, maar wel C(99). Een van de aspecten van C die niet zijn overgenomen in de C++ standaard. Ze worden wel door de GCC (en misschien andere compilers) als extensie ondersteund in C++

VLA's staan echter in geen van die standaarden, zoals farlane ook zegt. Typisch gebruik je in deze situatie gewoon een std::vector<int>

De vector waarmee dit avontuur begon
Heb mij iets verder verdiept in pointers zoals jij aanraadde, met iets van twee uur video's en een paar webs.
Dacht er inmiddels een redelijk begrip van te hebben totdat ik bij dynamisch geheugen aankwam. Ik bedoel niet dat ik helemaal niet weet waar hij het over heeft maar ik raak het pad kwijt door teveel variabelen. Zou eigenlijk alles op papier moeten zetten met adres en inhoud en pointer die wijst van de ene naar de andere. Nadeel is dan wel dat het uren gaat kosten. Soort van animatie zou nog beter zijn, met watch stappen en memory geeft ook niet direkt het hele plaatjes overzicht vind ik, hoewel ik me nog niet laat ontmoedigen. Hieronder staat de code en een link naar de video waar ik het over heb. De code heb ik zonder commentaar regels overgetypt vanuit de video.
Bedankt voor de antwoorden.

code:

// C++ video serie Hank Stalica // video 5
// https://www.youtube.com/watch?v=FpGgXO0a6T4&index=5&list=PLaatXkJEXKyK7-ng1Fo8qOBJ9iqFJFrV_
// TOETS -99 OM PROG TE STOPPEN
#include <iostream>  
using namespace std;
int *expand(int*, int, int&);
void print(int*, int);
int main(){
    int *oldarr = 0; int length = 0; int input;
    do  {
        cout << "Enter an integer :   ";
        cin >> input;
        oldarr = expand(oldarr, input, length);
        print(oldarr, length);
    } while (input != -99);
    delete[] oldarr;
    oldarr = 0;
    cout << endl << endl;
    system("pause");
    return 0;}
int *expand(int* oldarr, int newvalue, int& length){
    int *newarr = new int[length + 1];
    for (int i = 0; i < length; i++)
        newarr[i] = oldarr[i];
    newarr[length] = newvalue;
    delete[] oldarr;
    length++;
    return newarr;}
void print(int* arr, int length){
    for (int i = 0; i < length; i++)
        cout << arr[i] << "   "; cout << endl;
}

[farlane]

http://www.cplusplus.com/doc/tutorial/pointers

[kitao]

farlane schreef op zaterdag 26 januari 2019 @ 11:57:
http://www.cplusplus.com/doc/tutorial/pointers

Bedankt Farlane, goeie tip.
Ik volg die hoofdstukjes, ben nu bij Hfdst 3. Program structure 3.1 Statements and flow control.
Pointers is een klein stukje verderop, zie index.
Deze serie bekijk ik ook ... https://www.tutorialspoint.com/cplusplus/cpp_pointers.htm .. hoewel oppervlakkiger, maar soms kom je dan iets tegen wat bij de eerste niet werd vermeld.

Ps/
deze vid is nog iets pittiger als de vorige, meer voor gevorderden en goeie recente kwaliteit video.
en wrs hebben de gevorderden deze zelf al ontdekt.
YouTube: What Are Pointers? (C++)
heb het nog niet nagespeeld maar zag wel handige dingen zoals slepen van watch naar memory.

[ Voor 24% gewijzigd door kitao op 26-01-2019 18:18 . Reden: Ps ]

[kitao]

Bovenstaande video inmiddels aan het na-apen.
Op minuut 10:52 kwam ik deze voor mij onbekende notatie tegen :
cout << (int) pointer;
Dit bleek na wat proberen hetzelfde te zijn als cout << pointer; met als enige verschil dat de eerste de waarde in dec geeft en de ander in hex.
Of heeft dit nog andere gevolgen ?

Volgende wat ik me afvroeg is hoe dan het opgeslagen adres in de pointer als oct uit te printen.
Zoeken op cout << (int) pointer gaf nog niet veel resultaat.
Zoeken op cout << oct << pointer gaf o.a. het resultaat dat onderin de code te vinden is (cplusplus reference).
Bij uitvoering van het programma zie ik bij regel 11 echter geen oct getal maar een hex getal verschijnen, vandaar de "????".

Ik veronderstel dat via een omweg het opgeslagen adres in de pointer wel als oct geprint kan worden, door deze bijvoorbeeld op te slaan in een niet-pointer variabele.
Maar vraag me af waarom het niet gewoon direkt kan en 'aparte trucjes' zoals (int)pointer moeten worden toegepast om een dec-getal te krijgen terwijl er zover ik weet geen 'trucje' voor oct is ?

code:

/*Pointers video javidx9 ---- minuut 10:51
https://www.youtube.com/watch?v=iChalAKXffs&t=2s
*/
#include <iostream>  
using namespace std;
int main() {
    int SomeArray[10];
    int *pointer10 = &SomeArray[10];
    cout << "(int)pointer10     =  " << (int)pointer10 << endl;
    cout << "pointer10          =  "  << pointer10 << endl;
    cout << "oct << pointer10   =  " << oct << pointer10 << "   (??????) " << endl << endl << endl;
    cout << "The difference between (int)pointer10 - pointer10" ;
    cout << " geeft een error bij compilen" << endl << endl;
    cout << "The difference between pointer10 - pointer10           =   " ;
    cout << pointer10 - pointer10 << endl << endl;
    cout << "The difference between (int)pointer10 - (int)pointer10 =   ";
    cout << (int)pointer10 - (int)pointer10 << endl;
    cout << endl << endl;
    cout << "Verschil met cout << oct volgens http://www.cplusplus.com/reference/ios/oct/ " << endl << endl;
    /*
    http://www.cplusplus.com/reference/ios/oct/ 
    */
    int n = 30;
    cout << "int n = 30"  << endl;
    cout << "dec n geeft :   " << dec << n << '\n';
    cout << "hex n geeft :   " << hex << n << '\n';
    cout << "oct n geeft :   " << oct << n << '\n';
    cout << endl << endl; system("pause");  return 0;}

[Radiant]

kitao schreef op zondag 27 januari 2019 @ 12:23:
Bovenstaande video inmiddels aan het na-apen.
Op minuut 10:52 kwam ik deze voor mij onbekende notatie tegen :
cout << (int) pointer;
Dit bleek na wat proberen hetzelfde te zijn als cout << pointer; met als enige verschil dat de eerste de waarde in dec geeft en de ander in hex.
Of heeft dit nog andere gevolgen ?

Dat heet een cast. Je verandert het type van pointer (int *) naar int. Pointers worden normaliter geformat als hex als je ze uitprint, integers worden geformat als decimaal. Gevolg van de cast is dus dat de pointer een integer wordt, gevolg daarvan is weer de andere formatting.

[.oisyn]

Een ander euvel is dat een pointer mogelijk niet in een int past (typisch in 64 bits applicaties). Een intptr_t is een integer type die gegarandeerd groot genoeg is voor een pointer.

[ Voor 9% gewijzigd door .oisyn op 27-01-2019 14:42 ]

[Matis]

.oisyn schreef op zondag 27 januari 2019 @ 14:41:
Een ander euvel is dat een pointer mogelijk niet in een int past (typisch in 64 bits applicaties). Een intptr_t is een integer type die gegarandeerd groot genoeg is voor een pointer.

Ik ben het met je eens dat het voor de semantiek beter is om het juiste type (typedef) te gebruiken, maar heeft een int per definitie niet woordbreedte van de architectuur? Al krijg je dan mogelijk negatieve getallen als je het als decimaal afdrukt.
Is een uintptr_t dan niet "beter"?

[.oisyn]

Ik zeg net letterlijk dat dat niet zo is

Op 64 bits Linux en Windows is een int nog steeds 32 bits.

[ Voor 41% gewijzigd door .oisyn op 27-01-2019 16:23 ]

[kitao]

Radiant schreef op zondag 27 januari 2019 @ 14:03:
Dat heet een cast.
Je verandert het type van pointer (int *) naar int. Pointers worden normaliter geformat als hex als je ze uitprint, integers worden geformat als decimaal. Gevolg van de cast is dus dat de pointer een integer wordt, gevolg daarvan is weer de andere formatting.

Ik kwam het tegen ja, ca. kwartier later noemde hij dat. Bij gewoon kijken viel het me niet op, pas met nabouwen (dus met video snelheid op 0.75, telkens pauzeren, terugspoelen etc.) hoorde ik dat de (int) een cast is. Later eens kijken of ik met dat trefwoord meer kan vinden.
Nog een handig iets gezien, shift+alt+pijltjestoetsen kun je kolommen in een code blok selecteren.
Vanaf ca. minuut 18 kon ik het niet zo best meer volgen, dat werd echt na-apen. Objects en subobjects en unique-pointers en smart-pointers allemaal nog niet gehad.

.oisyn schreef op zondag 27 januari 2019 @ 14:41:
Een ander euvel is dat een pointer mogelijk niet in een int past (typisch in 64 bits applicaties). Een intptr_t is een integer type die gegarandeerd groot genoeg is voor een pointer.

Zal die gelijk met cast nog eens opzoeken dan, tnx.

[MartenBE]

kitao schreef op maandag 28 januari 2019 @ 01:55:
Vanaf ca. minuut 18 kon ik het niet zo best meer volgen, dat werd echt na-apen. Objects en subobjects en unique-pointers en smart-pointers allemaal nog niet gehad.

Als je moeite hebt met gewone pointers, dan wacht je best even met smartpointers. Die vereisen immers kennis van copy vs move en ownership van objecten en dat is op dit moment nog wat te ver gegrepen denk ik.

Wat wij doen in de opleiding is eenmaal ze wat met pointers vertrouwd worden om ze enkele datastructuren te laten maken. Meestal is dit een (enkelvoudige of dubbele) gelinkte lijst met een constructor/destructor, voegtoe en verwijder functie. Als je begint met pointers is het wel een tijdje spartelen en vloeken, maar eenmaal het je lukt om in elkaar te steken, heb je wel een goede brok inzicht in pointers en new/delete enzo. Je vind er ook veel over op het internet: maak wel de code echt zelf, het spartelen is hetgeen wat je het meest inzicht gaat geven. Later als je meer van C++ kent, kan je dan de pointers omzetten naar smartpointers ofzo.

[kitao]

MartenBE schreef op maandag 28 januari 2019 @ 18:40:

Als je moeite hebt met gewone pointers, dan wacht je best even met smartpointers. Die vereisen immers kennis van copy vs move en ownership van objecten en dat is op dit moment nog wat te ver gegrepen denk ik.

Wat wij doen in de opleiding is eenmaal ze wat met pointers vertrouwd worden om ze enkele datastructuren te laten maken. Meestal is dit een (enkelvoudige of dubbele) gelinkte lijst met een constructor/destructor, voegtoe en verwijder functie. Als je begint met pointers is het wel een tijdje spartelen en vloeken, maar eenmaal het je lukt om in elkaar te steken, heb je wel een goede brok inzicht in pointers en new/delete enzo. Je vind er ook veel over op het internet: maak wel de code echt zelf, het spartelen is hetgeen wat je het meest inzicht gaat geven. Later als je meer van C++ kent, kan je dan de pointers omzetten naar smartpointers ofzo.

Ja bedankt voor het advies, ik noemde het zelf al een video voor gevorderden hoewel dat in het begin vd video er niet op lijkt.

Ben uren bezig geweest met de IDE, kom niet aan programmeren toe zo. Invoegen van header file.
Links e.d. in de codes.

Stap 1. Het maken van een c++ .asm project in visial studio 2017.

01 - Open empty project
02 - Geef het een naam , bijv. Test Header File en klik op ok.
03 - Klik op Project in toolbar (tussen view en debug) en klik Add new item.
04 - Klik op C++ File en geef het een naam , bijv main.cpp en klik op add.

-------- Tot dus ver is alles zoals normaal bij opstarten C++

Voor Masm assembly moet er echter een .asm folder bijgemaakt worden.

05 - Klik op Project in toolbar (tussen view en debug) en klik Add new item.
06 - Klik op C++ File maar geef het nu een naam met .asm aan het eind, bijv asm.asm en klik op add.
07 - In Solution Eplorer rechtsklik op Test Header File
08 - Klik op Build Dependencies - klik op Build Customizations
09 - Vink masm(.targets ....) en klik OK

10 - Op de Toolbar onder Tools en Test, verander x86 naar x64 in het veldje. Ik weet echter niet zeker of dat voldoende is. Heb enige tijd geleden daarin gerommeld en weet niet of dat nu automatisch standaard is geworden. Als het niet voldoende is klik in datzelfde veldje en kies Config. Manager. Bij mij staan die zo :



Alles zou nu moeten werken.
Zet een programmaatje in main

code:

//; Video 9 - Passing Integers to and from C++ and Assembly
// vanaf ca. minuut 09:00
//; https://www.youtube.com/watch?v=0tpOEdxtRkA

#include <iostream>
#include <conio.h>
using namespace std;

extern "C" short PassingParameters(short a, short b, short c, short d);

int main()
{
    
    cout << "The function returned :  " << PassingParameters(2, 4, 6, 8) << endl; 
    _getch();
    return 0;
}

Zet een programmaatje in asm.asm

code:

; Vid 9 - Passing Integers to and from C++ and Assembly
; https://www.youtube.com/watch?v=0tpOEdxtRkA
; visual studio gebruikt fast call compiling convention
; To return an int use an appriote size of RAX

 comment /* ; *********************************************************

;   size    QWORD   DWORD   WORD    BYTE
;   1st     RCX     ECX     CX      CL
;   2nd     RDX     EDX     DX      DL
;   3rd     R8      R8D     R8W     R8B
;   4th     R9      R9D     R9W     R9B
;   >4      Stack!  Stack!  Stack!  Stack!

*/ ; ******************************************************************

.data

.code
PassingParameters  proc
    mov ax, cx
    add ax, dx
    add ax, r8w
    add ax, r9w

    ret
PassingParameters endp
end

11 - klik op run , er moet dan 20 in de window verschijnen.

Althans, dat was voorheen zo. ???????????????????????

Heb een andere video na zitten bouwen, no. 13 (typisch)

YouTube: x64 Assembly and C++ Tutorial 13: Programming a Useful Algorithm Par...


De video duurt 10 minuten maar heeft me uren gekost want er zat ineens een header file bij.
Uieindelijk na veel knopjes drukken en vergelijken met oudere, zonder header.h, wel werkende versies toch aan de praat gekregen. Maar nu zijn ineens ook voor nieuwe masm/c++ -projecten bovenstaande stappen niet meer genoeg want er komt een build error :

Error LNK2019 unresolved external symbol PassingParameters referenced in function main
Error LNK1120 1 unresolved externals Test Header File 1

Er moet nu ineens als extra bij :

12 - Rechtsklik op asm.asm in Sol.Expl. en klik op properties.
13 - Er verschijnt een pop-up, klik op Item Type en klik op Mic.Mac.Assembler en klik op ok.


^{(klik voor groter)}


Nu gaat het wel goed en zal een window met 20 verschijnen.


Stap 2. Het maken van een header in een c++ .asm project in visial studio 2017.
Keer terug naar Stap 1. Begin met een nieuw project.

Doorloop 1 t/m 13, ga verder met 14.
14 - Klik op Project in toolbar (tussen view en debug) en klik Add new item.
15 - Klik op Header File (h) en geef het een naam , bijv ZeroArray.h en klik op add.
17 - klik op Save All in Toolbar.
18 - Plak de codes hieronder erin op de juiste plekken en klik op run, er verschijnen nu 2048 getallen, waarvan de helft 0.

Met een paar lege lijntjes ertussen ... zoals ik mij nu voel.

code voor respectievelijk main.cpp , asm.asm en ZerroArray.h

code:

#include <iostream>     // For cout
#include <conio.h>      // For _getch()
#include <stdlib.h>     // For rand()

#include "ZeroArray.h" // Header for our procedure

using namespace std;

// extern "C" void ZeroArray(void* arr, int countInBytes);


int main()
{
    int count = 1024;
    char *arr = new char[count];

    // Init the array to contain random numbers
    // so its easy to tell that the procedure has worked
    for (int i = 0; i < count; i++) arr[i] = (char)rand();

    // Print out the initial values
    for (int j = 0; j < count; j++) cout << (int)arr[j] << " ";

    // Call the procedure
    ZeroArray(arr, count * sizeof(char));

    // Print out the values again to make sure the're all 0
    cout << "\n\n\n\n\n\n\n\n";
    for (int j = 0; j < count; j++) cout << (int)arr[j] << " ";

    _getch();       //Prevent window close
    delete[] arr;   // Free the memory
    return 0;
}

code:

.code
; void ZeroArray(void* RCX, int EDX)
; Sets all bytes from *RCX to *RCX + EDX to 0
ZeroArray proc
    cmp edx, 0          ; Check for 0 or less
    jle Finished

    cmp edx, 1          ; Check for 1
    je SetFinalByte

    mov ax, 0       ; Set AX to 00
    mov r8d, edx    ; Save the original count to r8d
    shr edx, 1      ; Halve the count because we use AX, not AL

MainLoop:
    mov word ptr [rcx], ax  ; Set two bytes to 0
    add rcx, 2              ; Move RCX to the next two bytes
    dec edx                 ; Decrement counter
    jnz MainLoop            ; Jump if more to set

    and r8d, 1      ; Check for even number
    jz Finished     ; If there was, no byte was skipped
    
SetFinalByte:
    mov byte ptr [rcx], 0

Finished:
    ret
ZeroArray endp
end

code:

#ifndef ZEROARRAY_H 
#define ZEROARRAY_H

// Set countInBytes to 0 starting from &arr and
// moving to &arr + countInBytes

extern "C"  void ZeroArray(void* arr, int countInBytes);

#endif

Hopleijk kan de geïnteresseerde hier nog wijs uit (mits ik alsnog geen fouten bij het kopieeren heb gemaakt naar deze post. Maar dat was dus allemaal nodig om c++ gecombineerd met masm en een header file in actie te kunnen krijgen. Echt gebruiksvriendelijk kan ik het niet noemen, tenzij iemand mij mss kan wijzen op welke overbodige stappen ik evt. gemaakt heb ? En is het zo dat (bepaalde, niet alle) settings wijzigingen voor het ene project meteen erin gebakken blijven staan voor de volgende ? Want de mic.mac.assembler hoefde ik voorheen niet te selecteren en in het x84, x64 config manager veldje stond volgens mij eerst ook ARM maar heb die daarna nooit meer terug gezien.

Nog iets, heb inmiddels ook een asm. text highlighter programma erin staan, dat heet AsmDude.

YouTube: How to get Assembly Syntax Highlighting in Visual Studios

Is wel een verbetering maar soms ook wel hinderlijk als ieder woord oplicht.

[ Voor 1% gewijzigd door kitao op 30-01-2019 15:42 . Reden: Afbeelding naar thumbnail omgezet. ]

[kitao]

Ben bij een recursieve functie beland, onderaan deze pagina staat de originele code.
http://www.cplusplus.com/doc/tutorial/functions/
Vind het lastig te begrijpen wat er gebeurt en heb hier iets meer duidelijkheid gekregen :
https://beginnersbook.com/2017/08/cpp-recursion/

Ik heb de code uit cplusplus intact gelaten maar er enkele cout regels bijgezet om het beter in beeld te krijgen.
Overig commentaar staat in de code.

code:

// factorial calculator
#include <iostream>
using namespace std;

long x = 6;  // zet deze gelijk aan 'number' in main op regel 38.

long factorial(long a)
{
    if (a > 1)
    {
        cout << "a = " << a << endl;
        cout << "a - 1 = " << a - 1 << endl;
        x = x * (a - 1); // oftewel, number = number * (number -1)
        cout << "x = x * (a-1) =       " << x << endl << endl;

        return (a * factorial(a - 1));
        cout << " jump uit return 1 " << endl; // Deze wordt niet uitgeprint !!!
    }
    else
    {
        // zet op de regel hieronder een breakpoint
        cout << endl << endl << "a in Else =  " << a << endl << endl;

        return 1; 
        // Return 1 verspringt naar de accolade op regel 34
        // Daarna wordt er (number-1) aantal keren versprongen tussen
        // de return op regel 16 en de accolade op regel 34.
        // Vragen :
        // 1. Hoe weet hij hoeveel keer hij moet verspringen ?????
        // 2. Waar kan ik een cout regel zetten om het aantal 'jumps' te tellen ????
        // 3. En waar worden de tussenresultaten van 6x5, 6x5x4 ... etc. opgeslagen ???

    }
}

int main()
{
    long number = 6; // zet deze gelijk aan 'x' op regel 5.
    cout << "De faculteit van " << number << " =  " << factorial(number);

    cout << endl << endl;
    system("pause");
    return 0;
}

// Return 1 verspringt naar de accolade op regel 34
// Daarna wordt er (number-1) aantal keren versprongen tussen
// de return op regel 16 en de accolade op regel 34.
// Vragen :
// 1. Hoe weet hij hoeveel keer hij moet verspringen ?????
// 2. Waar kan ik een cout regel zetten om het aantal 'jumps' te tellen ????
// 3. En waar worden de tussenresultaten van 6x5, 6x5x4 ... etc. opgeslagen ???

Heb de cout op regel 17 geprobeerd op enkele plekken neer te zetten zodat die wel uitgeprint gaat worden en dus als tellertje kan gaan dienen van het aantal jumps zodra return 1 is gepasseerd. Maar dat is me nog niet gelukt.
Hoe kan ik wel het aantal jumps weergeven nadat return 1 is gepasseerd ?