THMMY.gr

ειδα λιγο τα θεματα feb_2003 και εκανα τα αντιστοιχα προγραμματα...για μελετη πριν τις εξετασεις οποιος μπορει ας ανεβασει και αλλα θεματα στο downloads ή προγραμματα-λυσεις των ηδη υπαρχοντων θεματων.

Ανεβάζω με μικρές διορθώσεις το 1ο Θέμα που είχε ανεβάσει ο edenaxas..

οντως στο πρωτο θεμα ειχα κανει λαθος στην υλοποιηση στην κλαση D ως προς τον επικαλυπτομενο τελεστη...sorry! :)

λίγο αργά μάλλον, αλλά 2 ερωτήσεις..

1) Γιατί virtual public A, οι κλάσεις B και C ?
2) το d.d τι συμβολίζει? (είδα και d.n και d.a[ί] κτλ)
   είναι το κλασσικό object.function() ή όχι?

Για το 1, δες τις σημειώσεις.. παράγραφος 6.3 (ή 4.2. και 4.3)..

Προφανώς στο πρόγραμμα δε χρειάζονται και η B και η C.. τις βάζει απλώς για να τεστάρει αυτό το σημείο..

2) Στη συνάρτηση του operator έχουμε όρισμα ένα αντικείμενο τύπου D.. που ονομάζεται d.. και στην κλάση D έχουμε μία private μεταβλητή d... Οπότε το d.d καλεί τη μεταβλητή d του αντικειμένου d... :P

μολις τωρα εριξα μια γρηγορα ματια στη λυση αυτη....

1)
η virtual public A δε χρειαζεται και προσωπικα πρωτη φορα βλεπω κατι τετοιο με τη συγκεκριμενη συνταξη?!?....

2)
οχι ωρε,...d.d, d.n κλπ ειναι ουσιαστικα οι αντιστοιχες μεταβλητες d,n του αντικειμενου d....επισης η μεταβλητη d ειναι και αχρειαστη και δε ζητηται....

Τh@nx!
Τις μεταβλητές αυτές, δεν τις βλέπουμε και με scope resolution (δλδ D::d, D::n) ή πάλι μλκία είπα??


χμμ, το κατάλαβα!
αλλά, αν τις βάζαμε κατευθείαν d και n, δεν θα ήταν σωστό?
μήπως έχουμε αντίγραφο του αντικειμένου, γι' αυτό το κάνουμε?

κοιτα μολις εριξα και μια ματια στο vitual που αναφερεται ο juan ειναι ασχετο με την ασκηση,...χρησιμοποιειται για απομονωση του προβληματος του scope....

το scope που λες το χρησιμοποιεις μοναχα οταν υπαρχει περιπτωση συγχυσης μεταβλητων,...πχ σε κληρονομικοτητα να εχει 2 μεταβλητες ιδιου ονοματος....ετσι αν θες να προσπαλασεις συγκεκριμενα καποιας κλασης, προσθετεις το scope...αν ειναι διαφορετικα τα ονοματα δεν ασχολεισαι...τωρα αν εχεις ιδια ονοματα και δε βαλεις το scope δεν ειμαι βεβαιος αλλα νομιζω το default κοιταζει πρωτα τις μεταβλητες τις ιδιας κλασεις απο την οποια καλειται....

ειναι αναλογα με την αλληλουχια κληρονομικοτητας που εχεις... αλλη φορα δινει το μελος της ιδιας της κλασης αλλη οχι...

Μία κάπως διαφοροποιημένη λύση του 2ου Θέματος..

..πώς σας φαίνεται?

επιπλεον τωρα που ειδα την ασκηση, εχω βαλει το Virtual στις κληρονομησεις των b Και c επειδη στην επικαλυψη του τελεστη [] πρεπει να κανεις ελεγχο αν το k που μπαινει σαν παραμετρος ειναι μεγαλυτερος ή οχι του n που αναφερεται στην κλαση Α, η οποια φαινεται σε δυο κλασεις ως βασικη. αρα υπαρχει ασαφεια και για ναμην χρησιμοποιω scope resolution κανω virtual τις b κ' c...

αυτα.

βασικα καλυτερα ετσι..

καλα ξαναειδα τη λυση του 1ου και εφριξα..
τη μεγαλη μλκια τν εχω κανει στην D που κανω στο τελος d[d] ειναι τελειως λαθος...
κανονικα πρεπει να υπαρχει στην επικαλυψη του τελεστη [] παραμετρος (int k) αντι για (D d)...

έλα μωρέ.. δε βαριέσαι :P  :D

ε, μαλλον οταν τις εγραφα βαριομουνα :D

Διαβάζοντας διόρθωσα και το πρόγραμμα-λύση του edenaxas στο 1ο θέμα.
Είναι ίδιο με μερικές αλλαγές κυρίως στο κομμάτι main και στην κλάση D.
Νομίζω είναι σωστό. :)

γιατι στη συναρτηση αρχικων συνθηκων γραφει B:: B(int k) κ οχι B::B(int k ): A() ? δεν ειναι απαραιτητο?

Ρε παιδιά δεν καταλβαίνω πως βγαίνει το 3ο θέμα... >:(.
αντίστοιχο τμήμα μέσα στη θεωρία υπάρχει πουθενά.?Please
 λίγο γρήγορα,κάποιος.

Το πρόγραμμα όπως και να έχει, ζητάει στην main να φτιάξουμε μόνο αντικείμενο D. Άρα όλες οι τιμές αρκεί να δωθούν από την συνάρτηση δόμησης της D.
Αν βάζαμε αυτό που λες στην Β, τότε νομίζω θα υπήρχε πρόβλημα. Γιατί φτιάχνοντας αντικείμενο κλάσης D έχουμε για την δόμησης:

D::D(int k):A(),B(k),C(k)

Καλείται η δόμησης της Α, που φτιάχνει τον πίνακα a.
Μετά καλείται η δόμησης της Β.
Αν είχαμε B::B(int k ): A() τότε η δόμησης της Β καλεί και την δόμησης της Α ξανά. Οπότε, ξαναορίζουμε τον α που δεν χρειάζεται, και νομίζω έτσι κι αλλιώς ο compiler θα έβγαζε πρόβλημα...Αν και δεν το δοκίμασα!



Δεν υπάρχει κάτι αντίστοιχο στην θεωρία από ό,τι είδα. Το βασικό που πρέπει να καταλάβεις νομίζω είναι ότι:
C c(3,2),*p;
int K,M;
p=&c;
K=*(int *)p;

O pointer p σε αντικείμενο κλάσης C, με την (int *)p; γίνεται pointer σε δεδομένο int. Βάζοντας * από μπροστά, έχουμε το περιεχόμενο του pointer p σε int, στην ίδια θέση που είναι η αρχή του c (λόγω του p=&c;).
Με την ίδια λογική έχεις για τα άλλα.

π.χ. K=*(  ( (int *)p )+1  ). 
Εδώ έχεις το περιεχόμενο του pointer p σε int όχι στην αρχική θέση, αλλά σε θέση +int (=2byte) πιό μακρυά. Άρα θα έχεις το δεύτερο στην σειρά στοιχείο του c.

Τονίζω ότι δεν είμαι 100% σίγουρος για αυτά, ούτε εγώ τα έχω διαβάσει κάπου στην θεωρία :(

αρα τι εκτυπωνει εδω ρε σεις??

Καλημέρα,
ο edenaxas στο πρώτο post που έχει ανεβάσει τις λύσεις ,γράφει  και τι θα εκτυπώσει το πρόγραμμα στο τέλος:

2 3
3 1
5 3
3 1

σορρυ νομιζα οτι ειχε ανεβασει μονο το πρωτο θεμα κ κατεβασα το διορθωμενο του πιο μετα

Παιδιά μπορεί κανείς να εξηγήσει λίγο την λογική στο πώς τα εκτυπώνει αυτά??

d=(A *)&c

θετει τη διευθυνση του αντικειμενου c στον pointer που ειναι τυπου Α.Αρα που δειχνει?στα στοιχεια του Α η του C??
γτ εμφανιζει 5 3??

Εγώ πως το καταλαβαίνω..

Λοιπόν ορίζει το Α *d. Δηλαδή  pointer που δείχνει σε αντικείμενο Α.
Στην συνέχεια κάνει το type casting d = (A*) &c;
Αυτο σημαίνει ότι πλέον ο d δείχνει στο αντικείμενο c.
ΑΛΛΑ δείχνει πλεόν θέσεις μνήμης χωρητικότητας του Α. Δηλαδή ο Α έχει 4 bytes
μνήμης. 2 bytes  για τον k  και   2 bytes  για τον m.

Σκέψου την αντίστοιχη πχ d = ( int *) &c
Σε αυτή την περίπτωση ο d έχει την διέυθυνση του c. Αλλά δείχνει σε ακεραίους. Αυτο πχ στην επόμενη εντολη *(d+1) θα πήγαινε στον επόμενο ακέραιο δηλαδή στο Α::m..

Στην δικία μας περίπτωση όμως το *(d+1) θα περάσει τα 4 bytes του d και θα δείχνει πλέον στα 4 bytes του Β. Η κλάση C ως παραγόμενη έχει στην μήμνη της
(4 bytes A, 4 bytes B, 4 bytes C)..

Δηλαδή το Α είναι 4 bytes...

Ελπίζω να βοήθησα.

Επίσης μέσα στον Constructor της C k=t+l; όχι k=t+1
Ετσι?? γιατί αλλιώς δεν βγαίνει το κ=3 και m= 1 . Κανονικά θα έπρεπε ΝΟΜΙΖΩ
k=5 kai m= - 1.. Σωστα??

Θεωρώντας λοιπόν ότι C::k=5 C::m=-1, ο πίνακας που βγάζω είναι ο
   2   3
   5   -1
   5    5
   5     -1 ( για αυτό δεν είμαι σίγουρος.. Παίρνει δηλαδή τις τιμές του κ και του m χωρίς καμία αλλαγή?

ρε παιδιά στην σειρα
C::C(int l, int t): A(t,l);

το t του Α είνααι το l του C?? H C::l = A::l ??

nai

Παρ' όλο που όπου και αν το έτρεξα έβγαζε τα αποτελέσματα που είπατε δεν μπορούσα να βρώ γενικά πως ακριβώς γίνεται memory allocation σε non-POD objects. Τελικά βρήκα αυτό στο standard της C++ (C++03):

Chapter 10 - Derived Classes:

The order in which the base class subobjects are allocated in the most derived object (1.8) is unspecified.

από εδώ: http://stackoverflow.com/questions/4837480/objects-with-inheritance-memory-storage/4837836#4837836