if((*it) == borrar){      
                       NomEst.erase(it);
                       --it; 

Una vez que haces "erase", el iterador que has utilizado deja de ser válido, ya que el elemento al que apunta deja de pertenecer al vector. Cualquier operación sobre ese vector que realices después del "erase" es una operación no válida.

Para hacer esto tienes varias opciones. Yo te comento dos de ellas:

1. Creas un iterador temporal y después borras el elemento. De esta forma conservas un iterador válido después de la operación:

if((*it) == borrar){
  std::vector< std::string > itTemp = it--;
  NomEst.erase( itTemp );

Porque claro, el iterador sobre el que se hace "erase" deja de ser válido... pero el resto de iteradores siguen siendo totalmente válidos.

El problema que tiene este sistema es que si intentas eliminar el primer elemento del vector, it-- resulta entonces en una operación no válida. Puedes intentar hacer una lógica un poco más completa para detectar esta situación y actuar en consecuencia, o puedes pasar a la otra opción.

2. Hacer uso de la STL para marcar los elementos a borrar. Hay una función en la STL llamada "remove". Esta función itera un contenedor y ejecuta una comprobación sobre cada elemento. Si la condición resulta positiva, marca el elemento para eliminar. Al finalizar la función, los elementos a borrar se encontrarán al final del vector, por lo que nos podemos cargar todos de un plumazo borrando un rango de iteradores.

std::vector< std::string > itEnd = std::remove( NomEst.begin( ), NomEst.end( ), nombre );
NomEst.erase( itEnd, NomEst.end( ) );

"remove" pertenece a la librería "algorithm"

También existe la función "remove_if". Si bien esta variante es mucho más potente, puesto que permite usar una función personalizada para detectar los elementos a eliminar, es un pelín más compleja de usar y no merece la pena en este caso tan sencillo. Te lo comento por si te pica la curiosidad y quieres investigar un poco más sobre el tema.

En cuanto a tu problema con la búsqueda... fflush no se puede usar con buffer de entrada y stdin es un buffer de entrada. Conclusión, esa línea no debería estar en tu programa. Si necesitas borrar el buffer de entrada hay otros mecanismos, buscando en google encontrarás algunos), pero no creo que necesites limpiarlo en tu caso.

Un saludo.

void setNomEst(vector<string> pNomEst){NomEst = pNomEst;}

El código funciona, hasta ahí todo bien. Sin embargo te pongo un pequeño "pero". En la función de arriba, pNomEst va a ser una copia del vector que pases como parámetro. Una vez hecha la copia, el contenido de pNomEst se va a copiar en la variable interna NomEst, es decir, vas a copiar el puntero dos veces.

Este comportamiento suele ser algo a evitar por cuestiones de rendimiento. Puedes evitar una de las dos copias pasando el argumento por referencia en vez de por valor:

void setNomEst(const vector<string>& pNomEst){NomEst = pNomEst;}

Añadimos "const" porque la referencia se comporta, a efectos prácticos, como un puntero. Dado que no se desea que "pNomEst" cambie dentro de esta función, lo suyo es etiquetar la variable como "const" para asegurarnos.

Un saludo

Lo actual ahora no venia siendo C++14?

una librería no es más que un "paquete" de clases y funciones que puedes usar para añadir funcionalidad a tu aplicación. Usar librerías no implica crear aplicaciones gráficas, así como el diseño de aplicaciones gráficas no implica usar librerías.

Las librerías pueden ser estáticas o dinámicas. Las estáticas se empaquetan junto al ejecutable en tiempo de compilación (un ejemplo lo tienes en la librería estándar de C o C++). Las dinámicas son archivos independientes que se enlazan en tiempo de ejecución.

En cuanto al tema de aplicaciones gráficas. Todos los sistemas gráficos que uses en windows van a usar, antes o después, la API de Windows. Sin embargo, aunque todos acaben pasando por ese aro, eso es totalmente transparente para tí. Cada librería gráfica tiene sus ventajas y sus inconvenientes. La cosa es que cates varios sistemas y eligas con cual te quedas.

Algunos ejemplos de librerías gráficas:

* API de Windows
* MFC (solo si programas con VS)
* Qt
* wxWidgets

Si preguntas por preferencias, lo dicho, cada uno te dirá una diferente. Sin embargo no suele haber un claro ganador en este punto.

Un saludo.

Pero vamos a ver... ¿cuánto puede tardar en ejecutarse este código? ¿Media milésima de segundo? ¿una milésima?

Vamos, a no ser que estés cargando una base de datos con 200.000.000.000 registros no creo que consigas notar diferencia alguna entre tu código y uno totalmente optimizado.

Pero tu mismo:

Los objetos pesados se pasan por referencia, no por valor.

cEstudiante(string vnomv) : nomv(vnomv){}

En esa línea estás creando un string temporal que, posteriormente, se usará para asignar el valor de "nomv". En tu código no vas a notar ningúna diferencia, pero es bastante más óptimo pasar los strings por referencia para evitar la creación de objetos temporales:

cEstudiante(const string& vnomv) : nomv(vnomv){}

No uses system

Las llamadas a "system" son muy lentas. Es mucho más eficiente programarte tu propia rutina que espere una pulsación del teclado.

Evita la copia innecesaria de objetos

cEstudiante runEstudiante = vEstudiante[i];

Ahí estás haciendo una copia de vEstudiante. Después de esa línea "runEstudiante" y "vEstudiante" son dos objetos independientes... estas copias consumen tiempo de ejecución y memoria.

Puedes evitar la copia usando referencias o haciendo uso de iteradores:

cEstudiante& runEstudiante = vEstudiante[i];

std::vector< cEstudiante >::iterator it, itEnd = vEstudiante.end( );
for (it = vEstudiante.begin( ); it != itEnd; ++it )
{
  if( it->nomv == NomEst)
    cont++;	
}

fflush es solo para buffer de salida

fflush(stdin);

Esa línea tienes que evitarla a toda costa. fflush, de acuerdo con el estándar, está pensado para vaciar un buffer de salida, no un buffer de entrada. Dependiendo del sistema operativo esta línea te puede dar problemas.

Y con esto ya tienes algo con lo que empezar. Aunque no esperes notar demasiada diferencia... si tu programa hiciese cálculos matemáticos intensivos todavía... pero manejar un vector de 20 o 30 objetos...

Iteras el array y, para cada elemento, compruebas si los parámetros de dicho elemento coinciden con los buscados:

std::string nombre;
std::cout << "Nombre del trabajador: " << std::endl;
std::cin >> nombre;
 
for( int i=0; i < 20; i++ )
{
  if ( Trabajador[i].nombre == nombre )
  {
    std::cout << "Nombre: " << Trabajador[i].nombre << std::endl;
    std::cout << "Edad: " << Trabajador[num].edad << std::endl;
    std::cout << "Empresa: " << Trabajador[num].empresa << std::endl;
  }
}

PD.: si usas "new", asegúrate de hacer "delete" cuando ya no vayas a usar el array para liberar la memoria

Lo normal es que la declaración del struct se haga fuera de la función:

struct Personaje{
  char nombre[30];
  int edad;
  char empresa[30];
};
 
int main( )
{
  struct Personaje Trabajador;
}

Partiendo de esta base, para no guarrear mucho el código, siempre puedes crear un array fijo de elementos:

int main( )
{
  int i;
  struct Personaje Trabajadores[20];
  for( i=0; i < 20; ++i )
    Trabajadores[ i ].edad = 20 + i;
}

El ejemplo anterior crea un array de 20 elementos de tipo "Personaje". El bucle, para mostrarte un ejemplo sobre cómo se puede acceder a los elementos de ese array, asigna una edad a cada uno de ellos: 20 al primero, 21 al segundo, 22 al siguiente y así.

Esto es con arrays de tamaño fijo. También puedes crearlos del tamaño que tu quieras haciendo uso de la memoria dinámica:

int main( )
{
  int i;
  struct Personaje *Trabajadores = (struct Personaje*)malloc( 20 * sizeof( struct Personaje ) );
  for( i=0; i < 20; ++i )
    Trabajadores[ i ].edad = 20 + i;
 
  free( Trabajadores );
}

En el caso de la memoria dinámica, hay que acordarse de liberar luego esta memoria para poder reutilizarla en el futuro.

Un saludo.

¿De verdad te preocupa la eficiencia de este código?

No se hacen tareas. Publica tu código y tus dudas o no vas a recibir ninguna respuesta.

Un saludo

otra cosa:

class Circulo
{
  // ...
  char *Color;
};

Con esa declaración de "Color"...

Circulo::Circulo() //por defecto
{
    strcpy(Color,"");
}

Esa copia va a fallar... Color no apunta a ninguna dirección de memoria válida.

Y esta otra asignación:

Circulo::Circulo(float x,float y,unsigned diam,char *Color) //parametrizado
{
    this->Color= Color;
}

Puede darte problemas, ya que los dos char* apuntan al mismo sitio... si modificas una de las dos cadenas la otra también va a cambiar:

int main( )
{
  char cad1[10];
  strcpy( cad1, "Test" );
 
  Circulo circulo( 1, 2, cad );
 
    strcpy( cad1, "Hola" );
 
    std::cout << cad1 << std::endl;
    std::cout << circulo.Color << std::endl; // Pon Color en el public para que esto compile.
}

Y lo mismo con el constructor copia. No es un fallo como tal pero te puede dar problemas.

Un saludo.