THMMY.gr

Μια ερωτηση για το 3ο θεμα: οταν η μεταβλητη της κλασης ειναι public κ η τιμη της μεταβαλλεται απο μια συναρτηση, οταν βγουμε απο την συναρτηση η τιμη της μεταβλητης θα ειναι η αρχικη η η καινουργια?

τα θεματα πως σας φανηκαν?

δε λεω το 1ο θεμα ενδιαφερον φαινοταν, απο κει κ περα το αφηνω ασχολιαστο.

Δε θέλω να ξέρω αλήθεια :D

Πάντως εγώ έβαλα ότι η τιμή αλλάζει..  :-\

Β Ομάδα ήμουν:

Κι αν θυμάμαι καλά.. τύπωσα:

19
11
15
16
25
29

ή κάπως έτσι..

Το 1ο μου φάνηκε εύκολο σε δουλειά σε σχέση με τα πιο παλιά.. Μία επικάλυψη αρχικών συνθηκών ήθελε ουσιαστικά..

Το 2ο ήταν σχετικά κλασικό θέμα..

..και το 3ο νομίζω πιο εύκολο από τα αντίστοιχα που είχα δει με pointers κτλ..

κγω ιδιες τιμες βρηκα εκτος την τεταρτη που την εβαλα 29. την τιμη του m στην κλαση Α δεν βαζαμε? η την τιμη που ειχε για την fun?

Νομίζω ότι αλλάζει.

Τα θέματα δεν ήταν δύσκολα.Αν καταλάβαινες στο 1ο ότι χρειάζεται virtual συνάρτηση,λυνόταν εύκολα.Τα άλλα ήταν κλασσικά.

3ο θέμα (Α) έβγαλα (αν θυμάμαι καλά):
9
3
5
7
8
6

Ελπίζω να'ναι σωστό.Ας το επιβεβαιώσει κάποιος (εννοείται δε δέχομαι διάψευση  >:()

εγω Β ε.
Στο 3ο θεμα το τεταρτο νουμερο εγω το βαλα οτι εχει αλλαξει απο την fun. τεσπα θα δειξει.

19     Aυτα πρεπει να ειανι τα σωστα κιλας στο Β .
11
15
16
25     Το 1ο θέμα λυνοταν μοον με τη περπατημενη?(3 κλασεις εκ των οποιων οι 2 παραγομενες και μια συναρτηση virtual)?
29
         γιατι εγω το προσπαθησα με 1 κλαση(..μαλλον μπουρδα..)

Λογικά μόνο με virtual γινόταν,γιατί όαν ρώτησε κάποιος πως λύνεται,ο Κορτέσης είπε ότι το έχει κάνει στο μάθημα,άρα αυτό εννοούσε και μάλλον θα έχει φροντίσει να μην υπάρχει άλλος τρόπος.Κι εγώ μέχρι να καταλάβω ότι θέλει virtual όσο κι αν το πάλεψα δεν βρήκα άλλο τρόπο.

τον operator < πως των επικαλύψατε με ostream or istream?
 εγώ έτσι την έκανα  αλλα ο compliler βγάζει λάθος  :(

ostream &operator<(ostream &s,A b)
{
   int i;
   for(i=0;i<b.n;i++)
   {
      if(b.numbers%2==0)
      s<"numbers["<<i<<"]= "<<b.numbers<<"\n";
   }

   return s;
}

το βρήκα το λάθος ήθελε να γράψω
s<<"numbers["<<i<<"]= "<<b.numbers<<"\n";
αντι για
s<"numbers["<<i<<"]= "<<b.numbers<<"\n";

και τελικά επικαλύπτετε μόνο με ostream άσχετα αν έλεγε insertor

Το ίδιο αποτέλεσμα για το 3ο θέμα..

Κι εγώ το ίδιο για το 3 από Α ομάδα.
Εγώ δεν ήμουν σίγουρος ότι κρατιούνται δύο μεταβλητές m σε διαφορετικές θέσεις μνήμης...

Και (όπως πάντα αντίθετα από τους άλλους) εμένα μου φάνηκε κλασικό το πρώτο θέμα, ήταν μόνο virtual, ενώ το δεύτερο ήθελε πολλά πράγματα. Πχ, κάπου έπρεπε η main να αλλάξει τιμές ενός private στοιχείου της κλάσης. Το έκανα με τον τελεστή ".*", σωστό είναι;

Παιδιά.. εγώ το 1ο το έκανα με μία κλάση, βάζοντας την κατάλληλη συνάρτηση αρχικών συνθηκών κάθε φορά.  :-\

Η συνάρτηση είχε 2 μεταβλητές (Κόστος , Απόδοση) και διάλεγες τον τύπο του εργοστασίου ανάλογα με τα ορίσματα που έβαζες στις αρχικές συνθήκες..

Έτσι και η compare.. δε χρειάζεται καμία αλλαγή σε περίπτωση που προσθέσης νέο τύπο..

Λάθος..?

(Ομάδα Β πάντα ε..)

9-x-5-x--x-6
τα x δεν τα θυμάμαι, αλλά μάλλον τα έχω διαφορετικά (και λάθος.. ^tomato^)

πιάνει τα μισά σωστά, ή την κόβει όλη?

ποσα ορισματα εβαλες σε καθε μια?
παντως επρεπε να μας το λεει κανονικα γιατι δν γινεται να ξερουμε ποσα χρειαζεται για καθε τυπο.

Στο ηλιακό είχαμε 3 ορίσματα και στο πετρελαίου 4..

Γι' αυτό βασικά το έκανα έτσι...

για αλλες περιπτωσεις ομως???

Αν έχεις διαφορετική ποσότητα (ή τύπο) ορισμάτων... απλώς προσθέτεις μία συνάρτηση αρχικών συνθηκών..

Αλλιώς.. ενδεχομένως μπορείς να κάνεις αλλαγές.. βάζοντας παραγόμενες κλάσεις από την 1η.. αλλά πάλι δε θα χρειαστεί να πειράξεις την compare, το οποίο είναι και ο μόνος περιορισμός.

λογικο ακουγεται. αλλα δεν το σκεφτηκα ετσι.... ^aytoxeir^

Αν κάποιος έχει πάρει τα θέματα ας τα ανεβάσει να τα δούμε κι εμείς που δεν προλάβαμε να δώσουμε το μάθημα...thanx

και εγω πανω κατω σαν τον juan το εκανα ,απλα εβαζα 2 τιμες στην κλαση ,αφου 1α εβρισκα την αποδοση και το κοστος στην main().και εβαλα ως public την compare(A a,A b)

ostream &operator<(ostream &s,A b)
{
   int i;
   for(i=0;i<b.n;i++)
   {
      if(b.numbers%2==0)    --------------------------------------------------------------->εδω νομιζω θελει *( b.numbers+i) ή b.numbers(i)   %2==0
      s<"numbers["<<i<<"]= "<<b.numbers<<"\n";------------------------------->και εδω
                                                                                                          ισχυει?
   }                                                                                                     

   return s;
}

Είμαι σχεδόν σίγουρος ότι ο Κορτέσης στο πρώτο θέμα ήθελε να δει virtual συνάρτηση. Βέβαια πολλούς έχω ακούσει να το κάναν με άλλους τρόπους και ψιλοκάλυπταν αυτά που ζητούσε (δηλαδή να είναι μια συνάρτηση ανεξάρτητη από το είδος της παραγωγής ή του σχήματος του αγρού). Αλλά απλά νομίζω ότι δεν ήθελε αυτό...

Κοίτα..

μια φορά κι έναν καιρό..

μου ζήτησαν να δω αν είναι ένας αριθμός άρτιος ή περιττός.

Εγώ δε γνώριζα τότε τον τελεστή του υπολοίπου. Οπότε ύψωσα έναν αρνητικό αριθμό στη δύναμη του αριθμού που έψαχνα να βρω τί είναι.. και είπα πως αν το αποτέλεσμα είναι θετικός.. τότε είναι άρτιος. Αλλιώς είναι περιττός.

Το αποτέλεσμα είναι σωστό. Αν το ήθελαν με τον τελεστή... ας μου το έλεγαν από πριν ;)

Βρεεε Χουάν!
Δεν εννοούσα αυτό! Πολύ καλή σκέψη και ολόσωστο αυτό που έκανες.
Εγώ όμως έλεγα για το 1ο θέμα. Η ομάδα Α είχε κάτι με αγρούς και η ομάδα Β αν δεν κάνω λάθος με παραγωγή ηλεκτρικής ενέργειας. Φαντάζομαι θα ήταν ίδια φιλοσοφία. Σε αυτό ήθελε να δει τη virtual... (δηλαδή πολυμορφισμό κατά το χρόνο εκτέλεσης)

μπορει να μου εξηγησει καποιος ποια συναρτηση κανατε virtual?

λοιπον, ετσι οπως το σκεφτομαι δεν μπορεις να κανεις virtual συναρτηση επειδη, αν κανεις μια abstact κλαση η οποια θα κληρονομειται καθε φορα απο καποιο καινουριο συστημα παραγωγης, πρεπει να εχεις συγκεκριμενο περιορισμο στα ορισματα αυτης της κλασης, ετσι εχεις προβλημα καθως καθε συστημα εχει διαφορετκο τροπο για να υπολογιζει το κερδος/αποδοτικοτητα του(3 ή 4 ορισματα). αν προσπαθησεις να κανεις virtual και δεν εχεις συμφωνια στα ορισματα των παραγομενων, δεν μεταγλωττιζεται, ενω αν κανεις προεπιλεγμενα ορισματα, δεν εχεις σωστο πολυμορφισμο (περιοριζεις τις δυνατοτητες σου).
δευτερον, η ασκηση ελεγε οτι πρεπει να διαβαζει η main και μπλα μπλα... αρα δεν μπορεις να μην χρησιμοποιησεις ορισματα για το κοστος/αποδοτικοτητα. ετσι ωστε πχ να διαβαζει η virtual καθε παραγομενης τα στοιχεια που χρειαζεται...
με τον περιορισμο του να διαβαζεις στην Main και να δινεις τον ελεγχο καπου, και με το οτι δεν μπορεις να εχεις περιορισμενων δυνατοτητων κωδικα, ο μονος τροπος υλοποιησης που βλεπω εγω ειναι με καποιες μεταβλητες, οπως λεει o juan...

Η virtual συνάρτηση θα είναι η float say_area(void)
Δε χρειάζεται ορίσματα, αφού οι μεταβλητές που θα χρησιμοποιεί είναι μέλη του αντικειμένου για το οποίο καλείται.

Επειδή η main διαβάζει τις τιμές (πχ μήκος-πλάτος ή ακτίνα κυκλικού αγρού), ο constructor κάθε (παραγόμενης) κλάσης θα παίρνει ως ορίσματα αυτές τις τιμές και θα θέτει τις μεταβλητές του αντικειμένου ίσες με αυτές τις τιμές. Βέβαια θα πρέπει πρώτα να διαβάζονται οι τιμές από τη main και μετά να δημιουργούνται τα αντικείμενα.

βασικα ετσι χρησιμοποιεις τη λογικη sony και καλα χρησιμοποιω virtual ακομα και αν δεν χρειαζεται, μιας; και η συναρτηση που κανεις virtual ουσιαστικα ειναι πλεονασμος, καθως α)την ενεργεια που κανεις μπορει καλλιστα να την κανεις στην συναρτηση δομησης και β)η ουσια της υλοποιησης σου ειναι ετσι η αλλιως οι κοινες μεταβλητες σε ολες τις κλασεις τις οποιες με τον ενα ή τον αλλο τροπο τροποποιεις.anyway we'll see :D

Δεν έχω ίδιες μεταβλητές σε όλες τις κλάσεις. Η μία παραγόμενη έχει μόνο τη μεταβλητή "ακτίνα" και η άλλη παραγόμενη μόνο τις μεταβλητές "μήκος" και "πλάτος".

Μάλλον δεν κατάλαβες τον τρόπο που δουλεύει η virtual συνάρτηση, άρα και το τι κερδίζουμε χρησιμοποιώντας την.
Με virtual συναρτήσεις δε χρειάζεται έλεγχος ούτε για ορίσματα, ούτε για "κρυφές" μεταβλητές που μου λένε τι τύπος είναι το αντικείμενο. Κάθε υλοποίηση της virtual λειτουργεί σαν να υπήρχαν αντικείμενα μόνο του τύπου για τα οποία δουλεύει.

Τελικά, κάθε αντικείμενο έχει και τις δικές του μεταβλητές και τις δικές του συναρτήσεις που δουλεύουν πάνω σε αυτές τις μεταβλητές. Όταν διαφορετικοί τύποι αντικειμένων έχουν συνάρτηση με ίδιο όνομα (δηλαδή virtual), τότε, καλώντας αυτή τη συνάρτηση δεν ξέρουμε τι θα εκτελεστεί. Εξαρτάται από τον τύπο του αντικειμένου που την καλεί!

χαιρω πολυ! αδερφε ξερω πως λειτουργουν οι virtual συναρτησειs
στειλε σε Pm τον ενα προχειρο κωδικα με την υλοποιηση σου...θα σου στειλω κι εγω οταν εχω χρονο

Ok. Θα ανεβάσω εδώ όταν έχω χρόνο, γιατί pm;

class agros{
public:
virtual float say_area(void)=0;
};

class circle:public agros{
float aktina;
public:
float say_area(void);
circle(r); // constructor που δίνει τιμή στην ακτίνα
};

class box:public agros{
float mikos,platos;
public:
float say_area(void);
box(m,p); // constructor που δίνει τιμή σε μήκος και πλάτος
};

float circle::say_area(void)
{
return aktina*aktina*3,14;
}

float box::say_area(void)
{
return mikos*platos;
}

void D_area(agros* p1, agros* p2, apodotikotita)
{
float area1=p1->say_area();
float area2=p2->say_area();
epidotisi = apodotikotita*(area1-area2); // εδώ παραλείπω λεπτομέρειες
}

void main()
{
float r,m,p,apodotikotita;
cin >> r >> m >> p;
circle obj1(r);
box obj2(m,p);
agros *p1,*p2;
p1=&obj1;
p2=&obj2;
D_area(p1,p2,apodotikotita);
}

Το χαρακτηριστικό αυτού του κώδικα είναι ότι η D_area δε γνωρίζει τίποτα για τον τύπο των αντικειμένων που εισάγονται.
Θα μπορούσαμε να προσθέσουμε και άλλους τύπους αγροκτημάτων (πχ τρίγωνα), προσθέτοντας απλώς μια κλάση και δημιουργώντας για αυτήν την αντίστοιχη say_area(void) συνάρτηση

Είδα τα αποτελέσματα από το ethmmy.

Απογοητεύτηκα πλήρως, έκανα τα 2 προγράμματα ολόκληρα, την τρίτη άσκηση περίπου και πήρα 3.

Ξέρετε αν μπορούμε να δούμε τα γραπτά;

Την Τρίτη 10:30 με 11:30 το πρωί.Έχει ανακοίνωση εκεί που έχει αναρτήσει τα αποτελέσματα.

Ρε παιδιά όλα καλά με τη virtual συνάρτηση και την υλοποίηση που ανέβασε ο Junior (ο Κορτέσης σίγουρα αυτό ήθελε να δει,γιατί όσοι έκαναν virtual πήραν καλό βαθμό, ενώ οι υπόλοιποι όχι από ότι συζήτησα με συναδέλφους).Το θέμα όμως ζητούσε η compare να είναι ανεξάρτητη από τις εισόδους κάτι το οποίο γίνεται και χωρίς virtual, όπως προανέφερε ο Juan. Αυτό δεν ήταν το σημαντικότερο ζήτημα. Και οι δύο τρόποι δε θα έπρεπε να είναι σωστοί; Αν κάνω λάθος ας με διορθώσει κάποιος. Ξέρω πως λειτουργεί η virtual, αλλά στο συγκεκριμένο θέμα θεώρησα περιττό να τη χρησιμοποιήσω.

λοιπον... στο ethmmy λεει οτι πηρα 5.... ομως δεν εχω κανει εργασιες...... περασα????

Όταν το συζητούσα μετά την εξέταση είχα ακούσει έναν τρόπο χωρίς virtual που φαινόταν σωστός, αλλά δεν το έψαξα σε βάθος. Μπορείς να εξηγήσεις πώς ακριβώς θα γινόταν χωρίς virtual να έχουμε και άλλους τύπους εργοστασίων ή αγρών (με ίδιο αριθμό ορισμάτων!);

Aκριβώς όπως ανέφερε παραπάνω ο Juan...Απλά αλλάζεις τη συνάρτηση αρχικών συνθηκών με τις νέες μεταβλητές που θέλεις και αυτή δίνει το ζητούμενο για την απόδοση της κλάσης σου.Έτσι δεν πειράζεις καθόλου την compare, στην οποία δίνεις με pointer την κλάση και μπορείς κάθε φορά αλλάζοντας την κλάση ή προσθέτοντας μια καινούρια να κάνεις όσες συγκρίσεις θέλεις χωρίς να πειράζεις την compare. Αυτό δεν είναι το ζητούμενο της άσκησης; Να είναι ανεξάρτητη η compare;

Κατά την άποψη μου ο κάθε πρόγραμμα έχει παραπάνω από μια υλοποιήσεις και μετά από διάφορες συζητήσεις που έκανα με συναδέλφους πιστεύω ότι και αυτός ο τρόπος υλοποίησης είναι σωστός.Θεωρώ ότι είναι άδικο να χάνει κάποιος όλη την άσκηση επειδή δε χρησιμοποίησε virtua.l

εχεις μια βασικη κλαση πχ. την Α. σε αυτην οριζεις τις μεταβλητες που θα χρησιμοπιηθουν στην compare ως public μεταβλητες. επειτα με βαση τι θες να κανεις, (εργοστασιο, αγρο, κτλ) δημιουργεις μια αλλη κλαση η οποια κληρονομει την A ως public παραγομενη, ετσι εχει αμεση προσβαση στις παραπανω μεταβλητες. τωρα στο καθε παραγομενο συστημα, οριζεις ετσι τις συναρτησεις δομησης ετσι ωστε να διαμορφωνεις ξεχωριστα καθε φορα τις μεταβλητες της κληρονομουνενης Α μεσα απο την κλαση σου, χρησιμοποιωντας οσα και οποια ορισματα θες (εξοδα συντηρησης, κοστος καυσιμου, κερδος, αποδοση κτλ...) στην compare βαζεις σαν ορισματα δυο pointer σε αντικειμενα τυπου Α.στην main σου τωρα, οριζεις τα αντικειμενα που θες, βαζεις τα ορισματα σου κατα την δημιουργια των αντικειμενων σου. το κεντρο της υλοποιησης ειναι οτι οριζεις και δυο ποιντερ σε αντικειμενα τυπου Α στα οποια δινεις τις διευθυνσες των αλλων αντικειμενων απο τις παραγομενες κλασεις. αυτους τους δυο ποιντερ δινεις στην compare και κανεις τη δουλεια σου..
πραγματικα οταν βρω χρονο θα ανεβασω τον κωδικα με την υλοποιηση ετσι οπωως ηταν στα δικα μας τα θεματα, με σταθμους παραγωγης ηλ.ενεργειας και συγκριση αποδοτικοτητας...
to be continued...

Ok, πιστεύω καταλαβαίνω αυτό που λέει ο edenaxas

Δηλαδή χρησιμοποιείτε τη λογική των virtual συναρτήσεων, δηλαδή pointer παράγουσας που δείχνει σε παραγόμενη, αλλά το κάνετε μόνο για να χρησιμοποίησετε μεταβλητές και όχι συναρτήσεις. Και στις μεταβλητές αυτές δίνετε τιμές με τους constructors.

Πράγματι φαίνεται σωστό. Δεν είχα σκεφτεί ότι μπορεί να έχει νόημα αυτό με τους pointers χωρίς virtual συνάρτηση. Βέβαια έτσι αναγκαζόμαστε να έχουμε public μεταβλητές, τις οποίες μάλιστα καθορίζουμε με constructors, αλλά δεν αναφερόταν ότι δεν επιτρέπεται να το κάνουμε. Θα πρέπει να το συζητήσετε με τον κ. Κορτέση.

Πρέπει να σιγουρευτείτε αν το συγκεκριμένο το παίρνει για λάθος (μήπως είχατε κάπου αλλού λάθος;). Οι περισσότεροι πάντως που δε χρησιμοποίησαν virtual χρησιμοποιούσαν τα ορίσματα για να ξεχωρίσουν τις περιπτώσεις.

κατι σαν επικαλυψη με διαφορετικα ορισματα δηλαδη?


κοιτα με τον τροπο που εκανα ουσιαστικα δν χρησιμοποιω virtual, εκμεταλλευομαιι την κληρονομικοτηττα και την χρηση των ποιντερ, και δν νομιζω οτι η μια υλοποιηση υστερει σε κατι απο την αλλη. ειδικα στον προγραμματισμο μεσα σε 10 ατομα θα βρεις 9 διφορετικες υλοποιησεις για ενα θεμα και μπορει ολες να ειναι σωστες με βαση τους υπαρχοντες καθε φορα περιορισμους, με υστερηση ισως στην αποδωση απο υλοποιηση σε υλοποιηση. αλλα και παλι δεν νομιζω οτι ετσι οπως λεω κανεις εναν "αργο" αλγοριθμο, τουλαχιστον σε σχεση με την αλλη υλοποιηση δν νομιζω οτι εχει διαφορα(-σε τετοια μεγεθη βεβαια δν θα ειχε ετσι κι αλλιως...).

anyway θα δουμε..

στο παρακατω προγραμμα φαινεται μια παρομοια/υποθετικη  υλοποιηση με αυτην που εκανα...

#include <iostream.h>

class A{     
public:
float a,c;
int no;
};

class B:public A{
public:
B(int m,int p);
};

B::B(int m, int p){
   a=m+p;
   c=m*p;
   cout<<"dwse onoma...\n";
        cin>>no;
}

class C: public A{
public:
C(int t);
};

C::C(int t){
   a=t+1;
   c=t-1;
   cout<<"dwse onoma classhs c...\n";
        cin>>no;
}

int compare(A *a,A *b){
   if(a->a>b->a)return a->no;
   else return b->no;
}
void main(){
   A *a1,*a2;
   B b(2,3);
   C c(1);
   a1=&b;
   a2=&c;
   cout<<"megalytero a exei h "<< compare(a1,a2)<<"\n";
}

τελικα δεν ειναι λαθος η ασκηση ετσι οπως την εκανα, αλλα στην εκφωνηση ελεγε " η compare να υπολογιζει και να κανει μπλαμπλα...." ενω εγω υπολογιζω στην constructor και οχι στην compare...
παρολο που η ανοιχτη-κλειστη σχεδιαση ακολουθειται, για την υλοποιηση μου, για αυτο το λαθος, αντι για 4 που επιανε η ασκηση πηρα ενα ωραιοτατο 0.5 για τον κοπο μου.

anyfuckinfreakinway...