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
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 ]