:strip_icc():strip_exif()/u/12461/crop65b195553d948.jpg?f=community)
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
:strip_icc():strip_exif()/u/467128/bermuda2.jpg?f=community)
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.
/u/123066/crop5db977bf69322.png?f=community)
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
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 ]
/u/296460/beaker_s.png?f=community)
/u/3813/100_8985_ICON2.JPG?f=community)
Nee klopt, maar het ligt voor de hand (en is mijn ervaring) dat alle relational operators dan op die manier geschreven gaan worden.:
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.
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Dat valt zeker te overwegen, bedankt.
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| #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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| //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 ?
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 :
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.
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
| /*
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 ]
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
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?
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.
Misschien moet je eerst proberen de code te begrijpen ipv gewoon maar wat bij elkaar copy-pasten
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
ja, dat idee had ik ook al:
Misschien moet je eerst proberen de code te begrijpen ipv gewoon maar wat bij elkaar copy-pasten
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.
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?
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Dat was om te testen farlane, de auteur gaf namelijk dit in zn antwoord : if (myIndex != string.npos).:
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?
maar dat draait bij mij niet, dus was er (tijdelijk) over verbaasd.
Op deze manier bedoel je ?
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| #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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| // 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.
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
| #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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| 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 ]
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 :
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 :
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++''.
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++:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 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++:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
| #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++''.
/u/126369/Daos2.png?f=community)
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 ]
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
Z80Vandaar 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.
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
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 ]
:strip_exif()/u/88216/Goomba-animated.gif?f=community)
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
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 ]
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
"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
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
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Dat is zo, gaat natuurlijk ook om het plezier en dat heb ik er momenteel wel in.:
"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
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.
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 ]
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
oeps
de nummers lijken op elkaar, zelfde bereik ongeveer van 10 tot 15.
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
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| // 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;
} |
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
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 ?
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| /*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;} |
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
:strip_icc():strip_exif()/u/206968/325134.jpg?f=community)
Ik zeg net letterlijk dat dat niet zo is
Op 64 bits Linux en Windows is een int nog steeds 32 bits.
Op 64 bits Linux en Windows is een int nog steeds 32 bits.
[ Voor 41% gewijzigd door .oisyn op 27-01-2019 16:23 ]
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
/u/486087/crop5ed11512833ce_cropped.png?f=community)
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| //; 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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| ; 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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| #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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| .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:
1
2
3
4
5
6
7
8
9
| #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. ]
Bedankt voor het meekijken en de suggestie
Heb eerder de cout op regel 17 gekopieerd naar de lege regel 15 en dan wordt die wel uitgeprint. Maar dat is niet helemaal de bedoeling. Ik wil het aantal jumps weergeven nadat regel 22 is uitgevoerd want pas daarna, oftewel bij het bereiken van Return 1 , gaat die ook daadwerkelijk jumpen.
Heb nog geprobeerd de cout op de lege regel 23 te zetten maar dan verschijnt die maar 1x en niet 5 keer (het aantal jumps).
Het is waarschijnlijk zoals jij zegt, de jump-teller zit een nivo dieper en momenteel weet ik die teller niet te vinden en/of weer te geven.
[ Voor 5% gewijzigd door kitao op 31-01-2019 08:22 ]
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
nee, nog niet naar gekeken, goeie tip.
was ook nog van plan om in disassembly te kijken maar is tijd voor een pauze geloof ik.
Vierkante oogjes heb ik ervan gekregen. Kom er later mss op terug.
Heb inmiddels de call-stacks erbij gezet en dat hielp goed, tnx.
Ik zie het programma, nu volgens het origineel hieronder, eerst 6x 'factorial opbouwen' in de call stack om ze vervolgens weer af te breken. (Breakpoint op main gezet)
Register EAX gaat bij opbouwen van 6 - 5 - 4 - 3 - 2 naar 1.
Register EAX gaat bij afbreken van 1 - 2 - 6 - 18 - 78 - 2DO
Dus bij wat ik jojo noemde gaat die pas rekenen zo te zien, en niet van 6x5x4x3x2x1 maar andersom van 1x2x3x4x5x6 en dat geeft respectievelijk 2-6-18-78 en tenslotte 2D0 als hex eindresultaat in de EAX.
Eerder zag ik dat patroon niet omdat ik er zoveel zelf-verzonnen regels bij gezet had die ook naar de EAX schrijven volgens mij en omdat ik de call stack er nog niet bij had.
Ik laat het hierbij, best veel van opgestoken hoewel een cout van de EAX nog niet gelukt is, schijnt ook niet zo eenvoudig te zijn. Misschien later nog eens naar kijken.
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| // factorial calculator
#include <iostream>
using namespace std;
long factorial (long a)
{
if (a > 1)
return (a * factorial (a-1));
else
return 1;
}
int main ()
{
long number = 6;
cout << number << "! = " << factorial (number);
return 0;
} |
klik voor groter
Geraadpleegde video
YouTube: Illustrated Assembly Language Recursion
[ Voor 1% gewijzigd door kitao op 31-01-2019 21:30 . Reden: typo ]
Het voorgaande heeft m.i. aangetoond dat enige kennis van assembly geen kwaad kan. Vind het ook leuk om dat naast C++ erbij te doen en besteed daar ongeveer de helft van de tijd aan. Zodoende kwam ik een project tegen van iemand die daar al bijna 20 jaar mee bezig is en dat heet Visual Masm. En iemand anders heeft daar een serie video's over gemaakt met programmeer voorbeelden.
Voor geïnteresseerden in deze post, dat niet zozeer een vraag bevat, een paar verwijzingen.
Allereerst van de maker zelf, op zijn youtube kanaal klik op video's :
YouTube: Thomas Jaeger
Daar staan ze namelijk op volgorde wat op zijn afspeellijst niet het geval lijkt te zijn. Hier is zijn website :
http://www.visualmasm.com/
Een andere serie video voorbeelden staan hier :
YouTube: x86 Assembler using MASM32 Tutorial 5 - IF Statements
Daaronder via meer weergeven kan je een website vinden waar de behandelde codes netjes staan uitgeschreven : https://www.alanphipps.ne...s/IT_Assembler_Tutorial05
Video 5 ging dus over If-Else en ik had de statements daarvan met de hand uitgetikt en kwam waarschijnlijk via een typefout in een oneindige lus terecht waar slechts met een harde reset van de computer uit te komen was. Na her-opstarten zag ik nog steeds allerlei flitsen voorbij komen en daarom raad ik niet aan dit op een dure, nieuwe en/of enigste PC te downloaden, hoewel alles nu weer goed lijkt te werken.
Ook het saven en openen van projecten, nieuw of bestaand, vond ik niet erg soepel gaan, maar dat kan ook komen omdat ik niet al te goed thuis ben ik het handmatig maken van directory mappen, zoals met msdos of linux. Na een tijd oefenen gaat dit inmiddels wel beter maar zal daar zolang daar geen vraag naar is niet verder over uitweiden. De 100% gekopieerde If-code draaide overigens prima.
Al met al best knap van die meneer om zelf zo'n programma op te bouwen en jammer voor hem eigenlijk dat zijn video's zo weinig bekeken zijn. Mocht iemand dit toevallig eerder zijn tegengekomen en eventueel enkele tips hebben in die richting of van iets soortgelijks, dan hoor ik dat graag.
Voor geïnteresseerden in deze post, dat niet zozeer een vraag bevat, een paar verwijzingen.
Allereerst van de maker zelf, op zijn youtube kanaal klik op video's :
YouTube: Thomas Jaeger
Daar staan ze namelijk op volgorde wat op zijn afspeellijst niet het geval lijkt te zijn. Hier is zijn website :
http://www.visualmasm.com/
Een andere serie video voorbeelden staan hier :
YouTube: x86 Assembler using MASM32 Tutorial 5 - IF Statements
Daaronder via meer weergeven kan je een website vinden waar de behandelde codes netjes staan uitgeschreven : https://www.alanphipps.ne...s/IT_Assembler_Tutorial05
Video 5 ging dus over If-Else en ik had de statements daarvan met de hand uitgetikt en kwam waarschijnlijk via een typefout in een oneindige lus terecht waar slechts met een harde reset van de computer uit te komen was. Na her-opstarten zag ik nog steeds allerlei flitsen voorbij komen en daarom raad ik niet aan dit op een dure, nieuwe en/of enigste PC te downloaden, hoewel alles nu weer goed lijkt te werken.
Ook het saven en openen van projecten, nieuw of bestaand, vond ik niet erg soepel gaan, maar dat kan ook komen omdat ik niet al te goed thuis ben ik het handmatig maken van directory mappen, zoals met msdos of linux. Na een tijd oefenen gaat dit inmiddels wel beter maar zal daar zolang daar geen vraag naar is niet verder over uitweiden. De 100% gekopieerde If-code draaide overigens prima.
Al met al best knap van die meneer om zelf zo'n programma op te bouwen en jammer voor hem eigenlijk dat zijn video's zo weinig bekeken zijn. Mocht iemand dit toevallig eerder zijn tegengekomen en eventueel enkele tips hebben in die richting of van iets soortgelijks, dan hoor ik dat graag.
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Nogmaals bedankt
Ben nog wel afwisselend bezig met C++ en was een tijd aan het zoeken om een string naar een functie door te geven. Zoals waarschijnlijk met alle talen, lezen/luisteren is makkelijker als schrijven/spreken.
Kwam daarover een aantal dingen tegen op internet maar niet de m.i. makkelijkste en meest voor de hand liggende. Is waarschijnlijk zo vanzelfsprekend dat niemand er vragen over stelt. Aan de andere kant merk je goed als je dit zelf probeert hoeveel combinaties er mogelijk zijn, een zijdelings voorbeeld daarvan is hier te vinden :
Pointers and const (ergens halverwege op die pagina, m.n. de verschillende schrijfwijzen ervan)
http://www.cplusplus.com/doc/tutorial/pointers/
Dat is trouwens waar ik tot nu toe gebleven ben met die tutorial.
Afin, ik heb nu drie 'string passings technieken' verzameld in een mapje aangezien ik die dingen vrij snel vergeet en is misschien een leuke puzzel op de zondag voor diegeen die het wil aanvullen met een vierde of vijfde versie.
Daarbij opgemerkt dat ik soms tegenkwam dat het ook met vectors kan (moet dat nog verder uitzoeken) maar ben volgens mij in bovenstaande tutorial nog geen enkel vector voorbeeld tegengekomen
Deze drie versies heb ik tot nu toe getest.
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
| // passing string T to function
// string T = "Test";
************* Met ombouw herverbouwing **********
#include <iostream>
#include <string>
using namespace std;
void functie(const char *P)
{
cout << P;
}
int main()
{
const char *T = "Test";
functie(T);
return 0;
}
***************** Valse omweg ********************************
void functie(const char *P)
{
cout << P;
}
int main()
{
string T = "Test";
functie("Test"); // Valse omweg, met T gebeurt niks
return 0;
}
******************** Makkelijkste *******************************
void functie(string P)
{
cout << P;
}
int main()
{
string T = "Test";
functie(T);
return 0;
}
***************** Nog meer ? *******************************
functie()
[...]
main()
[...] |
Een wat serieuzere vraag als slot toevoeging aan deze post.
Was vandaag dus bezig met dit hoofdstuk
http://www.cplusplus.com/doc/tutorial/pointers/
en helemaal onderaan staan de subonderwerpen void pointer en pointer to function.
Bij de eerste heb ik volgens mij inmiddels door dat ...
void increase (void* data, int psize)
pchar=(char*)data;
.. de void pointer data via pchar omgezet wordt in een char pointer data.
Bij de tweede, pointers to functions, vraag ik me af of (beroepsmatige) programmeurs echt regelmatig die vorm toepassen of laat de tutorial hier enkel zien wat principieel mogelijk is ?
Vind het wel heel erg abstract worden zo maar kan aan mij liggen.
int operation (int x, int y, int (*functocall)(int,int))
int (*minus)(int,int) = subtraction;
en abstract is niet negatief bedoeld, knap juist als iemand dit zonder naslag weet op te schrijven.
.
[ Voor 15% gewijzigd door kitao op 17-02-2019 18:05 . Reden: vraag toegevoegd ]
Ok, bedankt
Is soms lastig vooraf te bepalen voor een leek of iets meer of weinig of geen nadere aandacht nodig heeft.
Kwam laatst iets tegen over het nesten van namespaces maar dat leek mij dus wel echt een theoretisch spelletje.
Niet dat ik zelf van plan was beroeps te worden maar vond het pointers naar functies nogal complex. Maar nu jij aantoont dat het geen uitzondering is, en te verwachten valt dat dit vaker in programma's te zien zal zijn, is het de moeite waard er nog eens nauwkeuriger naar te kijken.
En ik snap wel dat zulke vragen na verloop van tijd zichzelf verduidelijken maar dat vroeg ik mij op dit moment dus af.
Ps/
Idem voor Radiant
[ Voor 4% gewijzigd door kitao op 17-02-2019 21:03 ]
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Het concept "callback functie" wordt overal en then some toegepast. (niet alleen in C++)
Een functiepointer is de essentie van een (runtime variabele) callback dus het is (in tegenstelling tot assembly
) wat mij betreft een must have skill om er mee om te kunnen gaan.
Een functiepointer is de essentie van een (runtime variabele) callback dus het is (in tegenstelling tot assembly
) wat mij betreft een must have skill om er mee om te kunnen gaan.
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Bedankt voor de waarschuwing om dit niet zomaar over te slaan.:
Het concept "callback functie" wordt overal en then some toegepast. (niet alleen in C++)
Een functiepointer is de essentie van een (runtime variabele) callback dus het is (in tegenstelling tot assembly
Ongetwijfeld zal ik die dan ook bij andere websites tegenkomen hoewel ik mij beperkt heb tot slechts een paar daarvan anders wordt het chaotisch.
Is namelijk zo dat als ik door de cplusplus voorbeelden heen stap via de compiler (VS17 gebruik ik), niet automatisch alle aspecten van de variabelen meteen in beeld komen. Zoals bij de void pointer wou ik het adres van char a in beeld krijgen maar daar bleek een cout << static_cast<void *>(&a); voor nodig te zijn.
Uiteindelijk duurt dan zo'n 'inspectie' al gauw een uur, vooral als je het eerst zelf probeert.
Maar ik heb de tijd en geen haast, dat scheelt.
.
[ Voor 15% gewijzigd door kitao op 17-02-2019 23:55 ]
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Kan je het plaatje zien ?
Anders zet ik hem hier
En ja sorry, je hebt gelijk, moet nog thuis worden in de terminologie, het is de editor.
- adres &subtraction vastgepind geeft 26D0
- adres &subtraction in console geeft 13DE
- pointer *minus en 'pointer' *function_call wijzen naar 13DE
En met vastgepind in de compiler bedoel ik de weergaven die 'naast' het programma staan.
Bij de regel nummers is ook een punaise te zien , die geen betrekking hebben op de regel zelf, maar waar de pin naartoe is gesleept.
Trouwens tof dat je even meekijkt
Kan zijn dat het in een andere compiler geen verschil geeft zoals bij mij ?
Onderaan staat de console window.
Herstarten, hoewel niet helemaal 'vers' maar van het opgeslagen project, gaf geen verschil.
&subtraction in watch zetten evenmin.
Zal morgen nog eens dit programma vers erin zetten en kijken of dat verschil maakt.
.
Vers opgeladen, VS17 vers opgestart, code vers gekopieerd uit mijn vorige post zodat er niks blijft hangen en maakt helaas geen enkel verschil, zover ik kan waarnemen.
.
&subtraction gepind = ....26D0
&subtraction cout = ....13DE
pointer *minus wijst naar ....13DE
.
[ Voor 23% gewijzigd door kitao op 18-02-2019 21:14 ]
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Ok, ten eerste, "de compiler" is het programma dat jouw broncode omzet in machinecode (of een intermediate representatie) en heeft dus weinig relatie met wat je nu aan het doen bent . Die pins zijn onderdeel van de debugger.
Wat betreft de verschillen, het heeft denk ik te maken met het feit dat je compilet in debug (met ondersteuning voor edit&continue). De functies wijzen dan niet echt naar de functies maar naar een thunk (waar een JMP instructie staat naar het daadwerkelijke functieadres). Tijdens het runnen kan de debugger dan makkelijk de functie vervangen door een nieuwe versie als je tijdens het debuggen de code wijzigt. Ik denk dat hij echter bij het ophalen van het adres van een functie voorbij de thunk kijkt.
Sowieso heeft je programma het altijd bij het rechte eind, niet je debugger
. Die pins zijn onderdeel van de debugger.Wat betreft de verschillen, het heeft denk ik te maken met het feit dat je compilet in debug (met ondersteuning voor edit&continue). De functies wijzen dan niet echt naar de functies maar naar een thunk (waar een JMP instructie staat naar het daadwerkelijke functieadres). Tijdens het runnen kan de debugger dan makkelijk de functie vervangen door een nieuwe versie als je tijdens het debuggen de code wijzigt. Ik denk dat hij echter bij het ophalen van het adres van een functie voorbij de thunk kijkt.
Sowieso heeft je programma het altijd bij het rechte eind, niet je debugger
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Dat was mij vaag ook al opgevallen die offset, ik neem aan dat je dit bedoelt :
- plaatje 1 : &subtraction gepind = 010526D0
- plaatje 1 : &subtraction cout ... = 010513DE
na verversing ..
- plaatje 2 : &subtraction gepind = 00A426D0
- plaatje 2 : &subtraction cout ... = 00A413DE
Het klopt inderdaad dat in 'run mode' , en trouwens ook in 'debug mode', sowieso de uitkomst hetzelfde blijft, namelijk 20 - 14 = 6.:
Ok, ten eerste, "de compiler" is het programma dat jouw broncode omzet in machinecode (of een intermediate representatie) en heeft dus weinig relatie met wat je nu aan het doen bent
Wat betreft de verschillen, het heeft denk ik te maken met het feit dat je compilet in debug (met ondersteuning voor edit&continue). De functies wijzen dan niet echt naar de functies maar naar een thunk (waar een JMP instructie staat naar het daadwerkelijke functieadres). Tijdens het runnen kan de debugger dan makkelijk de functie vervangen door een nieuwe versie als je tijdens het debuggen de code wijzigt. Ik denk dat hij echter bij het ophalen van het adres van een functie voorbij de thunk kijkt.
Sowieso heeft je programma het altijd bij het rechte eind, niet je debugger
Dus ondanks mijn geklaag over gammele VS17 lag het toch aan de bestuurder die niet goed uit elkaar weet te houden hoe de verschillende bewerkingen van zo'n programma invloed hebben.
Komt waarschijnlijk omdat ik nooit eerder van thunk had gehoord, dus zal dat eens naslaan.
Bedankt, allebei
Ps\
Ik was niet de enige die ging duizelen van de notatie int (int , int , int(*)(int, int)).
Hier noemen ze het zelfs ugly en leveren een aantal alternatieven ervoor.
[Function Pointers]
https://www.learncpp.com/cpp-tutorial/78-function-pointers/
Ps2\
Vwb [thunk], paar artikelen daarover bekeken en denk dat deze het duidelijkst is hoewel ik zelf niet helemaal er doorheen gespit ben, is niet echt voor beginners.
https://www.codeproject.c.../27908/Thunk-and-its-uses
.
[ Voor 11% gewijzigd door kitao op 19-02-2019 13:00 . Reden: Ps\ ]
Base address randomization
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Over random gesproken, ben de flow kwijt ... 
Origineel :
https://www.tutorialspoin.../cpp_copy_constructor.htm
Zelfde maar dan gecomprimeerd en voorzien van blok nummers in de comments
Main bevat enkel regel R33,34,35 en slot haakje } op R36
Main() = Blok 0
Wat bepaalt de programma flow ?
Met een breakpoint op main() en vervolgens step into zie ik dit :
R33 >>jmp...>> Blok2 ..........zoals te verwachten
Blok2 >>return>> R33 .............zoals te verwachten
R33 ...>>naar...>> R34 .............zoals te verwachten
R34....>>jmp...>> Blok3 ..........?? volgens welke logica, waarom niet naar Blok6 ??
En kan hier al stoppen voor het geoefende oog, hoewel het nog verder gaat maar hoop dat mijn vraag duidelijk is, wat bepaalt hier nu eigenlijk de programmaflow ? Zijn het de pointers en hoe dan, is het de 'inwendige' structuur van Classes oftewel een mij onbekend protocol zeg maar, of de volgorde waarin de blokken achter elkaar staan ?
Gister kwam ik er niet uit bij hoe de debugger zn pointer-adressen bijhoudt en dat is bij dit voorbeeld wmb al bijna helemaal een onbegonnen zaak, maar daarbovenop lijkt het nog erger te worden.
Kan nu al niet meer herkennen hoe het programma zn jumps en returns maakt ?
Tot nu toe was dat altijd wel duidelijk.
Nogmaals kort(er) samengevat , wat laat regel 34 nu eigenlijk springen naar blok 6? EDIT = BLOK3
32. int main() { // BLOK 0
R33. Line line(10); // jumps naar blok 2
R34. display(line);
R35. return 0;
R36. }
12. Line::Line(int len) { // BLOK 2 Member functions definitions including constructor
13. cout << "Normal constructor allocating ptr" << endl;
14. ptr = new int; // allocate memory for the pointer;
15. *ptr = len;
16. }
// Blok 2 returns naar R33
// R33 gaat naar R34
// R34 JMP naar BLOK3 ?? ?? ??
17 Line::Line(const Line &obj) { // BLOK 3
********************
Hieronder dan de rest van de programmaflow in debug mode, maar is waarschijnlijk onnodig om de vraag verder te verduidelijken.
B=BLOK
B3>>returns>>R34
R34>>JMP>>B6 ............zoals te verwachten
B6>>JMP>>B5...............zoals te verwachten
B5>>returns>>B6.............zoals te verwachten
B6>>JMP>>B4 ............. ?? volgens welke logica ??
B4>>returns>>B6 ........... ok
B6>>returns>>R34
R34>>naar>>R35
R35>>JMP>>BLOK4 .... ?? volgens welke logica ??
B4>>returns>>R35
R35>>naar>>R36...........eindeprogramma
Ik vermoed dat deze vraag misschien weer net zo'n tamelijk harde noot wordt als gisteren en alvast mijn excuses daarvoor. Ben net met classes begonnen en zou beter nog iets verder daarin duiken in de hoop dat dit vanzelf duidelijker wordt. Probleem is echter dat ik zo gauw geen andere manier zie om dit enigzins onder de knie te krijgen zonder 'erdoorheen te stappen' met de debugger. Is dus in feite een kip-ei verhaal.
.
Origineel :
https://www.tutorialspoin.../cpp_copy_constructor.htm
Zelfde maar dan gecomprimeerd en voorzien van blok nummers in de comments
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| #include <iostream>
using namespace std;
class Line { // BLOK 1
public:
int getLength(void);
Line(int len); // simple constructor
Line(const Line &obj); // copy constructor
~Line(); // destructor
private:
int *ptr;
};
Line::Line(int len) { // BLOK 2 Member functions definitions including constructor
cout << "Normal constructor allocating ptr" << endl;
ptr = new int; // allocate memory for the pointer;
*ptr = len;
}
Line::Line(const Line &obj) { // BLOK 3
cout << "Copy constructor allocating ptr." << endl;
ptr = new int;
*ptr = *obj.ptr; // copy the value
}
Line::~Line(void) { // BLOK 4
cout << "Freeing memory!" << endl;
delete ptr;
}
int Line::getLength(void) { // BLOK 5
return *ptr;
}
void display(Line obj) { // BLOK 6
cout << "Length of line : " << obj.getLength() << endl;
}
int main() { // BLOK 0
Line line(10);
display(line);
return 0;
} |
Main bevat enkel regel R33,34,35 en slot haakje } op R36
Main() = Blok 0
Wat bepaalt de programma flow ?
Met een breakpoint op main() en vervolgens step into zie ik dit :
R33 >>jmp...>> Blok2 ..........zoals te verwachten
Blok2 >>return>> R33 .............zoals te verwachten
R33 ...>>naar...>> R34 .............zoals te verwachten
R34....>>jmp...>> Blok3 ..........?? volgens welke logica, waarom niet naar Blok6 ??
En kan hier al stoppen voor het geoefende oog, hoewel het nog verder gaat maar hoop dat mijn vraag duidelijk is, wat bepaalt hier nu eigenlijk de programmaflow ? Zijn het de pointers en hoe dan, is het de 'inwendige' structuur van Classes oftewel een mij onbekend protocol zeg maar, of de volgorde waarin de blokken achter elkaar staan ?
Gister kwam ik er niet uit bij hoe de debugger zn pointer-adressen bijhoudt en dat is bij dit voorbeeld wmb al bijna helemaal een onbegonnen zaak, maar daarbovenop lijkt het nog erger te worden.
Kan nu al niet meer herkennen hoe het programma zn jumps en returns maakt ?
Tot nu toe was dat altijd wel duidelijk.
Nogmaals kort(er) samengevat , wat laat regel 34 nu eigenlijk springen naar blok 6? EDIT = BLOK3
32. int main() { // BLOK 0
R33. Line line(10); // jumps naar blok 2
R34. display(line);
R35. return 0;
R36. }
12. Line::Line(int len) { // BLOK 2 Member functions definitions including constructor
13. cout << "Normal constructor allocating ptr" << endl;
14. ptr = new int; // allocate memory for the pointer;
15. *ptr = len;
16. }
// Blok 2 returns naar R33
// R33 gaat naar R34
// R34 JMP naar BLOK3 ?? ?? ??
17 Line::Line(const Line &obj) { // BLOK 3
********************
Hieronder dan de rest van de programmaflow in debug mode, maar is waarschijnlijk onnodig om de vraag verder te verduidelijken.
B=BLOK
B3>>returns>>R34
R34>>JMP>>B6 ............zoals te verwachten
B6>>JMP>>B5...............zoals te verwachten
B5>>returns>>B6.............zoals te verwachten
B6>>JMP>>B4 ............. ?? volgens welke logica ??
B4>>returns>>B6 ........... ok
B6>>returns>>R34
R34>>naar>>R35
R35>>JMP>>BLOK4 .... ?? volgens welke logica ??
B4>>returns>>R35
R35>>naar>>R36...........eindeprogramma
Ik vermoed dat deze vraag misschien weer net zo'n tamelijk harde noot wordt als gisteren en alvast mijn excuses daarvoor. Ben net met classes begonnen en zou beter nog iets verder daarin duiken in de hoop dat dit vanzelf duidelijker wordt. Probleem is echter dat ik zo gauw geen andere manier zie om dit enigzins onder de knie te krijgen zonder 'erdoorheen te stappen' met de debugger. Is dus in feite een kip-ei verhaal.
.
[ Voor 0% gewijzigd door kitao op 19-02-2019 20:15 . Reden: EDIT BLOK6 MOEST BLOK 3 ZIJN ]
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Ieders nivo en talent verschilt per persoon natuurlijk, de ene heeft meer aanleg voor taal, de ander voor rekenen en weer een ander voor voetbal en alles wat daartussen zit. Ben er paar uur mee bezig geweest, incl. breakpoints en debugger, zoals je zag heb ik iedere losse stap gekopieerd en alle localen erbij geplakt maar feit blijft dat ik het nog steeds niet zie en pretenderen alsof dat wel zo is heeft ook geen nut.
Er zijn een aantal blokken
Line::Line(int len) { .................................... // BLOK 2
Line::Line(const Line &obj) {...................... // BLOK 3
Line::~Line(void) {...................................... // BLOK 4
int Line::getLength(void) { ..........................// BLOK 5
void display(Line obj) {............................... // BLOK 6
en in main deze twee regeltjes
33 Line line(10);
34 display(line);
Regel 33 roept Blok 2 aan, dat zie ik dan nog wel in maar dat regel 34 Blok 3 roept had ik niet verwacht. Dit omdat Blok 6 qua syntax namelijk veel meer op regel 34 lijkt. Ok, er staat in Blok 6 een obj en in Blok3 staat een &obj maar in regel 34 zie ik geen obj maar een line met kleine letter.
Wat het leren van de basis betreft, begin vorige maand een keuze gemaakt hoe ik dat leren zou aanpakken en heb toen ervoor gekozen om deze drie aan te houden
http://www.cplusplus.com/doc/tutorial/
https://github.com/TPayneExperience/Lets_Learn_Cpp
https://www.tutorialspoint.com/cplusplus/index.htm
en volg die die vanaf de hoofdstukken 1 tot waar ik nu ben en dus zouden er in principe geen gaten gevallen moeten zijn waardoor ik iets gemist heb om bovenstaand te kunnen begrijpen. Slechts 1 van die drie heb ik nu Classes zien behandelen dus hopelijk wordt via die andere twee tzt meer duidelijk. En ondertussen kan ik in jouw boek dat onderwerp nalezen, waarvoor bedankt.
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Dat regel 34 blok 3 aan roept is eenvoudig te verklaren. Jouw functie display is namelijk: void display(Line obj). Je geeft een Line object mee
Zoals ik dit lees, wat natuurlijk niet hetzelfde hoeft te zijn als jij bedoelt, kom ik tot de volgende interpretatie :
34 display(line); >>>> via het woord display wordt de functie in Blok6 aangeroepen
29 void display(Line obj) { // BLOK 6 >>> en via Line obj wordt Blok3 aangeroepen
17 Line::Line(const Line &obj) { // BLOK 3
Ik zou hier graag genoegen mee nemen en omdat ook eergisteren .oisyn en farlan het over de obj hadden zie ik wel enig verband, maar ik zie de debugger zo niet stappen.
Dit komt bij mij in beeld : (edit : waarbij regel 14 per ongeluk dubbel is gefotografeerd)
Hele code staat hier
kitao in "[C++] Programmeren Beginnersvraag(en)"
Ik zie dus als locale een this verschijnen, vanuit het niets, die toevallig, al voordat 34 display(line); wordt bereikt, hetzelfde adres aanneemt opneemt als obj.
Dit ging mij pas achteraf opvallen anders had ik mij eerst verdiept in wat de this voorstelt voordat ik deze vraag ging stellen. Ik vermoed namelijk dat die invloed heeft op de stapvolgorde, maar kan me vergissen.
Ik geef .oisyn mede daarom groot gelijk dat dit voor mij nog een dieptelaag te ver is , iets wat ik zelf al aangaf, maar de bereidheid om te helpen is groot, waarvoor hartelijk dank en wou dat niet zomaar zonder antwoord laten.
.
[ Voor 8% gewijzigd door kitao op 21-02-2019 16:38 . Reden: typo's + edit ]
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Correctie vorige post, dat boek blijkt geen herhaling te zijn en heeft een vrij andere insteek als de overige tutorials, bedankt voor de tip. Heb gisteren hfdst2 afgerond.
Vind ergens wel dat in een beginnerstopic vragen vrij zou moeten staan, ook al blijkt hieruit dat de vraagsteller zn lesje niet goed heeft begrepen, tenzij overduidelijk blijkt dat de vraagsteller te lui is om zelf te zoeken.
Uiteindelijk valt vrijwel alles te vinden maar dan gaat het vaak gedeeltelijk via andere forums/websites en dat lijkt me ook niet de bedoeling.
In ieder geval, nogmaals, bedankt voor de boektip, komt goed van pas
Deze vraag gaat trouwens niet over dat boek maar komt via deze :
http://www.cplusplus.com/doc/tutorial/structures/
Er staan een drietal voorbeeld-programma's in maar dit gaat enkel over de eerste twee.
Ik vroeg me namelijk af waarom sstream erbij werd gehaald.
In het 1e voorbeeld heb ik een wijziging aangebracht, namelijk dit :
Die wijziging had geen enkele invloed op het eindresultaat.
Het 2e voorbeeld bevat echter een loop, om veel woorden te vermijden een plaatje van mijn zelfde soort wijziging die nu wel (erg) veel invloed heeft op het eindresultaat :
Te zien valt dat bij de 1e iteratie alles nog goed gaat, maar bij de tweede en laatste iteratie wordt regel 22 met getline(cin, yours.title); mysterieus en glashard overgeslagen. Mysterieus voor mij althans.
Iemand enig idee waardoor dat komt ?
Vind ergens wel dat in een beginnerstopic vragen vrij zou moeten staan, ook al blijkt hieruit dat de vraagsteller zn lesje niet goed heeft begrepen, tenzij overduidelijk blijkt dat de vraagsteller te lui is om zelf te zoeken.
Uiteindelijk valt vrijwel alles te vinden maar dan gaat het vaak gedeeltelijk via andere forums/websites en dat lijkt me ook niet de bedoeling.
In ieder geval, nogmaals, bedankt voor de boektip, komt goed van pas
Deze vraag gaat trouwens niet over dat boek maar komt via deze :
http://www.cplusplus.com/doc/tutorial/structures/
Er staan een drietal voorbeeld-programma's in maar dit gaat enkel over de eerste twee.
Ik vroeg me namelijk af waarom sstream erbij werd gehaald.
In het 1e voorbeeld heb ik een wijziging aangebracht, namelijk dit :
code:
1
2
3
4
5
6
| cout << "Enter title: ";
getline(cin, yours.title);
cout << "Enter year: ";
cin >> yours.year; // deze regel is door mij erbij gezet
//getline(cin, mystr); // deze regel is door mij tot comment gemaakt
//stringstream(mystr) >> yours.year; // deze regel is door mij tot comment gemaakt |
Die wijziging had geen enkele invloed op het eindresultaat.
Het 2e voorbeeld bevat echter een loop, om veel woorden te vermijden een plaatje van mijn zelfde soort wijziging die nu wel (erg) veel invloed heeft op het eindresultaat :
Te zien valt dat bij de 1e iteratie alles nog goed gaat, maar bij de tweede en laatste iteratie wordt regel 22 met getline(cin, yours.title); mysterieus en glashard overgeslagen. Mysterieus voor mij althans.
Iemand enig idee waardoor dat komt ?
Je hebt het goed gelezen, knap hoor, ik raak zelf meestal nog de weg kwijt in dit soort 'datasheets'.
Maar nu je het zegt, ik ben zoiets dergelijks wel eens eerder tegengekomen met een 'haperende' cin.
Heb regel 25 toegevoegd uit jouw verwijzing naar notes en dit is het eindresultaat :
Helemaal prima dus
Niet dat ik het nu echt 100% begrijp maar er zit vooruitgang in.
Ook is het mij nog niet helemaal duidelijk waarom in http://www.cplusplus.com/doc/tutorial/structures/ sstream erbij wordt gehaald maar dat is voor een andere keer.
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
Bedankt voor de toelichting farlane,
Heb het nog eens opgezocht en sstream bleek te staan in het hoofdstukje basic input and output.
http://www.cplusplus.com/doc/tutorial/basic_io/
Had er zelfs een aantekening van maar mijn geheugen is niet meer wat het geweest is, en bovendien ben ik het daarna (vrijwel) niet meer tegengekomen.
Er staat bijvoorbeeld dit :
The standard header <sstream> defines a type called stringstream that is most useful to convert strings to numerical values and vice versa.
Ik kan best begrijpen dat dit nuttig is in bepaalde gevallen maar zag er niet het voordeel van in bij genoemd voorbeeldprogramma // example about structures op pagina http://www.cplusplus.com/doc/tutorial/structures/
In dat programma kunnen 4 regels worden verwijderd en door slechts één regel toe te voegen blijft het eindresultaat toch hetzelfde.
Dus deze 4 regels kunnen weg :
4. // #include <sstream>
16. // string mystr;
24. //getline(cin, mystr);
25. //stringstream(mystr) >> yours.year;
En dan slechts één regeltje erbij :
26. cin >> yours.year;
Vroeg me daarom af waarom cplusplus zo omslachtig doet, maar waarschijnlijk alvast één reden valt in dezelfde basic pagina terug te vinden : you should always use getline to get input in your console programs instead of extracting from cin.
In het tweede programma op de structures webpagina, met het voorbeeld // array of structures , wou ik dezelfde vereenvoudiging toepassen maar liep zoals beschreven tegen een cin-probleem aan en helaas herkende ik het niet als zodanig en dacht (gemakshalve) dat dit in verband stond met de stringstream verwijdering.
[Cin-ignore]
daar kom ik later in een edit op terug om het voor mezelf nog eens op een rijtje te zetten en voor eventuele andere geïnteresseerden en is natuurlijk niet als uitleg aan jou bedoeld.
Pas na het antwoord van hazzytje besefte ik dat ik een geskipte cin al eerder had meegemaakt en daar zelfs drie uur mee bezig was en is dan best teleurstellend dat er in mijn gaten geheugen geen lampje ging branden.
kitao in "[C++] Programmeren Beginnersvraag(en)"
Als zijspoor detail , daar staat vermeld dat bij gebruik van
cin.ignore(numeric_limits<streamsize>::max(), '\n');
er een #include <limits> vermeld moet staan boven main.
Had dat niet zelf verzonnen maar blijkt dus niet te kloppen (?).
Een andere (zeer) uitgebreide uitleg heb ik hier na lopen testen, het gedeelte over ene Wlodarczyk :
https://stackoverflow.com...gnore-after-reading-input
Ik begrijp nu beter de oorzaak, de spatie veroorzaakt (zonder een aanwezige getline) in feite twee stringen.
Ik concludeer hieruit dat een 'enter' , zoals in mijn voorbeeld, hetzelfde effect heeft als zo'n spatie (?).
Om deze lange post af te sluiten nog één plaatje waar ik de complexe zin cin.ignore(numeric_limits<streamsize>::max(), '\n');
heb vervangen door het eenvoudigere cin.ignore();
#include <sstream> en string mystr; heb ik verwijderd uit het voorbeeld // array of structures plus de twee regels 27 en 28 die zichtbaar zijn in de afbeelding.
[ Voor 26% gewijzigd door kitao op 05-03-2019 15:10 ]
Somniferous whisperings of scarlet fields. Sleep calling me and in my dreams i wander. My reality is abandoned (I traverse afar). Not a care if I never everwake.
@farlane
In VS17 was het prima leesbaar maar bedankt voor de tip, zal er volgende keer een code=c++ van maken.
En je hebt gelijk, het boek veronderstelt enige basiskennis en daarom heb ik het tot nu toe nog niet afgedaan, bovendien ging hij het subhoofdstukje erna toch in op structs. Misschien te vroeg gejammerd.
Maar had enig nut, andere geïnteresseerden hoeven nu niet meer de codes uit een pdf te kopiëren.
In VS17 was het prima leesbaar maar bedankt voor de tip, zal er volgende keer een code=c++ van maken.
En je hebt gelijk, het boek veronderstelt enige basiskennis en daarom heb ik het tot nu toe nog niet afgedaan, bovendien ging hij het subhoofdstukje erna toch in op structs. Misschien te vroeg gejammerd.
Maar had enig nut, andere geïnteresseerden hoeven nu niet meer de codes uit een pdf te kopiëren.
Het gaat vooral om de indenting en wat witregels hier en daar, daar gaat code=c++ je niet bij helpen:
@farlane
In VS17 was het prima leesbaar maar bedankt voor de tip, zal er volgende keer een code=c++ van maken.
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
