Πώς να χρησιμοποιήσετε το C ++ Vector

How Use C Vector



Εισαγωγή

Ένας πίνακας είναι μια σειρά από ίδιους τύπους αντικειμένων σε διαδοχικές θέσεις μνήμης. Μια συστοιχία δεν μπορεί να αυξήσει τη μείωση του μεταλλεύματος σε μήκος. Ένα διάνυσμα είναι σαν ένας πίνακας, αλλά το μήκος του μπορεί να αυξηθεί ή να μειωθεί. Ένα διάνυσμα, επομένως, έχει πολλές περισσότερες πράξεις από έναν πίνακα.

Το C ++ έχει πολλές βιβλιοθήκες, όλες οι οποίες αποτελούν τη Βασική Βιβλιοθήκη C ++. Μία από αυτές τις βιβλιοθήκες είναι η βιβλιοθήκη κοντέινερ. Ένα κοντέινερ είναι μια συλλογή αντικειμένων και ορισμένες λειτουργίες μπορούν να εκτελεστούν στη συλλογή. Τα δοχεία C ++ μπορούν να ομαδοποιηθούν σε δύο σύνολα: δοχεία αλληλουχίας και συσχετισμένα δοχεία. Τα δοχεία αλληλουχίας είναι το διάνυσμα, ο πίνακας (δεν είναι ο ίδιος πίνακας που συζητήθηκε προηγουμένως), το deque, το forward_list και η λίστα. Αυτές είναι διαφορετικές συλλογές (δομές δεδομένων που μοιάζουν με πίνακες) και η κάθε μία προσφέρει ξεχωριστές αντισταθμίσεις.







Οποιοσδήποτε προγραμματιστής πρέπει να ξέρει πώς να αποφασίσει εάν θα χρησιμοποιήσει ένα διάνυσμα, έναν πίνακα, ένα deque, μια λίστα προώθησης ή μια λίστα. Όταν ένας προγραμματιστής χρειάζεται μια δομή που απαιτεί περισσότερες λειτουργίες από αυτές που σχετίζονται με έναν συνηθισμένο πίνακα, ο συνηθισμένος πίνακας δεν πρέπει να χρησιμοποιείται.



Εάν η εργασία περιλαμβάνει συχνές εισαγωγές και διαγραφές στη μέση της ακολουθίας, τότε θα πρέπει να χρησιμοποιηθεί μια λίστα ή λίστα προώθησης. Εάν η εργασία περιλαμβάνει συχνές εισαγωγές και διαγραφές στην αρχή ή το τέλος μιας ακολουθίας, τότε θα πρέπει να χρησιμοποιηθεί ένα deque. Πρέπει να χρησιμοποιείται ένα διάνυσμα όταν δεν απαιτούνται τέτοιου είδους πράξεις.



Αυτό το άρθρο σας δείχνει πώς να χρησιμοποιήσετε το διάνυσμα C ++. Για να κατανοήσετε αυτό το άρθρο, θα χρειαστείτε γνώση δεικτών, αναφορών και συστοιχιών C ++.





Τάξη και Αντικείμενα

Μια κλάση είναι ένα σύνολο μεταβλητών και συναρτήσεων που λειτουργούν μαζί, όπου οι μεταβλητές δεν έχουν εκχωρημένες τιμές. Όταν εκχωρούνται τιμές στις μεταβλητές, μια κλάση γίνεται αντικείμενο. Διαφορετικές τιμές που δίνονται στην ίδια κλάση οδηγούν σε διαφορετικά αντικείμενα. Δηλαδή, διαφορετικά αντικείμενα μπορεί να είναι της ίδιας κλάσης αλλά να έχουν διαφορετικές τιμές. Η δημιουργία ενός αντικειμένου από μια κλάση είναι επίσης γνωστή ως instantiating του αντικειμένου.

Ο όρος διάνυσμα περιγράφει μια κλάση. Ένα αντικείμενο που δημιουργήθηκε από ένα διάνυσμα έχει ένα όνομα που επιλέγεται από τον προγραμματιστή.



Μια συνάρτηση που ανήκει σε μια κλάση είναι απαραίτητη για την παρουσίαση ενός αντικειμένου από την κλάση. Στο C ++, αυτή η συνάρτηση έχει το ίδιο όνομα με το όνομα της κλάσης. Διαφορετικά αντικείμενα που δημιουργήθηκαν (ενδεικτικά) από την τάξη έχουν ξεχωριστά ονόματα που δόθηκαν σε καθένα από αυτά από τον προγραμματιστή.

Η δημιουργία ενός αντικειμένου από μια κλάση σημαίνει την κατασκευή του αντικειμένου. σημαίνει επίσης την άμεση υλοποίηση του αντικειμένου.

Η τάξη του διανύσματος

Η κλάση του διανύσματος έχει ήδη οριστεί και βρίσκεται στη βιβλιοθήκη. Για να χρησιμοποιήσει τη διανυσματική κλάση, ένας προγραμματιστής πρέπει να συμπεριλάβει την κεφαλίδα του διανύσματος στο αρχείο με την ακόλουθη οδηγία προεπεξεργασίας:

#περιλαμβάνω

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

#περιλαμβάνω
#περιλαμβάνω

Παρουσίαση ενός φορέα

intfoo[10]?

Πάνω είναι η δήλωση ενός πίνακα με το όνομα foo και τον αριθμό των στοιχείων 10. Αυτός είναι ένας πίνακας ακέραιων αριθμών. Η δήλωση ενός διανύσματος είναι παρόμοια. Για ένα διάνυσμα, ο αριθμός των στοιχείων είναι προαιρετικός, καθώς το μήκος του διανύσματος μπορεί να αυξηθεί ή να μειωθεί.

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

ώρες::διάνυσμα <int>>vtr(8)?

Εδώ, το διάνυσμα είναι της ειδικής συνάρτησης κατασκευαστή. Ο τύπος δεδομένων που θα κρατήσει το διάνυσμα είναι int, σε αγκύλες γωνίας. Ο όρος vtr είναι το όνομα που επέλεξε ο προγραμματιστής για το διάνυσμα. Τέλος, 8, σε παρένθεση, είναι ο δοκιμαστικός αριθμός ακεραίων που θα έχει το διάνυσμα.

Ο όρος std σημαίνει τυπικός χώρος ονομάτων. Αυτός ο όρος πρέπει να ακολουθείται από διπλή άνω τελεία, σε αυτό το πλαίσιο. Ο καθένας μπορεί να γράψει τη δική του διανυσματική βιβλιοθήκη τάξης και να τη χρησιμοποιήσει. Ωστόσο, το C ++ έχει ήδη μια τυπική βιβλιοθήκη με τυπικά ονόματα, συμπεριλαμβανομένου του διανύσματος. Για να χρησιμοποιήσετε ένα τυπικό όνομα, πρέπει να προηγείται το τυπικό όνομα std ::. Για να αποφύγετε την πληκτρολόγηση std :: κάθε φορά στο πρόγραμμα για ένα τυπικό όνομα, το αρχείο προγράμματος μπορεί να ξεκινήσει ως εξής:

#περιλαμβάνω
#περιλαμβάνω
χρησιμοποιώντας το όνομα χώρου std?

Υπερφόρτωση μιας λειτουργίας

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

Κατασκευή διανύσματος

Η κατασκευή ενός διανύσματος σημαίνει τη δημιουργία (δημιουργία) ενός διανυσματικού αντικειμένου. Η συνάρτηση του κατασκευαστή υπερφορτώνεται ως εξής:

όνομα φορέα

Αυτό δημιουργεί ένα διάνυσμα μήκους μηδέν και τύπου Τ. Η ακόλουθη πρόταση δημιουργεί ένα διάνυσμα μηδενικού μήκους του τύπου float με το όνομα vtr:

διάνυσμα<φλοτέρ>>vtr?

όνομα διανύσματος (n)

Αυτό δημιουργεί ένα διάνυσμα με n στοιχεία τύπου T. Μια δήλωση για αυτό το διάνυσμα με τέσσερα στοιχεία float έχει ως εξής:

διάνυσμα<φλοτέρ>>vtr(4)?

όνομα διανύσματος (n, t)

Αυτό δημιουργεί ένα διάνυσμα n στοιχείων αρχικοποιημένο στην τιμή t. Η ακόλουθη πρόταση δημιουργεί ένα διάνυσμα 5 στοιχείων, όπου κάθε στοιχείο έχει την τιμή 3.4:

διάνυσμα<φλοτέρ>>vtr(5, 3.4)?

Κατασκευή με αρχικοποίηση

Ένα διάνυσμα μπορεί να κατασκευαστεί (δημιουργηθεί) και να αρχικοποιηθεί ταυτόχρονα, με έναν από τους ακόλουθους δύο τρόπους:

διάνυσμα<φλοτέρ>>vtr= {1.1, 2.2, 3.3, 4.4}?

Ή

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?

Σημειώστε ότι δεν υπάρχουν παρενθέσεις αμέσως μετά το όνομα του αντικειμένου. Οι παρενθέσεις που χρησιμοποιούνται αμέσως μετά το όνομα του αντικειμένου πρέπει να έχουν τη λίστα αρχικοποίησης, ως εξής:

διάνυσμα<φλοτέρ>>vtr({1.1, 2.2, 3.3, 4.4})?

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

διάνυσμα<φλοτέρ>>vtr?
vtr= {1.1, 2.2, 3.3, 4.4}?

διάνυσμα V2 (V1)

Αυτός είναι ένας κατασκευαστής αντιγράφων. Δημιουργεί ένα διάνυσμα V2 ως αντίγραφο του διανύσματος V1. Ο παρακάτω κώδικας το δείχνει αυτό:

διάνυσμα<φλοτέρ>>vtr1(5, 3.4)?
διάνυσμα<φλοτέρ>>vtr2(vtr1)?

Εκχώρηση διανύσματος κατά την κατασκευή

Κατά τη διάρκεια της κατασκευής, μπορεί να δημιουργηθεί ένα κενό διάνυσμα, ενώ του αποδίδεται ένα άλλο, ως εξής:

διάνυσμα<φλοτέρ>>vtr1{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ>>vtr2=vtr1?

Η δεύτερη δήλωση ισοδυναμεί με:

διάνυσμα<φλοτέρ>>vtr2= {1.1, 2.2, 3.3, 4.4}?

const Διάνυσμα

Ένα διάνυσμα const είναι ένα διάνυσμα του οποίου τα στοιχεία δεν μπορούν να αλλάξουν. Οι τιμές σε αυτό το διάνυσμα είναι μόνο για ανάγνωση. Όταν δημιουργηθεί, το διάνυσμα εμφανίζεται ως εξής:

constδιάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?

Σε αυτόν τον τύπο διανύσματος, κανένα στοιχείο δεν μπορεί να προστεθεί ή να αφαιρεθεί. Επιπλέον, καμία τιμή δεν μπορεί να αλλάξει.

Κατασκευή με Iterator

Ένα πρότυπο παρέχει μια γενική αναπαράσταση για έναν τύπο δεδομένων. Ένας επαναληπτής παρέχει μια γενική αναπαράσταση της σάρωσης μέσω των τιμών ενός κοντέινερ. Η σύνταξη για τη δημιουργία ενός διανύσματος με έναν επαναληπτή είναι η ακόλουθη:

πρότυπο<class InputIterator>>
διάνυσμα(InputIterator πρώτα,InputIterator τελευταία,constΚατανεμητής& =Κατανεμητής())?

Αυτό δημιουργεί ένα διάνυσμα για το εύρος [πρώτο, τελευταίο] χρησιμοποιώντας τον καθορισμένο κατανεμητή, το οποίο θα συζητηθεί αργότερα σε αυτό το άρθρο.

Καταστρέφοντας ένα διάνυσμα

Για να καταστρέψετε ένα διάνυσμα, απλώς αφήστε το να βγει εκτός εμβέλειας και ο χειρισμός του χειρίζεται αυτόματα.

Διανυσματική ικανότητα

size_type χωρητικότητα () const noexcept

Ο συνολικός αριθμός στοιχείων που μπορεί να κρατήσει το διάνυσμα χωρίς να απαιτείται ανακατανομή επιστρέφεται από τη συνάρτηση μέλους χωρητικότητας. Ένα τμήμα κώδικα για αυτό είναι το ακόλουθο:

διάνυσμα<φλοτέρ>>vtr(4)?
intσε ένα=vtrχωρητικότητα()?
κόστος<<σε ένα<< ' n'?

Η έξοδος είναι 4.

αποθεματικό (n)

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

διάνυσμα<φλοτέρ>>vtr(4)?
vtrΑποθεματικό(6)?
κόστος<<vtrχωρητικότητα() << ' n'?

Η έξοδος είναι 6. Άρα, ο επιπλέον χώρος που δεσμεύεται είναι 6 - 4 = 2 στοιχεία. Η συνάρτηση επιστρέφει άκυρη.

μέγεθος () const χωρίς εξαίρεση

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

διάνυσμα<φλοτέρ>>vtr(4)?
φλοτέρμικρό=vtrΜέγεθος()?
κόστος<<μικρό<< ' n'?

Η έξοδος είναι 4.

shrink_to_fit ()

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

διάνυσμα<φλοτέρ>>vtr(4)?
vtrΑποθεματικό(6)?
vtrshrink_to_fit()?
intμικρό=vtrΜέγεθος()?
κόστος<<μικρό<< ' n'?

Η έξοδος είναι 4 και όχι 6. Η συνάρτηση επιστρέφει άκυρη.

αλλαγή μεγέθους (sz), αλλαγή μεγέθους (sz, c)

Αυτό αλλάζει το μέγεθος του διανύσματος. Εάν το νέο μέγεθος είναι μικρότερο από το παλιό, τότε τα στοιχεία προς το τέλος διαγράφονται. Εάν το νέο μέγεθος είναι μεγαλύτερο, τότε προστίθεται κάποια προεπιλεγμένη τιμή προς το τέλος. Για να έχετε μια συγκεκριμένη προστιθέμενη αξία, χρησιμοποιήστε τη συνάρτηση resize () με δύο ορίσματα. Το ακόλουθο τμήμα κώδικα απεικονίζει τη χρήση αυτών των δύο συναρτήσεων:

διάνυσμα<φλοτέρ>>vtr1{1.1, 2.2, 3.3, 4.4}?
vtr1.αλλαγή μεγέθους(2)?
κόστος<< 'Νέο μέγεθος του vtr1:' <<vtr1.Μέγεθος() << ' n'?
διάνυσμα<φλοτέρ>>vtr2{1.1, 2.2}?
vtr2.αλλαγή μεγέθους(4, 8,8)?
κόστος<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' n'?

Η έξοδος είναι η ακόλουθη:

Νέο μέγεθος vtr1: 2
vtr2: 1,1 2,2 8,8 8,8

Οι συναρτήσεις επιστρέφουν άκυρες.

κενό () const noexcept

Αυτή η συνάρτηση επιστρέφει 1 για true αν δεν υπάρχουν στοιχεία στο διάνυσμα και 0 για false αν το διάνυσμα είναι κενό. Εάν ένα διάνυσμα έχει 4 τοποθεσίες για έναν συγκεκριμένο τύπο δεδομένων, όπως float, χωρίς καμία τιμή float, τότε αυτό το διάνυσμα δεν είναι κενό. Ο παρακάτω κώδικας το δείχνει αυτό:

διάνυσμα<φλοτέρ>>vtr?
κόστος<<vtrαδειάζω() << ' n'?
διάνυσμα<φλοτέρ>>vt(4)?
κόστος<<έτσι ώστεαδειάζω() << ' n'?

διάνυσμα<φλοτέρ>>v(4,3.5)?
κόστος<<v.αδειάζω() << ' n'?

Η έξοδος είναι η ακόλουθη:

1
0
0

Διανυσματική πρόσβαση στοιχείων

Ένα διάνυσμα μπορεί να υπογραφεί (ευρετηριαστεί) όπως ένας πίνακας. Η καταμέτρηση του δείκτη ξεκινά από το μηδέν.

vectorName [i]

Η διανυσματική πράξηName [i] επιστρέφει μια αναφορά στο στοιχείο στο iουδείκτη του διανύσματος. Ο ακόλουθος κώδικας εξάγει 3.3 για το παραπάνω διάνυσμα:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
φλοτέρfl=vtr[2]?
κόστος<<fl<< ' n'?

vectorName [i] const

Η διανυσματική λειτουργία Όνομα [i] const εκτελείται αντί Διανυσματικό Όνομα [i] όταν το διάνυσμα είναι σταθερό διάνυσμα. Αυτή η λειτουργία χρησιμοποιείται στον ακόλουθο κώδικα:

constδιάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
φλοτέρfl=vtr[2]?
κόστος<<fl<< ' n'?

Η έκφραση επιστρέφει μια σταθερή αναφορά στο iουστοιχείο του διανύσματος.

Αντιστοίχιση τιμής με Subscript

Μια τιμή μπορεί να αποδοθεί σε ένα μη σταθερό διάνυσμα, ως εξής:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
vtr[2] = 8,8?
κόστος<<vtr[2] << ' n'?

Η έξοδος είναι 8,8.

vectorName.at (i)

Το vectorName.at (i) είναι σαν το vectorName [i], αλλά το vectorName.at (i) είναι πιο αξιόπιστο. Ο παρακάτω κώδικας δείχνει πώς πρέπει να χρησιμοποιείται αυτό το διάνυσμα:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
φλοτέρfl=vtrστο(2)?
κόστος<<fl<< ' n'?
στο()είναι ένα διάνυσμα μέλοςλειτουργίαΤο

vectorName.at (i) const

Το vectorName.at (i) const είναι σαν το vectorName [i] const, αλλά το vectorName.at (i) const είναι πιο αξιόπιστο. vectorName.at (i) const εκτελείται αντί vectorName.at (i) όταν το διάνυσμα είναι σταθερό διάνυσμα. Αυτό το διάνυσμα χρησιμοποιείται στον ακόλουθο κώδικα:

constδιάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
φλοτέρfl=vtrστο(2)?
κόστος<<fl<< ' n'?
στο() constείναι ένα διάνυσμα μέλοςλειτουργίαΤο

Εκχώρηση τιμής με τη συνάρτηση at ()

Μια τιμή μπορεί να αποδοθεί σε ένα μη σταθερό διάνυσμα με τη συνάρτηση at (), ως εξής:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
vtrστο(2) = 8,8?
κόστος<<vtr[2] << ' n'?

Η έξοδος είναι 8,8.

Πρόβλημα με την υπο-γραφή

Το πρόβλημα με το sub-scripting (ευρετηρίαση) είναι ότι εάν το ευρετήριο βρίσκεται εκτός εμβέλειας, μπορεί να επιστρέψει μηδέν ή να εκδοθεί σφάλμα κατά την εκτέλεση.

εμπρός()

Αυτό επιστρέφει μια αναφορά στο πρώτο στοιχείο του διανύσματος χωρίς να αφαιρεθεί το στοιχείο. Η έξοδος του ακόλουθου κώδικα είναι 1.1.

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
φλοτέρfl=vtrεμπρός()?
κόστος<<fl<< ' n'?

Το στοιχείο δεν αφαιρείται από το διάνυσμα.

εμπρός () const

Όταν η κατασκευή του διανύσματος προηγείται από const, η έκφραση front () const εκτελείται αντί για front (). Αυτό χρησιμοποιείται στον ακόλουθο κώδικα:

constδιάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
φλοτέρfl=vtrεμπρός()?
κόστος<<fl<< ' n'?

Επιστρέφεται μια σταθερή αναφορά. Το στοιχείο δεν αφαιρείται από το διάνυσμα.

πίσω()

Αυτό επιστρέφει μια αναφορά στο τελευταίο στοιχείο του διανύσματος χωρίς να αφαιρεθεί το στοιχείο. Η έξοδος του ακόλουθου κώδικα είναι 4.4.

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
φλοτέρfl=vtrπίσω()?
κόστος<<fl<< ' n'?

πίσω () const

Όταν η κατασκευή του διανύσματος προηγείται από const, η έκφραση back () const εκτελείται αντί για back (). Αυτό χρησιμοποιείται στον ακόλουθο κώδικα:

constδιάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
φλοτέρfl=vtrπίσω()?
κόστος<<fl<< ' n'?

Επιστρέφεται μια σταθερή αναφορά. Το στοιχείο δεν αφαιρείται από το διάνυσμα.

Πρόσβαση σε διανυσματικά δεδομένα

δεδομένα () εκτός από δεδομένα () const χωρίς εξαίρεση

Καθένα από αυτά επιστρέφει έναν δείκτη έτσι ώστε [δεδομένα (), δεδομένα () + μέγεθος ()) να είναι έγκυρο εύρος.

Αυτό θα καλυφθεί με μεγαλύτερη λεπτομέρεια αργότερα στο άρθρο.

Επιστρέφοντας επαναλήπτες και το διάνυσμα

Ένας επαναληπτής είναι σαν δείκτης αλλά έχει περισσότερη λειτουργικότητα από έναν δείκτη.

Έναρξη () χωρίς εξαίρεση

Επιστρέφει έναν επαναληπτικό που δείχνει το πρώτο στοιχείο του διανύσματος, όπως στο ακόλουθο τμήμα κώδικα:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ> ::επαναληπτηςiter=vtrνα αρχίσει()?
κόστος<< *iter<< ' n'?

Η έξοδος είναι 1.1. Σημειώστε ότι η δήλωση που λαμβάνει τον επαναληπτή έχει δηλωθεί. Ο επαναλήπτης παραπέμπεται σε μια παράσταση επιστροφής για να λάβει την τιμή με τον ίδιο τρόπο που καταργείται η αναφορά ενός δείκτη.

Έναρξη () const noexcept?

Επιστρέφει έναν επαναληπτικό που δείχνει το πρώτο στοιχείο του διανύσματος. Όταν προηγείται η κατασκευή του διανύσματος με const, η έκφραση begin () const εκτελείται αντί να ξεκινήσει (). Υπό αυτή τη συνθήκη, το αντίστοιχο στοιχείο στο διάνυσμα δεν μπορεί να τροποποιηθεί. Αυτό χρησιμοποιείται στον ακόλουθο κώδικα:

constδιάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ> ::const_iteratoriter=vtrνα αρχίσει()?
κόστος<< *iter<< ' n'?

Η έξοδος είναι 1.1. Σημειώστε ότι το const_iterator έχει χρησιμοποιηθεί αυτή τη φορά αντί για τον επαναληπτή για να λάβει τον επαναλαμβανόμενο επαναλήπτη.

τέλος () εκτός από

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

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ> ::επαναληπτηςiter=vtrτέλος()?
κόστος<< *iter<< ' n'?

Η έξοδος είναι 0, η οποία δεν έχει νόημα, καθώς δεν υπάρχει συγκεκριμένο στοιχείο πέρα ​​από το τελευταίο στοιχείο.

end () const noexcept

Επιστρέφει έναν επαναληπτικό που δείχνει αμέσως πέρα ​​από το τελευταίο στοιχείο του διανύσματος. Όταν η κατασκευή του διανύσματος προηγείται από const, η έκφραση end () const εκτελείται αντί για τέλος (). Εξετάστε το ακόλουθο τμήμα κώδικα:

constδιάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ> ::const_iteratoriter=vtrτέλος()?
κόστος<< *iter<< ' n'?

Η έξοδος είναι 0. Σημειώστε ότι το const_iterator έχει χρησιμοποιηθεί αυτήν τη φορά αντί για τον επαναληπτή για να λάβει τον επαναλαμβανόμενο επαναλήπτη.

Αντίστροφη επανάληψη

Είναι πιθανό να υπάρχει ένας επαναληπτής που επαναλαμβάνεται από το τέλος έως λίγο πριν το πρώτο στοιχείο.

rbegin () εκτός

Επιστρέφει έναν επαναληπτικό που δείχνει το τελευταίο στοιχείο του διανύσματος, όπως στο ακόλουθο τμήμα κώδικα:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ> ::reverse_iteratorrIter=vtrrbegin()?
κόστος<< *rIter<< ' n'?

Η έξοδος είναι 4,4.

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

rbegin () const noexcept?

Επιστρέφει έναν επαναληπτικό που δείχνει το τελευταίο στοιχείο του διανύσματος. Όταν η κατασκευή του διανύσματος προηγείται από const, η έκφραση rbegin () const εκτελείται αντί του rbegin (). Υπό αυτή τη συνθήκη, το αντίστοιχο στοιχείο στο διάνυσμα δεν μπορεί να τροποποιηθεί. Αυτή η δυνατότητα χρησιμοποιείται στον ακόλουθο κώδικα:

constδιάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ> ::const_reverse_iteratorrIter=vtrrbegin()?
κόστος<< *rIter<< ' n'?

Η έξοδος είναι 4,4.

Λάβετε υπόψη ότι ο const_reverse_iterator χρησιμοποιήθηκε αυτή τη φορά, αντί για τον αντίστροφο_εξεταστή, για να λάβει τον επαναλαμβανόμενο επαναλήπτη.

καθιστούν () χωρίς εξαίρεση

Επιστρέφει έναν επαναληπτικό που δείχνει ακριβώς πριν από το πρώτο στοιχείο του διανύσματος. Εξετάστε το ακόλουθο τμήμα κώδικα:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ> ::reverse_iteratorrIter=vtrκάνει()?
κόστος<< *rIter<< ' n'?

Η έξοδος είναι 0, το οποίο δεν έχει νόημα, καθώς δεν υπάρχει συγκεκριμένο στοιχείο λίγο πριν από το πρώτο στοιχείο.

render () const noexcept

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

constδιάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ> ::const_reverse_iteratorrIter=vtrκάνει()?
κόστος<< *rIter<< ' n'?

Η έξοδος είναι 0.

Λάβετε υπόψη ότι ο const_reverse_iterator χρησιμοποιήθηκε αυτή τη φορά, αντί για τον αντίστροφο_εξεταστή, για να λάβει τον επαναλαμβανόμενο επαναλήπτη.

Διανυσματικοί τροποποιητές

Ένας τροποποιητής που τροποποιεί το διάνυσμα μπορεί να λάβει ή να επιστρέψει έναν επαναληπτή.

a.emplace (p, args)

Εισάγει ένα αντικείμενο τύπου Τ κατασκευασμένο με std :: forward (args)… πριν από το p.

Για λεπτομέρειες - δείτε αργότερα

insert (iteratorPosition, value)

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

διάνυσμα<int>>vtr{10, είκοσι, 30, 40}?
διάνυσμα<int> ::επαναληπτηςiter=vtrνα αρχίσει()?
++iter?
++iter?
vtrεισάγετε(iter, 25)?
κόστος<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3] << ' n'?

Η έξοδος είναι: 20 25 30.

Σημειώστε ότι ο επαναληπτής ήταν προχωρημένος (αυξανόμενος) ακριβώς όπως ένας δείκτης.

Μπορεί επίσης να εισαχθεί μια λίστα προετοιμασίας, όπως φαίνεται από τον ακόλουθο κώδικα:

διάνυσμα<int>>vtr{10, είκοσι, 30, 40}?
διάνυσμα<int> ::επαναληπτηςiter=vtrνα αρχίσει()?
++iter?
++iter?
vtrεισάγετε(iter, {25, 28})?

κόστος<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3]<< '' <<vtr[4] << ' n'?

Η έξοδος είναι: 20 25 28 30.

διαγραφή (θέση)

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

διάνυσμα<int>>vtr{10, είκοσι, 30, 40}?
διάνυσμα<int> ::επαναληπτηςiter=vtrνα αρχίσει()?
++iter?
++iter?
vtrεξάλειψη(iter)?
κόστος<<vtr[0] << '' <<vtr[1] << '
'
<<vtr[2]<< ' n'?

Η έξοδος είναι: 10 20 40

push_back (t), push_back (rv)

Χρησιμοποιείται για την προσθήκη ενός μόνο στοιχείου στο τέλος του διανύσματος. Χρησιμοποιήστε το push_back (t) ως εξής:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
vtrpush_back(5.5)?
φλοτέρfl=vtr[4]?
κόστος<<fl<< ' n'?

Η έξοδος είναι 5,5.

push_back(rv): -δείτε αργότερα.

pop_back ()

Αφαιρεί το τελευταίο στοιχείο χωρίς να το επιστρέψει. Το μέγεθος του διανύσματος μειώνεται κατά 1. Ο ακόλουθος κώδικας το απεικονίζει αυτό:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
vtrpop_back()?
φλοτέρμικρό=vtrΜέγεθος()?
κόστος<<μικρό<< ' n'?

Η έξοδος είναι 3.

a.swap (β)

Δύο διανύσματα μπορούν να ανταλλαχθούν, όπως απεικονίζεται στο ακόλουθο τμήμα κώδικα:

διάνυσμα<φλοτέρ>>vtr1{1.1, 2.2, 3.3, 4.4}?
διάνυσμα<φλοτέρ>>vtr2{10, είκοσι}?
vtr1.ανταλαγή(vtr2)?
κόστος<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'
<<vtr1[2] <<''<<vtr1[3] << ' n'?

κόστος<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' n'?

Η έξοδος είναι:

vtr1: 10 είκοσι 0 0
vtr2: 1.1 2.2 3.3 4.4

Σημειώστε ότι το μήκος ενός διανύσματος αυξάνεται, εάν είναι απαραίτητο. Επίσης, οι τιμές που δεν είχαν αντικαταστάσεις αντικαθίστανται από κάποια προεπιλεγμένη τιμή.

Σαφή()

Αφαιρεί όλα τα στοιχεία από το διάνυσμα, όπως απεικονίζει το ακόλουθο τμήμα κώδικα:

διάνυσμα<φλοτέρ>>vtr{1.1, 2.2, 3.3, 4.4}?
vtrΣαφή()?
κόστος<<vtrΜέγεθος() << ' n'?

Η έξοδος είναι 0.

Ισότητα και σχετικοί τελεστές για διανύσματα

Ο == Τελεστής

Επιστρέφει το 1 για true αν τα δύο διανύσματα έχουν το ίδιο μέγεθος και τα αντίστοιχα στοιχεία είναι ίσα. Διαφορετικά, επιστρέφει 0 για false. Για παράδειγμα:

διάνυσμα<int>>U{1, 2, 3}?
διάνυσμα<int>>V{4, 5, 6}?
bool bl=U==V?
κόστος<<bl<< ' n'?

Η έξοδος είναι 0.

Ο! = Τελεστής

Επιστρέφει το 1 για true αν τα δύο διανύσματα δεν έχουν το ίδιο μέγεθος και/ή τα αντίστοιχα στοιχεία δεν είναι ίσα. Διαφορετικά, επιστρέφει 0 για false. Για παράδειγμα:

διάνυσμα<int>>U{1, 2, 3}?
διάνυσμα<int>>V{4, 5, 6}?
bool bl=U! = =V?
κόστος<<bl<< ' n'?

Η έξοδος είναι 1.

ο

Επιστρέφει το 1 για true αν το πρώτο διάνυσμα είναι το αρχικό υποσύνολο του δεύτερου διανύσματος, με τα στοιχεία των δύο ίσων τμημάτων να είναι ίδια και με την ίδια σειρά. Εάν και τα δύο διανύσματα είναι του ίδιου μεγέθους και κινούνται από αριστερά προς τα δεξιά και ένα στοιχείο συναντάται στο πρώτο διάνυσμα που είναι μικρότερο από το αντίστοιχο στοιχείο στο δεύτερο διάνυσμα, τότε το 1 εξακολουθεί να επιστρέφεται. Διαφορετικά, επιστρέφεται το 0 για false. Για παράδειγμα:

διάνυσμα<int>>U{3, 1, 1}?
διάνυσμα<int>>V{3, 2, 1}?
bool bl=U<V?
κόστος<<bl<< ' n'?

Η έξοδος είναι 1.

Ο> Χειριστής

Επιστρέφει! (U

ο<= Operator

Επιστρέφει U<= V, where U is the first vector and V is the second vector, according to the above definitions.

Ο> = Χειριστής

Επιστρέφει! (U<= V), where U is the first vector and V is the second vector, according to the above definitions.

συμπέρασμα

Ένα διάνυσμα είναι ένα παράδειγμα δοχείου ακολουθίας. Ένα διάνυσμα είναι μια καλύτερη μορφή του συνηθισμένου πίνακα και δημιουργείται από μια κλάση. Τα διανύσματα έχουν μεθόδους που ταξινομούνται ως εξής: κατασκευή και εκχώρηση, χωρητικότητα, πρόσβαση στοιχείων, πρόσβαση δεδομένων, επαναληπτές, τροποποιητές και αριθμητικοί υπερφορτωμένοι χειριστές.

Υπάρχουν άλλα δοχεία αλληλουχίας, που ονομάζονται λίστα, λίστα_προηγούμενη και πίνακας. Εάν η εργασία περιλαμβάνει συχνές εισαγωγές και διαγραφές στη μέση της ακολουθίας, τότε θα πρέπει να χρησιμοποιηθεί μια λίστα ή λίστα προώθησης. Εάν η εργασία περιλαμβάνει συχνές εισαγωγές και διαγραφές στην αρχή ή στο τέλος της ακολουθίας, τότε θα πρέπει να χρησιμοποιηθεί ένα deque. Και έτσι, τα διανύσματα πρέπει να χρησιμοποιούνται μόνο όταν τέτοιου είδους πράξεις δεν είναι σημαντικές.