Mensajes

No necesitas la librería conio (puedes usar getchar() en lugar de getch()).

solo necesitas 2 for y 2 if... creo

2 if? Como compruebas si una letra es una vocal?

o multiplicar dicha variable por 2 directamente con lo que te ahorras tiempo de cálculo

Será sumar 2.

Mejor la API de Windows, está un poco más actualizado...

Todo numero par es divisible entre 2 (es decir, su resto es cero).

Recordemos que el resto de una división se sacaba con %

Buena idea, yo hize también un algoritmo recursivo pero en C++... Andara por algun lugar de este foro.

El determinante es una operacion complej, hacer un determinante de 20x20 puede trardar semanas (y me quedo corto).

Al ejecutar un programa, se le pueden proporcionar datos (muy util para transmitir datos entre programas).

Si no los vas a usar, puedes dejarlo en blanco.

Está desfasado, su última versión oficial fue hace 10 años.

Yo miraria pasarme a Codeblocks (la version que incluye el mingw). Merece la pena el cambio.

¿Por que usaa Borland? ¡Tiene casi 14 años!

Bajate el Codeblocks (la version que incluye mingw). Mucho más completo, multiplataforma... Y lo más importante, es reciente y se actualiza.

Con la librería estándar de I/E de C++:

Código (cpp) [Seleccionar] Expandir

            // Lanzador de excepciones
           
struct Excepcion
{
      string Mensaje; // Mensaje de error
      unsigned int Error; // Codigo de excepcion (los codigos se guardan en el header AMC CODIGOS_DE_ERROR.hpp
           
      Excepcion(string Texto,unsigned int ErroR) : Mensaje(Texto),Error(ErroR) {} // Contructor
};

void CopiarArchivos(ifstream &Lectura,ofstream &Escritura,unsigned long long Tamanyo_Archivo)
{
   char* Cosa; // Buffer para leer
   unsigned int Tamanyo_Lectura; // Variable que designa el tamaño de cada lectura
   unsigned long long Contador = 0;  // Variable auxiliar, se utiliza para contabilizar el progueso obtenido y calcular un porcentaje
   unsigned short Porcentaje = 0; // Porcentaje actual
   unsigned long long Limite; // Valor auxiliar correspondiente al 1% del tamanyo del archivo. Se utiliza para saber cuando hay que aumentar el porcentaje en 1
   unsigned long long Offset = 0; // Variable que contiene la posicion del archivo actual

if (!Lectura)
throw Excepcion("ERROR AL COPIAR ARCHIVOS, ARCHIVO DE ORIGEN NO ENCONTRADO",ARCHIVO_NO_ENCONTRADO);

// Si el tamanyo del archivo es inferior al buffer máximo permitido. Se leera el archivo del tirón
       
   if (Tamanyo_Archivo < 5242880)
           Tamanyo_Lectura = Tamanyo_Archivo;
   else
            Tamanyo_Lectura = 5242880; // Si no, se dejará en el máximo valor

/* Asignamos la memoria al buffer, si no se puede satisfacer la operación se intentará asignar un buffer menor,
si el tamaño del buffer llega a 1. La propia función de asignar memoria lanza una excepción que termina el programa */

while (!AsignarMemoria(Cosa,Tamanyo_Lectura))
{
Tamanyo_Lectura /=2;
}

/* Decidimos si vamos a mostrar el porcentaje o no, para aumentar el rendimiento. Solo se mostrará
si su tamaño es superior a 5 MB */

   if (Tamanyo_Archivo >  5242880)
    Limite = Tamanyo_Archivo/100;
   else
            Limite = 0; // Desactivado
           

while (Offset != Tamanyo_Archivo) // Mientras la posicion del archivo no llegue a su tamaño
         {
              // Leemos y escribimos
 
              Lectura.read(Cosa,Tamanyo_Lectura);
              Escritura.write(Cosa,Tamanyo_Lectura);
 
  Offset += Tamanyo_Lectura; // Aumentamos el progueso del archivo
             
  // Si el muestreo de porcentaje está activado...
 
              if (Limite != 0)
              {
  Contador += Tamanyo_Lectura; // Aumentamos el medidor
 
  if (Contador >= Limite) // Si el medidor supera el 1% del archivo
  {
 Porcentaje++; // Aumentamos el porcentaje
 cout<<Porcentaje<<"%"<<endl; // Lo mostramos por pantalla
 Contador = 0; // Reseteamos el medidor
  }
              }
             
  // Antes de repetir el bucle, comprobaremos si en la proxima lectura desbordaremos el archivo
 
              if ((Tamanyo_Archivo - Offset) < Tamanyo_Lectura)
              {
 // Si así es, hacemos una lectura con lo que nos quede del archivo
 
                 Lectura.read(Cosa,Tamanyo_Archivo - Offset);
                 Escritura.write(Cosa,Tamanyo_Archivo - Offset);
 
 // Situamos el indicador de posición al final del archivo
 
                 Offset = Tamanyo_Archivo;
              }
             
        }
       
     delete[] Cosa; //Borramos la memoria dinámica usada
}

/* Asigna el buffer de lectura, devuelve verdadero si tuvo exito.

Si no tuvo exito, devuelve falso por si se quiere modificar. Si no se puede modificar más, se lanza una excepción */

inline bool AsignarMemoria(char* &Cosa,unsigned int Lectura)
{
try
{
Cosa = new char[Lectura]; // Asignamos el buffer
return true; // Hemos conseguido asignar el buffer con exito
}
catch(...) // Si ocurrió alguna excepción
{
if (Lectura > 1) // Se devolverá "falso" para indicar que no se pudo asignar la memoria y asi dar una oportunidad para asignar un buffer menor
return false;
else // Si el tamaño del buffer no puede disminuir más, se lanza una excepción.
throw Excepcion("Error inesperado en la memoria",MEMORIA_NO_DISPONIBLE);
}
}

Código (c) [Seleccionar] Expandir

char* bola;

if (bola=="roja")
Cuando el compilador lee esto, interpetra que quieres comparar la dirreción de memoria del puntero char con el valor decimal de "roja" (se hace una conversión de cadena a su equivalente char).

Por eso te compila pero no funciona, aunque me extraña que el compilador no te lanzado un warning (a ver si lo adivino, usas Devcpp).