Programa que elige el mayor complejo de un array de ellos. Fallo de salida

[NikNitro!]

Bueno pues seguimos con los ejercicios estos. En este caso el fallo está al imprimir un dato dentro del struct TComplejo. El código es el siguiente:

Código [Seleccionar] Expandir

#include <iostream>
#include<cmath>
using namespace std;
const int TAMANO = 50;
struct TComplejo {
double p_real, p_imaginaria;
};
typedef TComplejo Tarray[TAMANO]; 

void imprimirComplejo (TComplejo complejo){
double a = complejo.p_real;
double b = complejo.p_imaginaria;
if (b<0){
cout << a << b << "i" << endl;
} else {
cout << a << "+" << b << "i" << endl;
}
}

double moduloDeComplejo(TComplejo complejo) {
double radikal = pow(complejo.p_real,2)+ pow(complejo.p_imaginaria,2);
double modulo = sqrt(radikal);
return modulo;
}

void mayorComplejo (Tarray array1, TComplejo& complejo){
TComplejo prueba;
//Tarray array1;
for (int i = 0; i<TAMANO; i++) {
prueba = array1[i];
if ( moduloDeComplejo(prueba)>moduloDeComplejo(complejo)) complejo = prueba;
}
}

int cuantosHay(){
int tamano;
cout << "Introduzca cuantos complejos va a introducir: ";
cin >> tamano;
return tamano;
}

void introduzcaValores(Tarray& array, int tamano){
//Tarray array;
for (int i = 0; i < tamano; i++) {
cout <<endl<< "Introduzca parte real del complejo nº"<<i+1<<": ";
cin  >>array[i].p_real;
cout <<endl<< "Introduzca parte imaginaria del complejo nº"<<i+1<<": ";
cin  >>array[i].p_imaginaria;
}
}

int main() {
Tarray array;
TComplejo elMayor;
int tamano = cuantosHay();
introduzcaValores(array, tamano);
mayorComplejo(array, elMayor);
cout << "El complejo con mayor módulo de todos es -->  ";
imprimirComplejo(elMayor);
return 0;
}

pero resulta que si le meto como entrada de tamano el valor 0 me devuelve:
"El complejo con mayor módulo de todos es -->  1.31755e+281+4.5515e+264i"

por lo que pienso que el error es al imprimir. ¿Qué me decís? Gracias ^^

S@lu2;)

[amchacon]

Si le metes Tamanyo 0, ningun bucle for de los que has puesto se ejecutará. Al no rellenar los vectores solo imprimiras basura.

Lo unico que tienes que hacer es una pequeña comprobación en el main:

Código (cpp) [Seleccionar] Expandir

int main()
{
   Tarray array;
   TComplejo elMayor;
   int tamanyo = cuantosHay();

   if (tamanyo != 0)    
   {
       introduzcaValores(array, tamanyo);
       mayorComplejo(array, elMayor);
       cout << "El complejo con mayor módulo de todos es -->  ";
       imprimirComplejo(elMayor);
   }
   else
        cout<<"Error, no se puede introducir un tamanyo de cero";
       
   return 0;
}

[NikNitro!]

La pega sigue siendo la misma :s
Esta es la salida:

Código [Seleccionar] Expandir

Introduzca cuantos complejos va a introducir: 2

Introduzca parte real del complejo nº1: 50

Introduzca parte imaginaria del complejo nº1: 3

Introduzca parte real del complejo nº2: 2

Introduzca parte imaginaria del complejo nº2: 1
El complejo con mayor módulo de todos es -->  6.09354e+265+1.03941e+268i


[leosansan]

Uno de los problemas fundamentales está en el uso de TAMANO en las funciones, cuando deberías usar tamano, porque si no se llenan los restantes 50 valores de "basura" y te dan un resultado disparatado. Además creo que deberías incorporar la variable "módulo" a la strct, junto a parte real e imaginaria.
El otro error está en la función imprimir que le pasas un valor no establecido y te devuelve basura, aunque el resto del programa esté haciendo lo correcto.
Por cierto, puedes entrar el complejo nulo sin problemas, si  cambias lo de tamano.
Como prueba he cambiado algunas cositas ... y funciona. Fíjate en los cambios y adecua los a tus funciones originales:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include<cmath>

using namespace std;
const int TAMANO = 50;
struct TComplejo {
double p_real, p_imaginaria;
};
typedef TComplejo Tarray[TAMANO];
/*********************************************/
/*void imprimirComplejo (TComplejo complejo){
double a = complejo.p_real;
double b = complejo.p_imaginaria;
if (b<0){
cout << a << "-" << b << "i" << endl;
} else {
cout << a << "+" << b << "i" << endl;
}
}*/
/*********************************************/
double moduloDeComplejo(Tarray& array, int tamano) {
double modulo[tamano],mayor=0;
for (int i = 0; i<tamano; i++){
   double radikal = pow(array[i].p_real,2)+ pow(array[i].p_imaginaria,2);
   modulo[i] = sqrt(radikal);
 }
for (int i = 0; i<tamano; i++){
   if ( modulo[i]>mayor) mayor = modulo[i];
   }
 return mayor;
}
/*********************************************/
/*void mayorComplejo (Tarray& array, int tamano){
double mayor=0;
//Tarray array1;
for (int i = 0; i<tamano; i++) {

if ( moduloDeComplejo(i)>menor) mayor = moduloDeComplejo(i);
}
}*/
/*********************************************/
int cuantosHay(){
int tamano;
cout << "Introduzca cuántos complejos va a introducir: ";
cin >> tamano;
return tamano;
}
/*********************************************/
void introduzcaValores(Tarray& array, int tamano){
//Tarray array;
for (int i = 0; i < tamano; i++) {
cout <<endl<< "Introduzca parte real del complejo nº"<<i+1<<": ";
cin  >>array[i].p_real;
cout <<endl<< "Introduzca parte imaginaria del complejo nº"<<i+1<<": ";
cin  >>array[i].p_imaginaria;
}
}
/*********************************************/
int main() {
Tarray array;
TComplejo elMayor;
int tamano = cuantosHay();
introduzcaValores(array, tamano);
 cout <<endl<< "El complejo con mayor modulo de todos es -->  ";
 cout<<moduloDeComplejo(array, tamano);

 return 0;
}
/*********************************************/

Saluditos!.
REEDITO:
Con el valor tamano corregido, el valor mayor lo obtienes en la función "mayorComplejo" y desde ahí, con ese valor "mayor" llamo a la función imprimir ..... y funciona O.K:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include<cmath>
#include<cstdlib>
using namespace std;
const int TAMANO = 50;
struct TComplejo {
double p_real, p_imaginaria;
};
typedef TComplejo Tarray[TAMANO];

void imprimirComplejo (TComplejo complejo){
double a = complejo.p_real;
double b = complejo.p_imaginaria;
if (b<0){
cout << a << b << "i" << endl;
} else {
cout << a << "+" << b << "i" << endl;
}
}

double moduloDeComplejo(TComplejo complejo) {
double radikal = pow(complejo.p_real,2)+ pow(complejo.p_imaginaria,2);
double modulo = sqrt(radikal);
return modulo;
}

void mayorComplejo (Tarray array1, TComplejo& complejo, int tamano){
TComplejo mayor;

//Tarray array1;
for (int i = 0; i<tamano; i++) {
mayor = array1[i];
   if ( moduloDeComplejo(mayor)>=moduloDeComplejo(array1[i])) mayor = array1[i];

}
imprimirComplejo(mayor);
}

int cuantosHay(){
int tamano;
cout << "Introduzca cuantos complejos va a introducir: ";
cin >> tamano;
return tamano;
}

void introduzcaValores(Tarray& array, int tamano){
//Tarray array;
for (int i = 0; i < tamano; i++) {
cout <<endl<< "Introduzca parte real del complejo "<<i+1<<": ";
cin  >>array[i].p_real;
cout <<endl<< "Introduzca parte imaginaria del complejo "<<i+1<<": ";
cin  >>array[i].p_imaginaria;
}
}

int main() {
Tarray array;
TComplejo elMayor;
int tamano = cuantosHay();
introduzcaValores(array, tamano);
 cout << "El complejo con mayor modulo de todos es -->  ";
mayorComplejo(array, elMayor, tamano);
return 0;
}


[NikNitro!]

Muchas gracias

La verdad es que el ejercicio ya lo entregué (mal xD) pero aun asi me gusta aprender de mis errores ^^

Nos vemos