Para el tipo incorporado, el compilador sabe cómo calcular, si se quiere definir una clase por
clase de persona, los datos privados puntaje construido, y cómo el constructor C Persona
= A + B; (donde a, b son el objeto);
#include<iostream>
using namespace std;
class Person
{
public:
Person() { score = 5; }
private:
int score;
};
Para los tipos predefinidos, el compilador sabe cómo calcular, si quieres por clase define una
necesidad de + sobrecargado, se puede definir a una persona y más (y persona p)
cambiado para alcanzar el objeto de valor es claramente no a + b es directamente más conveniente . Necesidad a través de
la utilización de operador + manera op proporcionado por el compilador para operadores sobrecargados para lograr el propósito,
puede ser en la forma de la función y persona de operador + (y persona de una ) de la definición de una clase que implementa
un único parámetro pasó también puede operador persona + (Person & a, y persona b )
medios para alcanzar una pluralidad de parámetros de transmisión, los códigos específicos son los siguientes:
#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;
}
Puede operación de a + b dirigir, la adición se puede prever con otros operadores tales como la sobrecarga de
datos de la puntuación directa de salida de un operador de desplazamiento a la izquierda, donde los datos son privados porque entonces la principal
función cout directamente de salida, obviamente, quieren usar improbables por la sobrecarga de operadores desplazamiento a la izquierda
se puede lograr este contenido para lograr un tribunal <<; formas no suelen utilizar la letra por los miembros
para implementar las funciones como funciones miembro de la función no puede reúnen tribunal << una serie de formularios para que cout
en el lado izquierdo, y por lo tanto puede ser realizado por la definición del contenido de la función global.
#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;
}
elementos directos automultiplicadoras se consigue definiendo un frente ++.
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站上黑马程序员相关这部分内容。