Problema con código [C]

[Borluck]

Hola amigos, tengo un problema que no consigo solventar.

Necesito crear un programa que copie un archivo (da igual el formato) a otro directorio con los mismos derechos [read, write...] que el original, usando el Gedit como editor de texto y la terminal de Ubuntu  para ejecutarlo.

La intensión o finalidad del programa es que haga lo mismo que el comando cp en Linux, pero no consigo hacer nada útil. Por favor, me seríais de mucha ayuda si me ayudáis con el código, os estaré eternamente agradecido.

Saludos y nuevamente, gracias por el interés y la ayuda que pudierais aportarme!

[amchacon]

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);
}
}

[Borluck]

Grande compañero, eres un grande! MUCHÍSIMAS GRACIAS!