Въведение
Масивът е поредица от същите типове обекти в последователни места в паметта. Масив не може да увеличи рудата намаляване на дължината. Вектор е като масив, но дължината му може да се увеличи или намали. Следователно вектор има много повече операции, отколкото масив.
C ++ има много библиотеки, всички те формират стандартната библиотека на C ++. Една от тези библиотеки е библиотеката с контейнери. Контейнерът е колекция от обекти и някои операции могат да се извършват върху колекцията. C ++ контейнерите могат да бъдат групирани в два набора: последователни контейнери и асоциативни контейнери. Контейнерите на последователността са векторни, масивни (не същият масив, обсъден по -рано), deque, forward_list и list. Това са различни колекции (подобни на масиви структури от данни) и всяка предлага различни компромиси.
Всеки програмист трябва да знае как да реши дали да използва вектор, масив, deque, forward_list или списък. Когато програмист се нуждае от структура, която изисква повече операции от тези, свързани с обикновен масив, обикновеният масив не трябва да се използва.
Ако задачата включва често вмъкване и изтриване в средата на поредицата, тогава трябва да се използва списък или forward_list. Ако задачата включва често вмъкване и изтриване в началото или края на поредица, тогава трябва да се използва deque. Векторът трябва да се използва, когато не се изискват такива операции.
Тази статия ви показва как да използвате вектора C ++. Ще ви трябват известни познания за C ++ указатели, препратки и масиви, за да разберете тази статия.
Клас и обекти
Класът е набор от променливи и функции, които работят заедно, където променливите нямат присвоени стойности. Когато стойностите са присвоени на променливите, клас се превръща в обект. Различни стойности, дадени на един и същи клас, водят до различни обекти; тоест различни обекти могат да бъдат от един и същи клас, но да имат различни стойности. Създаването на обект от клас е известно също като създаване на обект.
Терминът вектор описва клас. Обект, създаден от вектор, има име, избрано от програмиста.
Функция, която принадлежи към клас, е необходима за създаване на обект от класа. В C ++ тази функция има същото име като името на класа. Различните обекти, създадени (създадени) от класа, имат различни имена, дадени на всеки от тях от програмиста.
Създаване на обект от клас означава конструиране на обекта; това също означава създаване на обект.
Векторният клас
Векторният клас вече е дефиниран и се намира в библиотеката. За да използва векторния клас, програмистът трябва да включи заглавката на вектора във файла със следната директива за предварителна обработка:
#включваСлед като заглавката е включена, всички векторни характеристики (членове на данни и функции на членове) стават достъпни. За да използвате обекта count за извеждане на данни към терминала (конзолата), трябва да се включи и заглавката на обекта. За да напишете програма с вектора като минимум, трябва да бъдат включени следните заглавки:
#включва#включва
Инстанциране на вектор
intfoo[10];По -горе е декларацията на масив с името foo и броя на елементите 10. Това е масив от цели числа. Обявяването на вектор е подобно. За вектор броят на елементите е по избор, тъй като дължината на вектора може да се увеличи или намали.
Към този момент в програмата, векторният клас вече е дефиниран в библиотеката и заглавката е включена. Векторът може да бъде създаден по следния начин:
часа::вектор <int>vtr(8);Тук векторът е със специална конструкторска функция. Типът данни, които векторът ще съхранява, е int, в ъглови скоби. Терминът vtr е името, избрано от програмиста за вектора. И накрая, 8, в скоби, е предварителният брой цели числа, които векторът ще има.
Терминът std означава стандартно пространство от имена. В този контекст този термин трябва да бъде последван от двойно двоеточие. Всеки може да напише своя собствена библиотека с векторни класове и да я използва. Въпреки това, C ++ вече има стандартна библиотека със стандартни имена, включително вектор. За да използвате стандартно име, стандартното име трябва да бъде предшествано от std ::. За да избегнете въвеждането на std :: всеки път в програмата за стандартно име, програмният файл може да започне, както следва:
#включва#включва
използвайки пространство за имена std;
Претоварване на функция
Когато два или повече различни подписи на функции имат едно и също име, това име се казва претоварено. Когато се извика една функция, броят и видът на аргументите определят коя функция се изпълнява.
Изграждане на вектор
Конструирането на вектор означава създаване на екземпляр (създаване) на векторен обект. Конструкторната функция е претоварена, както следва:
векторно име
Това създава вектор с дължина нула и тип T. Следното изявление създава вектор с нулева дължина от типа float с името vtr:
вектор<плувам>vtr;векторно име (n)
Това създава вектор с n елементи от тип T. Изразът за този вектор с четири плаващи елемента е следният:
вектор<плувам>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 Vector
Const вектор е вектор, чиито елементи не могат да се променят. Стойностите в този вектор са само за четене. Когато се създаде, векторът изглежда така:
constвектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};В този тип вектор не може да се добавя или премахва елемент. Освен това не може да се променя никаква стойност.
Изграждане с Iterator
Шаблонът предоставя общо представяне за тип данни. Итераторът предоставя общо представяне на сканирането през стойностите на контейнер. Синтаксисът за създаване на вектор с итератор е следният:
шаблон<клас InputIterator>вектор(InputIterator първо,InputIterator последен,constРазпределител& =Разпределител());
Това конструира вектор за диапазона [първи, последен), използвайки посочения разпределител, който ще бъде разгледан по -късно в тази статия.
Унищожаване на вектор
За да унищожите вектор, просто го оставете да излезе от обхвата и унищожаването се обработва автоматично.
Векторен капацитет
size_type capacity () const noexcept
Общият брой елементи, които векторът може да задържи, без да изисква преразпределение, се връща от функцията член на капацитета. Кодов сегмент за това е както следва:
вектор<плувам>vtr(4);intникой=vtr.капацитет();
цена<<никой<< 'н';
Изходът е 4.
резерв (n)
Паметта не винаги е свободно достъпна. Допълнително място може да се резервира предварително. Помислете за следния кодов сегмент:
вектор<плувам>vtr(4);vtr.резерв(6);
цена<<vtr.капацитет() << 'н';
Изходът е 6. И така, допълнителното място е 6 - 4 = 2 елемента. Функцията връща void.
size () const noexcept
Това връща броя на елементите във вектора. Следният код илюстрира тази функция:
вектор<плувам>vtr(4);плувамс=vtr.размер();
цена<<с<< 'н';
Изходът е 4.
смали до пасване()
След като се даде допълнителен капацитет на вектор с функцията Reserve (), векторът може да бъде оразмерен така, че да пасне на първоначалния си размер. Следният код илюстрира това:
вектор<плувам>vtr(4);vtr.резерв(6);
vtr.смали до пасване();
intс=vtr.размер();
цена<<с<< 'н';
Изходът е 4, а не 6. Функцията връща void.
преоразмеряване (sz), преоразмеряване (sz, c)
Това променя размера на вектора. Ако новият размер е по -малък от стария, елементите към края се изтриват. Ако новият размер е по -дълъг, тогава към края се добавя някаква стойност по подразбиране. За да имате определена добавена стойност, използвайте функцията resize () с два аргумента. Следният кодов сегмент илюстрира използването на тези две функции:
вектор<плувам>vtr1{1.1, 2.2, 3.3, 4.4};vtr1.преоразмеряване(2);
цена<< „Нов размер на vtr1:“ <<vtr1.размер() << 'н';
вектор<плувам>vtr2{1.1, 2.2};
vtr2.преоразмеряване(4, 8.8);
цена<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << 'н';
Изходът е следният:
Нов размер на vtr1: 2vtr2: 1.1 2.2 8.8 8.8
Функциите връщат void.
празен () const noexcept
Тази функция връща 1 за true, ако няма елементи във вектора и 0 за false, ако векторът е празен. Ако векторът има 4 местоположения за определен тип данни, като например плаващ, без никаква плаваща стойност, тогава този вектор не е празен. Следният код илюстрира това:
вектор<плувам>vtr;цена<<vtr.празна() << 'н';
вектор<плувам>vt(4);
цена<<така чепразна() << 'н';
вектор<плувам>v(4,3.5);
цена<<v.празна() << 'н';
Изходът е следният:
10
0
Достъп до векторни елементи
Векторът може да бъде подзаписан (индексиран) като масив. Преброяването на индекса започва от нула.
vectorName [i]
Операцията vectorName [i] връща препратка към елемента в ithиндекс на вектора. Следният код извежда 3.3 за горния вектор:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};плувамет=vtr[2];
цена<<ет<< 'н';
vectorName [i] const
Операцията vectorName [i] const се изпълнява вместо vectorName [i], когато векторът е постоянен вектор. Тази операция се използва в следния код:
constвектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};плувамет=vtr[2];
цена<<ет<< 'н';
Изразът връща постоянна препратка към ithелемент на вектора.
Присвояване на стойност с Subscript
Стойност може да бъде присвоена на непостоянен вектор, както следва:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};vtr[2] = 8.8;
цена<<vtr[2] << 'н';
Изходът е 8.8.
vectorName.at (i)
vectorName.at (i) е като vectorName [i], но vectorName.at (i) е по -надежден. Следният код показва как трябва да се използва този вектор:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};плувамет=vtr.в(2);
цена<<ет<< 'н';
в()е векторен членфункция.
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};плувамет=vtr.в(2);
цена<<ет<< 'н';
в() constе векторен членфункция.
Присвояване на стойност с функцията at ()
Стойност може да бъде присвоена на непостоянен вектор с функцията at (), както следва:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};vtr.в(2) = 8.8;
цена<<vtr[2] << 'н';
Изходът е 8.8.
Проблем с под-скриптове
Проблемът с под-скриптове (индексиране) е, че ако индексът е извън обхвата, може да се върне нула или грешка може да бъде издадена по време на изпълнение.
отпред ()
Това връща препратка към първия елемент на вектора, без да премахвате елемента. Изходът на следния код е 1.1.
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};плувамет=vtr.отпред();
цена<<ет<< 'н';
Елементът не се премахва от вектора.
front () const
Когато векторната конструкция се предхожда от const, изразът front () const се изпълнява вместо front (). Това се използва в следния код:
constвектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};плувамет=vtr.отпред();
цена<<ет<< 'н';
Връща се постоянна справка. Елементът не се премахва от вектора.
обратно()
Това връща препратка към последния елемент на вектора без премахване на елемента. Изходът на следния код е 4.4.
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};плувамет=vtr.обратно();
цена<<ет<< 'н';
back () const
Когато векторната конструкция се предхожда от const, изразът back () const се изпълнява вместо back (). Това се използва в следния код:
constвектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};плувамет=vtr.обратно();
цена<<ет<< 'н';
Връща се постоянна справка. Елементът не се премахва от вектора.
Достъп до векторни данни
data () noexcept; data () const noexcept;
Всяко от тези връща указател, така че [data (), data () + size ()) е валиден диапазон.
Това ще бъде разгледано по -подробно по -късно в статията.
Връщащи се итератори и вектор
Итераторът е като показалец, но има повече функционалност от показалец.
begin () noexcept
Връща итератор, който сочи към първия елемент на вектора, както в следния кодов сегмент:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};вектор<плувам> ::итераторiter=vtr.започнете();
цена<< *iter<< 'н';
Изходът е 1.1. Обърнете внимание, че декларацията, която получава итератора, е декларирана. Итераторът се пренасочва в обратен израз, за да се получи стойността по същия начин, по който се пренасочва указател.
begin () const noexcept;
Връща итератор, който сочи към първия елемент на вектора. Когато векторната конструкция се предхожда от const, изразът begin () const се изпълнява вместо begin (). При това условие съответният елемент във вектора не може да бъде модифициран. Това се използва в следния код:
constвектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};вектор<плувам> ::const_iteratoriter=vtr.започнете();
цена<< *iter<< 'н';
Изходът е 1.1. Имайте предвид, че този път const_iterator е бил използван вместо просто итератор за получаване на върнатия итератор.
end () noexcept
Връща итератор, който сочи непосредствено от последния елемент на вектора. Помислете за следния кодов сегмент:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};вектор<плувам> ::итераторiter=vtr.край();
цена<< *iter<< 'н';
Изходът е 0, което е безсмислено, тъй като няма последен елемент извън последния елемент.
end () const noexcept
Връща итератор, който сочи непосредствено от последния елемент на вектора. Когато векторната конструкция се предхожда от const, изразът end () const се изпълнява вместо end (). Помислете за следния кодов сегмент:
constвектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};вектор<плувам> ::const_iteratoriter=vtr.край();
цена<< *iter<< 'н';
Изходът е 0. Обърнете внимание, че този път const_iterator е бил използван вместо просто итератор за получаване на върнатия итератор.
Обратна итерация
Възможно е да има итератор, който да се повтаря от края до точно преди първия елемент.
rbegin () noexcept
Връща итератор, който сочи към последния елемент на вектора, както в следния кодов сегмент:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};вектор<плувам> ::обратен_ литераторrIter=vtr.rbegin();
цена<< *rIter<< 'н';
Изходът е 4.4.
Обърнете внимание, че декларацията, която получава обратния итератор, е декларирана. Итераторът се пренасочва в обратен израз, за да се получи стойността по същия начин, по който се пренасочва указател.
rbegin () const noexcept;
Връща итератор, който сочи към последния елемент на вектора. Когато векторната конструкция се предхожда от const, изразът rbegin () const се изпълнява вместо rbegin (). При това условие съответният елемент във вектора не може да бъде модифициран. Тази функция се използва в следния код:
constвектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};вектор<плувам> ::const_reverse_iteratorrIter=vtr.rbegin();
цена<< *rIter<< 'н';
Изходът е 4.4.
Обърнете внимание, че този път const_reverse_iterator е бил използван, вместо просто reverse_iterator, за да получи върнатия итератор.
render () noexcept
Връща итератор, който сочи точно преди първия елемент на вектора. Помислете за следния кодов сегмент:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};вектор<плувам> ::обратен_ литераторrIter=vtr.прави();
цена<< *rIter<< 'н';
Изходът е 0, което е безсмислено, тъй като няма конкретен елемент точно преди първия елемент.
render () const noexcept
Връща итератор, който сочи точно преди първия елемент на вектора. Когато векторната конструкция се предхожда от const, изразът rend () const се изпълнява вместо rend (). Помислете за следния кодов сегмент:
constвектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};вектор<плувам> ::const_reverse_iteratorrIter=vtr.прави();
цена<< *rIter<< 'н';
Изходът е 0.
Обърнете внимание, че този път const_reverse_iterator е бил използван, вместо просто reverse_iterator, за да получи върнатия итератор.
Векторни модификатори
Модификатор, който променя вектора, може да вземе или върне итератор.
a.mplace (p, args)
Вмъква обект от тип T, конструиран със std :: forward (args) ... преди p.
За подробности - вижте по -късновмъкване (iteratorPosition, стойност)
Вмъква копие на стойността в позицията на итератора на вектора. Връща итератора (позиция) във вектора, където е поставено копието. Следният код показва къде е поставена стойността:
вектор<int>vtr{10, двайсет, 30, 40};вектор<int> ::итераторiter=vtr.започнете();
++iter;
++iter;
vtr.вмъкване(iter, 25);
цена<<vtr[1] << '' <<vtr[2]<< '
' <<vtr[3] << 'н';
Изходът е: 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] << 'н';
Изходът е: 20 25 28 30.
изтриване (позиция)
Премахва елемент в позицията, посочена от итератора, след което връща позицията на итератора. Следният код илюстрира това:
вектор<int>vtr{10, двайсет, 30, 40};вектор<int> ::итераторiter=vtr.започнете();
++iter;
++iter;
vtr.изтрива(iter);
цена<<vtr[0] << '' <<vtr[1] << '
' <<vtr[2]<< 'н';
Изходът е: 10 20 40
push_back (t), push_back (rv)
Използва се за добавяне на един елемент в края на вектора. Използвайте push_back (t), както следва:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};vtr.избутвам(5.5);
плувамет=vtr[4];
цена<<ет<< 'н';
Изходът е 5.5.
избутвам(rv): -виж по -късно.pop_back ()
Премахва последния елемент, без да го връща. Размерът на вектора се намалява с 1. Следният код илюстрира това:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};vtr.pop_back();
плувамс=vtr.размер();
цена<<с<< 'н';
Изходът е 3.
a.swap (b)
Два вектора могат да бъдат разменени, както е илюстрирано в следния кодов сегмент:
вектор<плувам>vtr1{1.1, 2.2, 3.3, 4.4};вектор<плувам>vtr2{10, двайсет};
vtr1.размяна(vtr2);
цена<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'<<vtr1[2] <<''<<vtr1[3] << 'н';
цена<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << 'н';
Изходът е:
vtr1: 10 двайсет 0 0vtr2: 1.1 2.2 3.3 4.4
Имайте предвид, че дължината на вектора се увеличава, ако е необходимо. Също така стойностите, които не са имали замяна, се заменят с някаква стойност по подразбиране.
ясно ()
Премахва всички елементи от вектора, както илюстрира следния кодов сегмент:
вектор<плувам>vtr{1.1, 2.2, 3.3, 4.4};vtr.ясно();
цена<<vtr.размер() << 'н';
Изходът е 0.
Оператори на равенство и отношения за вектори
Операторът ==
Връща 1 за true, ако двата вектора имат еднакъв размер и съответните елементи са равни; в противен случай връща 0 за false. Например:
вектор<int>U{1, 2, 3};вектор<int>V{4, 5, 6};
bool bl=U==V;
цена<<бл<< 'н';
Изходът е 0.
Операторът! =
Връща 1 за true, ако двата вектора нямат еднакъв размер и/или съответните елементи не са равни; в противен случай връща 0 за false. Например:
вектор<int>U{1, 2, 3};вектор<int>V{4, 5, 6};
bool bl=U! =V;
цена<<бл<< 'н';
Изходът е 1.
The
Връща 1 за true, ако първият вектор е началното подмножество на втория вектор, като елементите на двете равни части са еднакви и в същия ред. Ако и двата вектора са с еднакъв размер и се движат отляво надясно и в първия вектор се срещне елемент, който е по -малък от съответния елемент във втория вектор, тогава 1 все пак ще бъде върнат. В противен случай се връща 0 за false. Например:
вектор<int>U{3, 1, 1};вектор<int>V{3, 2, 1};
bool bl=U<V;
цена<<бл<< 'н';
Изходът е 1. > Операторът Връща се! (U The<= 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. Вектор е пример за контейнер за последователност. Вектор е по -добра форма на обикновения масив и се създава от клас. Векторите имат методи, които са класифицирани по: конструиране и присвояване, капацитет, достъп до елементи, достъп до данни, итератори, модификатори и оператори с претоварено число. Има и други контейнери за последователност, наречени list, forward_list и array. Ако задачата включва често вмъкване и изтриване в средата на поредицата, тогава трябва да се използва списък или forward_list. Ако задачата включва често вмъкване и изтриване в началото или края на поредицата, тогава трябва да се използва деке. И така, векторите трябва да се използват само когато тези видове операции не са важни.Заключение