Mensajes

A mi me gusta más la tercera opción por varias razones:

* Existe encapsulamiento.

* Permite obtener un código más legible, sobretodo si se sobrecargan varios operadores ( suma, resta, ... )

* Su mantenimiento luego es más sencillo y se limitan la cantidad de "gazapos" por parte del que usa el objeto.

* Es muy sencillo acoplarle una batería te test para asegurar el correcto funcionamiento.

Se que tiene varias desventajas, pero desde mi punto de vista y mi experiencia ( trabajo en un cad orientado al sector naval ) me dicen que la tercera opción es la que más beneficios tiene.

Algunas desventajas:

* Resevas de memoria al crear copias del objeto, lo que reduce sensiblemente el rendimiento.

* Hay que currárselo todo al principio.

Cierto. Vi los random y me cegué jejejeje.

El problema es que llegar a tardar un tiempo infinito en mezclar el mazo.... si una de las combinaciones (fila, columna) no se da hasta pasadas miles de iteraciones... pues ahí que te quedas esperando.

Es posible que el error se esté produciendo en la línea inmediatamente anterior...

[amchacon]

Como dice amchacon, tu código genera cartas repetidas ( por mera cuestión de estadística es más probable el caso en el que mazo tiene cartas repetidas que el caso en el que todas la cartas son distintas ).

La solución a ese problema pasaría por crear primero un mazo ordenado, lo cual es fácil de generar, y después mezclarlo mediante una serie de permutaciones ( generar un par X, Y e intercambiar sus cartas ). El número de permutaciones necesarias para asegurar una mezcla adecuada variará en función del algoritmo que elijas.

Revisa el código, tiene comentarios con los errores que has cometido.

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <string>
#include <cstdlib>

const int cNotas=3, cEstudiantes=100;

using namespace std;

struct Estudiante
{
  string cuenta;
  string nombre;
  int edad;
  char sexo;

  void registrar_estudiantes( )
  {
    // ***********
    // getchar?? no mezcles NUNCA cin con getchar, por favor.
    // funcionan de forma diferente y mezclarlas puede provocar efectos extraños.
    // ***********
    cout <<"ingresar cuenta ";
    cin >> cuenta;
    cout <<"ingresar nombre ";
    cin >> nombre;
    cout <<"ingresar edad ";
    cin >> edad;
    cout <<"ingresar sexo ";
    cin >> sexo;
  }
};

struct Registro_Notas
{
  Estudiante alumno;
  int notas[cNotas];
};
Registro_Notas  registroNotas [cEstudiantes ] ;

void registrar_notas(int nestudiante)
{
  // ***********
  // nestudiante es el indice del estudiante actual... el bucle sobra
  // ***********

  // ***********
  // Si cambias 'i' por 'i+1' le das al usuario un indice mas legible
  // ***********
  cout<<"ingresar la informacion del estudiante "<< (nestudiante+1) <<endl;
  registroNotas[ nestudiante ].alumno.registrar_estudiantes( );

  // ***********
  // cNotas es una constante... la idea es usar un bucle
  // ***********
  for ( int j = 0; j < cNotas; j++ )
  {
    cout << "ingresar nota " << j+1 << " ";
    cin >> registroNotas[ nestudiante ].notas[ j ];
  }
}

// ***********
// promedio no es un argumento de la funcion... no tiene sentido
// lo que si tienes que pasarle es el indice del estudiante
// ***********
float calcular_nota_final( int estudiante )
{
  float promedio = 0.0;
  for ( int i=0; i < cNotas; i++ )
    promedio += registroNotas[ estudiante ].notas[ i ];
  promedio /= (float)cNotas;

  return promedio ;
}

// ***********
// j ??? que narices es j??? y si cambiamos j por estudiante ??? ahora queda mas claro, no?
// Pues eso.
// Ahora queda claro que todos los usos de cEstudiantes que tienes en esta funcion
// son incorrectos
// ***********
void imprimir(int estudiante)
{
  cout << registroNotas[ estudiante ].alumno.cuenta << "\t"
       << registroNotas[ estudiante ].alumno.nombre << "\t";

  for ( int i=0; i< cNotas; i++ )
    cout << registroNotas[ estudiante ].notas[ i ] << "\t";

  // ***********
  // Se supone que 100 es la nota máxima, no??
  // Entonces se aprobara si la nota es superior a 70, no inferior.
  // ***********
  if( calcular_nota_final( estudiante ) > 70.0)
    cout<<"aprobo";
  else
    cout<<"reprobo";
  cout << endl;
}

int main()
{
  int nestudiante=0;

  cout<<"ingrese cantidad de estudiantes a procesar ";
  cin>>nestudiante;

  cout << endl << "###" << nestudiante << "###" << endl;

  // ***********
  // Si nestudiante >= cEstudiante la aplicacion va a dar error, deberias controlar eso
  // ***********
  for (int i=0; i<nestudiante ;i++)
  {
    registrar_notas(i);
  }

  // ***********
  // Detalle: aqui puedes reutilizar i sin problemas.
  // ***********
  for (int i=0; i<nestudiante ;i++)
  {
    imprimir(i);
  }

  system("pause");

  // ***********
  // Detalle: aunque el compilador lo ponga por defecto, pon este return siempre.
  // ***********
  return 0;
}

Código (cpp) [Seleccionar] Expandir


for (int i=0; i<nestudiante ;i++){
registrar_notas(nestudiante); 
}

si a registrar_notas, le pasas siempre nestudiante, obviamente, la función no va a funcionar como esperas.

"nestudiante" es una constante... si tu quieres iterar tienes que usar la variable adecuada, en este caso la que recorre todos los valores desde 0 hasta "nestudiante", es decir, "i".

Código (cpp) [Seleccionar] Expandir


for (int i=0; i<nestudiante ;i++){
registrar_notas( i ); 
}

pero al momento de que el programa empieza a funcionar pasa algo por ejemplo pongo 2 de los cuales estudiantes quiero ingresar pero 2,1,0,1

Perdona pero no me he enterado de nada.

ademas no me tira el promedio ni las notas que e ingresado

Pon el código que tienes, que después de tantos cambios el anterior no es válido.

Además, estaría bien que indicases en la etiqueta "code" que el código es de C++ "code=cpp". Así tendrá un aspecto más legible.

Un último consejo... tabular el código con espacios hace que sea más legible en el foro que si usas el tabulador.

Es que esa línea no tiene ningún sentido.

A ver, respira hondo. Se supone que estás aprendiendo... y esto es parte del proceso de aprendizaje... si te doy todo mascado no vas a aprender nada salvo a copiar.

si "imprimir( )" es una función que retorna...nada, por qué le pones después ese ""??

Código (cpp) [Seleccionar] Expandir

registroNotas[i].alumno.registrar_estudiantes ;

si "registrar_estudiantes" es una función... tienes que llamarla con los paréntesis:

Código (cpp) [Seleccionar] Expandir

registroNotas[i].alumno.registrar_estudiantes( );

En cuanto al promedio... si lo almacenas en un int estarás perdiendo precisión, ya que un promedio únicamente almacena la parte entera de la operación... estás perdiendo los decimales.

Además, te pasa lo mismo que te he comentado antes, si cambias el valor de cNotas, el código no funcionará ya que hace todo "a piñón fijo"... la idea es que uses un bucle para calcular el promedio desde 0 hasta cNotas.

Código (cpp) [Seleccionar] Expandir


float promedio = 0.0;
for ( int j=0; j < cNotas; j++ )
 promedio += registroNotas[i].notas[ j ];
promedio /= (float)cNotas;

cambia estudiante por Estudiante...

y luego

Registro_Notas registroNotas[cEstudiantes ];

El segundo cambio no lo has aplicado