Phenquestions
Аритметичните оператори обикновено се използват за аритметични операции. Не е ли хубаво да имате +, присъединете се към два низа? Разрешаването на това, за което се казва, че претоварва оператора за аритметично събиране, за низове.
Инкрементният оператор ++ добавя 1 към int или float. Когато се занимавате с указатели, той не добавя 1 към указателя. Той кара показалеца да сочи към следващия пореден обект в паметта. Итераторът сочи към следващия обект от свързан списък, но обектите от свързания списък са на различни места в паметта (не в последователни региони). Не би ли било хубаво да се претовари операторът за увеличаване за итератор, да се увеличи, но да се посочи следният елемент в свързания списък?
Тази статия обяснява претоварването в C++. Той е разделен на две части: претоварване на функцията и претоварване на оператора. Наличието на основни познания по C ++ е необходимо, за да се разбере останалата част от статията.
Съдържание на статията
- Претоварване на функцията
- Претоварване на оператора
- Пример Претоварване на оператор на клас низове
- Претоварване на оператора на итератор
- Заключение
Претоварване на функцията
Следващата функция добавя два ints и връща int:
int добавяне (int no1, int no2)int сума = no1 + no2;
сума за връщане;
Прототипът на тази функция е:
int add (int no1, int no2);
Прототипът на функция в заглавката на функцията, завършваща с точка и запетая. Следващата функция със същото име, но с различен прототип, ще добави три плувки и ще върне плувка:
float add (float no1, float no2, float no3)
плаваща сума = no1 + no2 + no3;
сума за връщане;
Как компилаторът различава коя функция да извика, тъй като две или повече функции имат едно и също име? Компилаторът използва броя на аргументите и типовете аргументи, за да определи коя функция да се извика. Списъкът с параметри на претоварените функции трябва да се различава по техния брой и / или типове параметри. И така, извикването на функцията,
int sm = добавяне (2, 3);ще извика целочислената функция, докато функцията извиква,
float sme = add (2.3, 3.4, 2.0);ще извика функцията float. Забележка: има ситуации, при които компилаторът ще отхвърли претоварена функция, когато броят на аргументите е еднакъв, но от различни типове! - Причина: - вижте по-късно.
Следващата програма въвежда в действие горните сегменти на кода:
#includeизползване на пространство от имена std;
int добавяне (int no1, int no2)
int сума = no1 + no2;
сума за връщане;
float add (float no1, float no2, float no3)
плаваща сума = no1 + no2 + no3;
сума за връщане;
int main ()
int sm = добавяне (2, 3);
Cout<
Cout<
Резултатът е:
5
7.7
Претоварване на оператора
Аритметичните оператори се използват за претоварване на операции в типове класове. Итераторът е тип клас. Операторите за инкрементиране и декрементиране се използват за претоварване на операции за итератор.
Пример Претоварване на оператор на клас низове
Този раздел предоставя пример, където + е претоварен за просто проектиран низ клас, наречен пролетен клас. + обединява литералите на два низови обекта, връщайки нов обект със свързаните литерали. Обединяването на два литерала означава присъединяване на втория литерал до края на първия литерал.
Сега C ++ има специална функция за всички класове, наречена оператор. Програмистът може да използва тази специална функция за претоварване на оператори, като +. Следващата програма показва претоварването на оператора + за два низа.
#includeизползване на пространство от имена std;
клас пролет
публично:
// членове на данните
char val [100];
int n;
char concat [100];
// членски функции
пружина (char arr [])
за (int i = 0; i<100; ++i)
val [i] = arr [i];
ако (arr [i] == '\ 0')
почивка;
int i;
за (i = 0; i<100; ++i) if (arr[i] == '\0') break;
n = i;
пружинен оператор + (spring & st)
int newLen = n + st.н;
char newStr [newLen + 1];
за (int i = 0; i
пролетен obj (newStr);
return obj;
;
int main ()
char ch1 [] = "Мразя те! "; пружина str1 (ch1);
char ch2 [] = "Но тя те обича!"; пружина str2 (ch2);
char ch3 [] = "един"; пружина str3 (ch3);
str3 = str1 + str2;
Cout<
Стойността на str1 е „Мразя те! ". Стойността на str2 е „Но тя те обича!". Стойността на str3, която е, str1 + str2, е изходът:
"Мразя те! Но тя те обича!"
което е конкатенацията на двата низови литерала. Самите низове са инстанцирани обекти.
Определението на операторската функция е вътре в описанието (дефиницията) на низовия клас. Започва с типа връщане, "пружина" за "низ". Специалното име, "оператор, следвайте това". След това има символа на оператора (да бъде претоварен). След това има списък с параметри, който всъщност е списъкът на операндите. + е двоичен оператор: означава, че отнема ляв и десен операнд. Според спецификацията C ++ обаче тук списъкът с параметри има само правилния параметър. След това има тялото на операторската функция, което имитира обикновеното поведение на оператора.
Чрез спецификацията C ++, дефиницията на оператора + приема само десния параметър на операнда, тъй като останалата част от описанието на класа е параметърът на левия операнд.
В горния код само дефиницията на функцията оператор + () се занимава с + претоварването. Останалата част от кода за класа е нормално кодиране. Вътре в тази дефиниция двата низови литерала са обединени в масива, newStr []. След това всъщност се създава нов обект на низ (създава се инстанция), като се използва аргумент, newStr []. В края на дефиницията на функцията оператор + () се връща новосъздаденият обект с конкатенирания низ.
Във функцията main () добавянето става чрез израза:
str3 = str1 + str2;Където str1, str2 и str3 са низови обекти, които вече са създадени в main (). Изразът, „str1 + str2“ със своите +, извиква функцията член оператор + () в обекта str1. Функцията на оператора + () в обекта str1 използва str2 като свой аргумент и връща новия обект с (разработен) конкатенирания низ. Операторът за присвояване (=) на пълния оператор замества съдържанието (стойности на променливи) на обекта str3 с тези на върнатия обект. Във функцията main (), след добавяне, стойността на члена с данни str3.val вече не е "един"; това е обединеният (допълващ) низ, "Мразя те! Но тя те обича!". Функцията-член на оператора + () в обекта str1, използва низовия литерал на собствения си обект и литерала на низа на своя аргумент, str2, за да излезе със свързан низ с литерал.
Претоварване на оператора на итератор
Когато се работи с итератор, участват поне два обекта: свързан списък и самият итератор. Всъщност участват поне два класа: клас, от който е създаден екземпляр на свързан списък, и клас, от който е създаден итератор.
Свързан списък
Диаграма за обект с двойно свързан списък е:
Този списък има три елемента, но може да има и повече. Трите елемента тук са елементи на цели числа. Първият има стойността 14; следващият има стойността, 88; и последният има стойността 47. Всеки елемент тук се състои от три последователни места.
Това е за разлика от масива, където всеки елемент е едно местоположение и всички елементи на масива са в последователни местоположения. Тук различните елементи са на различни места в поредицата памет, но всеки елемент се състои от три последователни местоположения.
За всеки елемент средното местоположение съдържа стойността. Правото местоположение има показалеца към следващия елемент. Лявото местоположение има показалеца към предишния елемент. За последния елемент правилното местоположение сочи към теоретичен край на списъка. За първия елемент лявото местоположение сочи към теоретично начало на списъка.
С масива операторът на инкремента (++) увеличава показалеца, за да сочи към физически следващото местоположение. При списъка елементите не са в последователни области в паметта. И така, операторът на увеличение може да бъде претоварен, преместете итератора (показалеца) от един елемент към логически следващия елемент. Същата проекция се отнася за оператора на декремент (-).
Препращащият итератор е итератор, който при ангажиране сочи към следващия елемент. Обратният итератор е итератор, който при ангажиране сочи към предишния елемент.
Претоварване на ++ реклама -
Претоварването на тези оператори се извършва в описанието на класа (дефиницията) на итератора.
Синтаксисът за прототипа на претоварващия оператор на инкремент, префикс, е
Оператор ReturnType ++ ();Синтаксисът на прототипа на претоварването на оператора на инкремент, postfix, е
Оператор ReturnType ++ (int);Синтаксисът на прототипа на претоварващия оператор на декремент, префикс, е
Оператор ReturnType - ();Синтаксисът за прототипа на претоварването на оператора на инкремент, postfix, е
Оператор ReturnType - (int);Заключение
Претоварването означава придаване на различно значение на функция или оператор. Функциите са претоварени в същия обхват. Това, което отличава претоварените функции, са броят и / или типовете параметри в техните списъци с параметри. В някои случаи, когато броят на параметрите е еднакъв, но с различни типове, компилаторът отхвърля претоварването - вижте по-късно. Много обикновени оператори могат да бъдат претоварени в класове, от които се създават екземпляри на обекти. Това се прави чрез даване на тип на връщане, списък с параметри и тяло на специалната функция, наречена оператор, в описанието на класа.
