c++ - sencillos - Sobrecargar el operador

sobrecarga de operadores relacionales en c++

Question

Soy un principiante en C ++. Estoy aprendiendo sobre cómo sobrecargar a los operadores. He creado una clase compleja que representa números complejos y métodos para la aritmética compleja y una clase ComplexArray que representa matrices de elementos de longitud fija en el espacio vectorial complejo C.

Recibo errores del compilador, que no puede encontrar la forma correcta de operador []. Sin embargo, busqué en Internet y no puedo corregir el error. Cualquier sugerencia / consejo en la dirección correcta sería de gran ayuda.

Código de gravedad Descripción Proyecto Archivo Estado de supresión de línea
Error C2676 binario ''['': ''const ComplexArray'' no define este operador o una conversión a un tipo aceptable para el operador predefinido ComplexArrays c: / users / quasa / source / repos / complexarrays / complexarrays / testcomplexarray.cpp 7

Aquí está mi código:

TestComplexArray.cpp

#include <iostream>
#include "ComplexArray.h"
Complex ComplexSum(const ComplexArray& cArray, int size)
{
Complex sum = cArray[0];
for (int i = 1; i < size; i++)
{
sum = sum + cArray[i];
}
return sum;
}
Complex ComplexProduct(const ComplexArray& cArray, int size)
{
Complex product = cArray[0];
for (int j = 1; j < size; j++)
{
product = product * cArray[j];
}
return product;
}
int main()
{
char ch;
const int size = 5;
ComplexArray cArray(size);
for (int i = 0; i < size; i++)
{
cArray[i] = Complex((double)(i + 1), 0);
std::cout << cArray[i];
}
Complex sum = ComplexSum(cArray, size);
Complex product = ComplexProduct(cArray, size);
std::cout << "Sum = " << sum << std::endl;
std::cout << "Product = " << product << std::endl;
std::cin >> ch;
return 0;
}

ComplexArray.h

class ComplexArray
{
private:
Complex* complexArr;
int size;
ComplexArray();
public:
//Constructors and destructors
ComplexArray(int size);
ComplexArray(const ComplexArray& source);
virtual ~ComplexArray();
//Range for the complexArr
int MaxIndex() const;
//Overload the indexing operator
const Complex& operator [](int index) const;
Complex& operator [](int index);
};

ComplexArray.cpp

#include "Complex.h"
#include "ComplexArray.h"
ComplexArray::ComplexArray(int s)
{
size = s;
complexArr = new Complex[size];
}
ComplexArray::ComplexArray(const ComplexArray& source)
{
//Deep copy source
size = source.size;
complexArr = new Complex[size];
for (int i = 0; i < size; i++)
{
complexArr[i] = source.complexArr[i];
}
}
ComplexArray::~ComplexArray()
{
delete[] complexArr;
}
int ComplexArray::MaxIndex() const
{
return (size - 1);
}
/*
c1.operator[](int index) should return a reference to the Complex
object, because there are two possible cases.
Case 1:
Complex c = complexArray[3];
Case 2:
complexArray[3] = c;
In the second case, complexArray[3] is an lvalue, so it must return
a Complex object by reference, so that it can be assigned to.
*/
const Complex& ComplexArray::operator[] (int index) const
{
return complexArr[index];
}
Complex& ComplexArray::operator[](int index)
{
return complexArr[index];
}

Complejo.h

#include <iostream>
class Complex
{
private:
double x;
double y;
void init(double xs, double ys); //Private helper function
public:
//Constructors and destructors
Complex();
Complex(const Complex& z);
Complex(double xs, double ys);
virtual ~Complex();
//Selectors
double X() const;
double Y() const;
//Modifiers
void X(double xs);
void Y(double ys);
//Overload binary +, = and * operators
Complex operator + (const Complex& z);
Complex& operator = (const Complex& z);
Complex operator * (const Complex& z) const;
//Overload unary - operator
Complex operator -() const;
friend Complex operator * (const double alpha, const Complex& z);
friend Complex operator * (const Complex& z, const double beta);
//Overload << operator
friend std::ostream& operator << (std::ostream& os, const Complex& z);
//A complex function f(z)=z^2
Complex square();
};

Answer 1

Como todos ustedes han señalado, me faltaba la definición avanzada de un #include.

Complex.cpp tiene el encabezado

#include "Complex.h"

ComplexArray.h tiene el encabezado

#include "Complex.h"

ComplexArray.cpp tiene el encabezado

#include "ComplexArray.h"

TestComplexNumbers.cpp tiene el encabezado

#include <iostream>
#include "ComplexArray.h"

Mis errores de compilación han sido resueltos.

Answer 2

ComplexArray depende de Complex pero el orden de las inclusiones no se ve bien

#include "ComplexArray.h"
#include "Complex.h"

Tienes que reenviar-declarar Complex antes de ComplexArray

 class Complex; 

El código falla en / testcomplexarray.cpp línea 7 que es

 Complex sum = cArray[0];

Parece que tienes problemas con ctors de Complex. Asegúrese de que NO haya definido tales:

 Complex(Complex& v); // that''s bad. it prevents to use copy constructor

Si necesita copiar ctor por alguna razón inconcebible, siempre debe verse así:

 Complex(const Complex& v);

Answer 3

No creo que el error provenga del operador [], como se puede ver en la función:

Complex ComplexSum(const ComplexArray& cArray, int size)
{
Complex sum = cArray[0];
for (int i = 1; i < cArray.MaxIndex(); i++)
{
sum = sum + cArray[i];
}
}

No devuelves un resultado. Eso es fatal.