Pour le compilateur sait calculer, si vous voulez, de type intégré pour définir une classe par
classe personne, données privées Score construit et comment le constructeur C Personne
= A + B, (a, b sont l'objet);
#include<iostream>
using namespace std;
class Person
{
public:
Person() { score = 5; }
private:
int score;
};
Pour les types intégrés, le compilateur sait calculer, si vous voulez par classe a défini un
besoin de + surcharge, vous pouvez définir une personne et plus (personne et p)
changé pour atteindre l'objet en valeur est clairement pas a + b directement est plus pratique . Le besoin grâce à
l'utilisation de l' opérateur + op manière prévue par le compilateur aux opérateurs surchargées pour atteindre l'objectif,
peut - être sous la forme de la fonction Personne opérateur & + (personne et a ) de la définition d'une classe qui implémente
un seul paramètre passé peut aussi personne opérateur + (personne et a, personne & b ) des
moyens pour obtenir une pluralité de paramètres de transmission, les codes spécifiques sont les suivants:
#include<iostream>
using namespace std;
class Person
{
friend Person operator+(Person& a, Person& b);//访问私有数据
public:
Person() { score = 5; }
private:
int score;
};
Person operator+(Person& a, Person& b)//实现相加重载
{
Person temp;
temp.score = a.score + b.score;
return temp;
}
int main()
{
Person a,b;
a=a+b;
return 0;
}
Peut diriger le fonctionnement d'un + b, l'addition peut être envisagée avec d' autres opérateurs tels que la surcharge des
données score sortie directement un opérateur de décalage vers la gauche où les données privées car alors la principale
fonction directement sortie Cout veut évidemment utiliser improbable par la surcharge de l' opérateur de décalage vers la gauche
peut être atteint ce contenu pour obtenir cout << un, les formes n'utilisent généralement la lettre par les membres
à mettre en œuvre les fonctions que les fonctions de membres de la fonction ne peut pas répondre cout << un certain nombre de formes afin que cout
sur le côté gauche, et peut donc être réalisé en définissant le contenu de la fonction globale.
#include<iostream>
using namespace std;
class Person
{
friend Person operator+(Person& a, Person& b);//访问私有数据
friend ostream& operator<<(ostream& cout, Person& p);//仅实现左移运算符号重载；
public:
Person() { score = 5; }
private:
int score;
};
ostream& operator<<(ostream& cout, Person& p)//实现左移重载
{
cout << p.score;
return cout;
}
int main()
{
Person a;
cout << a;
}
des éléments d'auto-excitation directe est obtenue en définissant une face ++.
class Person
{
friend Person operator+(Person& a, Person& b);//访问私有数据
friend ostream& operator<<(ostream& cout, Person& p);//仅实现左移运算符号重载；
friend Person& operator++(Person& a);//实现前置++重载;
public:
Person() { score = 5; }
private:
int score;
};
ostream& operator<<(ostream& cout, Person& p)//实现左移重载
{
cout << p.score;
return cout;
}
Person& operator++(Person& a)//实现前置递增重载;
{
a.score++;
return a;
}
int main()
{
Person a;
a++;
cout <<a;
}
由于后置++时必须返回临时对象,重载左移运算符中第二个参数也
必须时使用值而非引用值,如果保持引用作为函数参数会使得cout
<<a++;尽管在第一次运行流畅这是由于编译器的优化,第二次实现
时就会崩溃这是用于编译器已经将这部分内存释放了是一个临时变
量拷贝给源对象使得源对象在执行内容后被释放内存;
#include<iostream>
using namespace std;
class Person
{
friend void test(Person p);
friend ostream& operator<<(ostream& cout, Person& p);//仅实现左移运算符号重载；
friend Person operator+(Person& a, Person& b);
friend Person& operator++(Person& a);//实现前置++重载;
public:
Person() { score = 5; }
Person operator++(int)
{
Person temp = *this;
score++;
return temp;
}//实现后置++重载
private:
int score;
};
void test(Person p)
{
cout << p.score;
}
int main()
{
Person a;
a++;
test(a);
return 0;
}
本文内容粗糙,可以学习b站上黑马程序员相关这部分内容。