La sobrecarga de operadores, el operador existente se redefine, dándole otra función, para dar cabida a diferentes tipos de datos.
Puede volver a definir o anular la mayor parte del C ++ incorporado operadores. Por ejemplo, +, -, *, /,
++, -, >>, << y así sucesivamente, de modo que usted puede utilizar para personalizar el tipo de operador.
El formato básico de la sobrecarga de operadores
Operador está sobrecargado con una función especial, el nombre de la función es un operador clave y
A continuación, el operador a los símbolos de anulación. Al igual que con otras funciones, la sobrecarga de operadores una
Un tipo de retorno y la lista de parámetros.
Punto operador + (const punto y);
La sobrecarga de operadores de dos maneras: una es (funciones miembro en función de la clase de sobrecarga de operadores) de clase prevalece sobre el otro es (un amigo función como una función de la sobrecarga de operadores y similares) fuera de las sobrecargas de clase
Dentro de las modificaciones de la clase
#include <iostream>
using namespace std;
class Point{
public:
Point(){};
Point (int x, int y): x(x),y(y) {};
Point operator+(const Point &a){ //类内重载，运算符重载函数作为类的成员函数
Point ret;
ret.x = this->x + a.x;
ret.y = this->y + a.y;
return ret;
}
int x,y;
};
int main() {
Point a(2,4),b(5,3);
Point c = a + b;
cout<< "x :" << c.x << endl;
cout<<"y :" << c.y << endl;
}Cuando el código anterior se compila y se ejecuta, produce los siguientes resultados:
x: 7
y: 7
sobrecarga de operadores de sobrecarga es la clase, como una función de la sobrecarga de operadores función miembro, el código anterior como un ejemplo a + b + corresponde al objeto llama a un método y pasan parámetros b Object
fuera de la clase de servicio pesado
#include <iostream>
using namespace std;
class Point{
public:
Point(){};
Point (int x, int y): x(x),y(y) {};
friend Point operator+(const Point &, const Point &);
int x,y;
};
Point operator+(const Point &a,const Point &b){//类外重载,运算符重载函数作为类的友元函数
Point ret;
ret.x = a.x + b.x;
ret.y = a.y + b.y;
return ret;
}
int main() {
Point a(2,4),b(5,3);
Point c = a + b;
cout<< "x :" << c.x << endl;
cout<<"y :" << c.y << endl;
}Cuando el código anterior se compila y se ejecuta, producirá los mismos resultados que anteriormente
Ejemplos de diversos sobrecarga de operadores
El siguiente ejemplo de código se muestra la sobrecarga de varios operadores, varios sobrecarga básica operador de presentación.
La inserción del operador >> y << la sobrecarga de operadores de extracción
Para extraer la sobrecarga de operadores <<, por ejemplo, coutes la ostreamclase de objeto. ostreamClase y coutse encuentran en el archivo de cabecera <iostream>de declaración. ostreamClase será <<sobrecargado como una función miembro.
Aquí sobreescribimos <<utilización coutsalida de un objetivo
#include <iostream>
using namespace std;
class Point{
public:
Point(){};
Point (int x, int y): x(x),y(y) {};
friend Point operator+(const Point &, const Point &);
friend ostream &operator<<(ostream &out , const Point &a);
private:
int x,y;
};
Point operator+(const Point &a,const Point &b){
Point ret;
ret.x = a.x + b.x;
ret.y = a.y + b.y;
return ret;
}
ostream &operator<<(ostream &out , const Point &a){
out << "<Point>( " << a.x << ", " << a.y << ")";
return out;
}
int main() {
Point a(2,4),b(5,3);
Point c = a + b;
cout << c<< endl;
}Cuando el código anterior se compila y se ejecuta, produce los siguientes resultados:
<Point> (7, 7)
Nota: La sobrecarga <<, la clase está fuera sobrecargado, es habitual que la gente está utilizando cin>>y cout<<, y tienen que utilizar una función de amigo para los operadores de sobrecarga, si la función miembro sobrecargada que se produzca c<<cout;este código no natural.
También alguien debe ostream &operator<<(ostream &out , const Point &a)funcionar preguntarse, en primer lugar sobrecargada <<, el tipo de valor de retorno es ostream&, el primer parámetro es ostream&. En otras palabras, la expresión cout<<cdel valor de retorno es todavía cout, se cout<<c<<endl;puede establecer
La sobrecarga de operadores frente y ++ ++ sobrecarga de operadores trasera
#include <iostream>
using namespace std;
class Point{
public:
Point(){};
Point (int x, int y): x(x),y(y) {};
friend Point operator+(const Point &, const Point &);
friend ostream &operator<<(ostream &out , const Point &a);
Point& operator++(){ //前置运算符，需要引用返回，不需要参数。返回自增后的值，且返回的是一个左值
x++;
y++;
return *this;
}
const Point operator++(int){//后置++，不需要引用返回，需要参数区分。返回自增前的值，且返回的是一个右值
Point temp(x,y);
x++;
y++;
return temp;
}
private:
int x,y;
};
Point operator+(const Point &a,const Point &b){
Point ret;
ret.x = a.x + b.x;
ret.y = a.y + b.y;
return ret;
}
ostream &operator<<(ostream &out , const Point &a){
out << "<Point>(" << a.x << " , " << a.y << ")";
return out;
}
int main() {
Point a(2,4),b(5,3);
Point c = a + b;
cout << c << endl;
c++;
cout << c << endl;
++c;
cout << c << endl;
}Cuando el código anterior se compila y se ejecuta, produce los siguientes resultados:
(7, 7)
<Point> (8, 8)
<Point> (9, 9)
1> una diferencia entre operadores delantero y trasero, necesidad de añadir el parámetro "int" en el operador trasera sobrecarga funciones, aunque el tipo en el presente documento, excepto para mostrar la diferencia no representa ningún significado real;
2> devuelve la variable de referencia delantera, trasera de retorno es constante. Así ++++ c legítima, y c ++++ no es legítimo;
3> c ++++ ¿Por qué no deja que sea legal? Si usted quiere lograr c ++++ legítima, debe volver al conjunto de variables o referencias a variables. c ++ c valor es volver otra vez 1, es imposible volver a c, debe establecer primero una variable local para almacenar el valor inicial de c, y luego volver a las variables locales (variables locales no permiten que devuelve una referencia), pero vuelve una variable local después de eso, si vuelve a conectar a la vez ++ operador, está involucrado en el cálculo del valor de una variable local, por lo que en este hecho equivalente a C ++ ++++ el caso c, no habría ningún sentido.