Comment puis-je copier un fichier d'un répertoire à un autre en c/c++

Je suis à la recherche d'un exemple simple sur la façon de copier un fichier d'un répertoire à un autre en C. Le programme doit utiliser uniquement de la croix-plate-forme de fonctions natives de C.

"Indigènes", les fonctions sont à peu près le contraire de "cross-plateforme" des fonctions. Les fonctions natives sont ceux qui sont "de souche", pour un OS, et donc spécifiques. "Cross-plateforme" fonctions sont disponibles partout, par la vertu d'être construit au-dessus de ces fonctions natives.
Vous pouvez utiliser #ifdef #else et #endif ceux de pré-traitement des blocs à l'appel de la plate-forme, les fonctions liées et laisser le compilateur prendre la décision en appel.
Bien dit, mais je pense que le démarrage d'une question avec "je cherche", indique un non-anglophone. :-/ J'ai moi-même interpréter l'OP est le sens est qu'il/elle voulait utiliser une bibliothèque que sous le capot appelle "copier le fichier" indigènes. Il serait dès lors d'exclure le (malheureusement) upvoted réponses ici sur le déploiement de son propre copie basée sur la simple lecture d'un fichier et de l'écriture à l'autre...

InformationsquelleAutor user63898 | 2011-09-01

c c++file-io

Ici est un simple non testé un programme C qui fait ce que vous avez besoin de:

#include <stdio.h>

int main(int argn, char * argv[]) {

    int src_fd, dst_fd, n, err;
    unsigned char buffer[4096];
    char * src_path, dst_path;

    //Assume that the program takes two arguments the source path followed
    //by the destination path.

    if (argn != 3) {
        printf("Wrong argument count.\n");
        exit(1);
    }

    src_path = argv[1];
    dst_path = argv[2];

    src_fd = open(src_path, O_RDONLY);
    dst_fd = open(dst_path, O_CREAT | O_WRONLY);

    while (1) {
        err = read(src_fd, buffer, 4096);
        if (err == -1) {
            printf("Error reading file.\n");
            exit(1);
        }
        n = err;

        if (n == 0) break;

        err = write(dst_fd, buffer, n);
        if (err == -1) {
            printf("Error writing to file.\n");
            exit(1);
        }
    }

    close(src_fd);
    close(dst_fd);
}

InformationsquelleAutor mshamma

open source file read-only
create destination file for write
while there's still data in source file
    read data from source file
    write it to destination file
close both files

Je suis sûr que vous pouvez le faire!

+1 pour la dernière ligne de la réponse..!!!

InformationsquelleAutor Didier Trosset

1

@Mu Qiao mentionné boost::filesystem. Vous souhaitez chercher des exemples de copy_file, si vous pouvez copier des répertoires.

Si vous êtes intéressés à obtenir de fantaisie avec des e/S asynchrones, mon impression est que boost::asio est intéressant de mises en prendre avantage de la plate-forme de capacités pour vous permettre d'utiliser le CPU lors de l'attente pour le disque, comme il le fait pour le réseau:

Comment effectuer la Croix-Plate-forme de Fichier Asynchrone I/O en C++

(Note: Dernièrement, le pilote asio de la bibliothèque a été à venir à l'esprit ces derniers temps beaucoup de choses, mais j'ai toujours offrir l'avertissement que je ne l'ai pas utilisé dans un projet et avez aucune idée de ce que ses limites. Afin de prendre ma mention de cela avec un grain de sel.)

Il y a d'autres croix-plate-forme de bibliothèques offrant ce type de fonctionnalité, si vous êtes prêt à faire le buy-in, toujours une question de goût et besoins. Moi, j'aime Qt pour beaucoup de raisons, et il arrive à offrir un QFile::copy méthode:

http://doc.qt.nokia.com/latest/qfile.html#copy

InformationsquelleAutor HostileFork

/*
*
* Module    : Copy Multiple from Src dir to Dest dir
* Author    : Mohd Asif
* Date     : 12-March-2013
* Description    : This code will copy all the files from Src dir to Dest Dir 
*    instead of onother directory inside src dir
* */
#include<stdio.h>
#include<stdio.h>
#include<dirent.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/stat.h>
#define MAX 1024
int main()
{
char    arSrcPath[]    = "/home/mpe4/Src";    /*Source directory path*/
char    arDestPath[]    = "/home/mpe4/Dest";    /*dest directory path*/
struct    dirent* spnDirPtr;    /* struct dirent to store all files*/
DIR* pnOpenDir = NULL;    /*DIR Pointer to open Dir*/
DIR* pnReadDir = NULL;    /*DIR POinter to read directory*/
pnOpenDir = opendir(arSrcPath); 
if(!pnOpenDir)
printf("\n ERROR! Directory can not be open");
else
{    
int nErrNo = 0;
while(spnDirPtr = readdir(pnOpenDir))
{
if(nErrNo == 0)
nErrNo = errno;
printf("\n Now writing %s file...",spnDirPtr->d_name);
printf("\n dest file name = %s/%s\n", arDestPath, spnDirPtr->d_name);
struct stat st_buf;
stat(spnDirPtr->d_name, &st_buf);
if (S_ISDIR (st_buf.st_mode))
{
continue;
}
else if (S_ISREG (st_buf.st_mode))
{
FILE* pnReadFile = fopen(spnDirPtr->d_name,"r");
if(pnReadFile)
{
printf("\n Now reading %s file...",spnDirPtr->d_name);
char strDestFileName[MAX] = {0};
sprintf(strDestFileName, "%s/%s", arDestPath, spnDirPtr->d_name);
printf("\n dest file name = %s\n", strDestFileName);
FILE* pnWriteFile  = fopen(strDestFileName, "w");    /*File Pointer to write in file*/
if(pnWriteFile)
{
char buffer[MAX] = {0};    /*Buffer to store files content*/
while(fgets(buffer, MAX, pnReadFile))
{
fputs(buffer, pnWriteFile);
}
fclose(pnWriteFile);
}
else
{
printf("\n Unable to open file %s", strDestFileName);
}
fclose(pnReadFile);
}
else
{
printf ("\nERROR! File Could not be open for reading");
}
}
}
if(nErrNo != errno)
printf ("\nERROR Occurred!\n");
else
printf ("\nProcess Completed\n");
}
closedir(pnOpenDir);
return 0;
}

Une description, ce serait bien.

InformationsquelleAutor M Asif

0

Une autre alternative est quelque chose comme ceci:
```
#ifdef SOME_OS
#define COPY_STR "copy %s %s"  //some sort of OS-specific syntax
#elif defined SOME_OTHER_OS
#define COPY_STR "%s cpy %s"   //some sort of OS-specific syntax
#else
#error "error text"
#endif
```
...
```
#include <stdio.h>   //sprintf()
#include <stdlib.h>  //system()
char copy_str[LARGE_ENOUGH];
char* source;
char* dest;
...
sprintf (copy_str, COPY_STR, source, dest);
system (copy_str);
```
- Une remarque sur l'utilisation des approches comme ceci: percer un couteau de l'armée suisse shell pour une telle tâche, crée des risques...soit accidentelle, erreurs ou de vulnérabilité pour les pirates. Sur Windows, par exemple, quelqu'un pourrait fournir un source de "foo.txt bar.txt" et un dest de "& del *.*"...l'esperluette faisant de la chaîne de l'ensemble des commandes que "copy foo.txt bar.txt & del *.*". Rappelez-vous toujours Bobby Tables!!! xkcd.com/327
- Si vous voulez faire preuve de pirates, vous devez chiffrer tous les littéraux de chaîne etc trop. De toute façon, rien dans la Fpo post indique que c'est une préoccupation de leurs, ni qu'ils sont même à l'aide de Windows.
- Vous absolument pas besoin de chiffrer les littéraux de chaîne pour s'assurer qu'une ligne de code ne peut copier des fichiers et non de les supprimer. Une fonction comme boost::filesystem::copy_file n'est pas l'objet de telles préoccupations. Et je ne mentionne Windows parce que votre premier exemple de chaîne a été COPY_STR "copy %s %s" (au lieu de, disons COPY_STR "cp %s %s"). Le même genre de méfait est possible lorsque vous utilisez cette classe de la technique dans tous les OS, si jamais vous passez une chaîne qui provient d'une source en plus d'une valeur codée en dur dans votre programme. Nettoyage devient un problème, et souvent très au sérieux.
- Notez également que je n'ai pas dit que la technique n'est pas la peine de démontrer dans ce fil. Mais les problèmes potentiels doivent être mentionnés...et que c'est vraiment quelque chose à utiliser dans les situations où vous souhaitez l'opportunisme dans le code jetable. En Plus je n'ai même pas pris la peine de souligner que vous êtes en invoquant l'ensemble d'un interpréteur de commande et de l'environnement au lieu d'utiliser quelque chose qui traduit spécifiques natif du système de fichiers d'appels. (Ce qui est une autre raison de ne pas le faire de cette façon, même si dans mon esprit, la partie d'une plus grande préoccupation que c'est de la performance vs potentiellement désastreux de l'exactitude problème).
- Tout d'abord, boost est probablement pas portable, car elle n'est pas standard C++. L'OP a demandé de la croix-plate-forme, sans parler de tous les détails. De toute façon, c'est évidemment un C réponse. En effet, system() est livré avec une charge supplémentaire, mais depuis que la copie des fichiers est très lent par lui-même, il peut ou peut ne pas être un problème. Si vous êtes pour un whole lotta copie de fichier aussi rapidement que possible, vous êtes naturellement mieux en appelant le système d'exploitation de l'API tout de suite (depuis fprintf etc est livré avec un interprète trop) et mettez le système d'exploitation spécifiques au compilateur commutateurs autour de l'e/S de fichier de code.
- [1] Si vous avez des doutes à propos du coup de pouce de validité, je vous suggère soit d'investir un peu de temps à lire les threads de stimuler le processus d'examen ou de poser votre propre question à la: stackoverflow.com/questions/2342037/...
- [2] je vais (re...doucement?) réitérer que le sujet de la validation de la saisie et de l'assainissement est un sujet que vous devriez vraiment commettre un certain temps pour étudier, si vous allez en fait l'avocat de ce type d'approche sur quelque chose de plus contraint. Surtout à garder arguant lorsque l'on est confronté avec les faits de l'affaire. Allez, srsly?
- 1) Dans les systèmes embarqués, par exemple, vous serez heureux si vous venez de trouver un compilateur suivant la norme C++. Soutien pour les non-standard 3ème partie les bibliothèques seront très rares. Aussi, il est inutile de se demander de bureau gens au sujet de comment portable boost est, parce qu'ils ne pense pas que quoi que ce soit dans le monde, au-delà PC et Linux. 2) je n'ai jamais fait valoir à l'encontre de ce que vous avez dit, c'est effectivement un problème de sécurité. Mais c'est codé en dur littéraux de chaîne dans le binaire, un hacker pourrait modifier ceux aussi bien qu'ils le pourraient modifier le programme d'entrée/sortie. Soit vous faites le programme de sécuriser tout le chemin ou la sécurité ne sera pas pertinente.
- Nous en sommes au point où StackOverflow est maintenant en m'avertissant que le débat est trop long. Il semble en fait que quand tout est dit et fait nous n'avons pas fondamentalement en désaccord sur quoi que ce soit (autre que la portabilité de boost, qui je vous suggère de faire valoir par ailleurs). Donc je vais juste vous demander de vous déplacer les mises en garde que nous avons discuté de ce fil dans votre réponse, et nous en rester là!! Ces jours-ci je suis assez sûr que nous sommes les deux seules personnes de la lecture de ce de toute façon. 😛
InformationsquelleAutor Lundin

J'ai apporté quelques modifications à @te7 réponse pour copier un fichier d'un dossier à un autre sur MAC. J'ai essayé de modifier son code il suffit de copier un fichier, mais il a été partiellement de l'écriture du fichier de destination. Donc j'utilise un code différent pour le fichier en lecture/écriture

void copyFile(string srcDirPath, string destDirPath, string fileName)
{
string command = "mkdir -p " + destDirPath;
cerr << endl << "Command = " <<  command.c_str() << endl << endl;
system(command.c_str());
DIR* pnWriteDir = NULL;    /*DIR Pointer to open Dir*/
pnWriteDir = opendir(destDirPath.c_str());
if (!pnWriteDir)
cerr << endl << "ERROR! Write Directory can not be open" << endl;
DIR* pnReadDir = NULL;    /*DIR Pointer to open Dir*/
pnReadDir = opendir(srcDirPath.c_str());
if (!pnReadDir || !pnWriteDir)
cerr << endl <<"ERROR! Read or Write Directory can not be open" << endl << endl;
else
{
string srcFilePath = srcDirPath + fileName;
const char * strSrcFileName = srcFilePath.c_str();
fstream in, out;
in.open(strSrcFileName, fstream::in|fstream::binary);
if (in.is_open()) {
cerr << endl << "Now reading file " << strSrcFileName << endl;
string destFilePath = destDirPath + fileName;
const char * strDestFileName = destFilePath.c_str();
out.open(strDestFileName, fstream::out);
char tmp;
while(in.read(&tmp, 1))
{
out.write(&tmp, 1);
}
out.close();
in.close();
}
else
cerr << endl << "ERROR! File Could not be open for reading" << endl;
}
closedir(pnReadDir);
closedir(pnWriteDir);
}

InformationsquelleAutor durgeshtrivedi

Vous devez vous connecter pour publier un commentaire.