Was sind die besten Methoden zum sicheren und schnellen Kopieren von Dateien in C und was sind ihre jeweiligen Vor- und Nachteile?

Sicheres und schnelles Kopieren von Dateien in C

Übersicht

Das Kopieren von Dateien ist eine häufige Aufgabe in der Programmierung. Es ist wichtig, diese Aufgabe mit Vernunft und Effizienz anzugehen. In diesem Artikel werden verschiedene Techniken zum Kopieren von Dateien in C untersucht und gleichzeitig deren Vor- und Nachteile erörtert. Wir behandeln unter anderem Standard-C-Funktionen, POSIX-Funktionen und C-Stream-Puffer.

ANSI-C-Ansatz: fread() und fwrite()

Dieser Ansatz verwendet die C-Standardbibliotheksfunktionen fread () und fwrite() zum Lesen und Schreiben von Daten in Blöcken. Obwohl es eine Steuerung auf niedriger Ebene bietet, erfordert es eine explizite Pufferverwaltung und kann ausführlich sein.

// ANSI-C-WAY
#include <stdio.h> // fopen(), fclose(), fread(), fwrite(), BUFSIZ
#include <cstdio> // size_t
using namespace std;

int main() {
    // Define buffer size (BUFSIZE default is 8192 bytes)
    const size_t BUFFER_SIZE = 4096;
    char buf[BUFFER_SIZE];
    size_t size;

    FILE* source = fopen("from.ogv", "rb");
    FILE* dest = fopen("to.ogv", "wb");

    while (size = fread(buf, 1, BUFFER_SIZE, source)) {
        fwrite(buf, 1, size, dest);
    }

    fclose(source);
    fclose(dest);

    return 0;
}

POSIX-Ansatz: read() und write()

Dieser Ansatz nutzt den POSIX-Read( ) und write()-Funktionen, die mehr Kontrolle über die Dateivorgänge bieten als der ANSI-C-Ansatz. Es bietet die Möglichkeit, größere Dateien zu verarbeiten und Fehler sorgfältiger zu behandeln.

// POSIX-WAY
#include <fcntl.h> // open()
#include <unistd.h> // read(), write(), close()
#include <stdio.h> // BUFSIZ
using namespace std;

int main() {
    // Define buffer size (BUFSIZE default is 8192 bytes)
    const size_t BUFFER_SIZE = 4096;
    char buf[BUFFER_SIZE];
    size_t size;

    int source = open("from.ogv", O_RDONLY, 0);
    int dest = open("to.ogv", O_WRONLY | O_CREAT | O_TRUNC, 0644);

    while ((size = read(source, buf, BUFFER_SIZE)) > 0) {
        write(dest, buf, size);
    }

    close(source);
    close(dest);

    return 0;
}

KISS-C-Streambuffer-Ansatz: Stream-Puffer

Dieser Ansatz nutzt C-I/O-Stream-Puffer. Es ist prägnant und unkompliziert und verwendet die rdbuf()-Methode zum Kopieren der gesamten Datei, sodass die C-Laufzeit Low-Level-I/O verarbeiten kann.

// KISS-C++-Streambuffer-WAY
#include <iostream> // cout, cin
#include <fstream> // ifstream, ofstream
using namespace std;

int main() {
    ifstream source("from.ogv", ios::binary);
    ofstream dest("to.ogv", ios::binary);

    dest << source.rdbuf();

    source.close();
    dest.close();

    return 0;
}

COPY-ALGORITHMUS-C-Ansatz: copy()-Algorithmus

Der C copy()-Algorithmus kann Daten effizient von einer Datei in eine andere kopieren. Dieser Ansatz profitiert von den robusten Iteratoren des STL, sodass die Pufferverwaltung nicht mehr manuell verwaltet werden muss.

// COPY-ALGORITHM-C++-WAY
#include <iostream> // cout, cin
#include <fstream> // ifstream, ofstream
#include <ctime> // clock_t, clock()
#include <algorithm> // copy
#include <iterator> // istreambuf_iterator, ostreambuf_iterator
using namespace std;

int main() {
    ifstream source("from.ogv", ios::binary);
    ofstream dest("to.ogv", ios::binary);

    istreambuf_iterator<char> begin_source(source);
    istreambuf_iterator<char> end_source;
    ostreambuf_iterator<char> begin_dest(dest);
    copy(begin_source, end_source, begin_dest);

    source.close();
    dest.close();

    return 0;
}

OWN-BUFFER-C-Ansatz: Eigene Pufferverwaltung

Dieser Ansatz weist seinen eigenen Puffer zu, Bietet eine detaillierte Kontrolle über die Speicherverwaltung und die Puffergröße. Es erfordert eine sorgfältige Speicherfreigabe, um Lecks zu vermeiden.

// OWN-BUFFER-C++-WAY
#include <iostream> // cout, cin
#include <fstream> // ifstream, ofstream
#include <ctime> // clock_t, clock()
using namespace std;

int main() {
    ifstream source("from.ogv", ios::binary);
    ofstream dest("to.ogv", ios::binary);

    // Determine file size and allocate buffer
    source.seekg(0, ios::end);
    ifstream::pos_type size = source.tellg();
    source.seekg(0, ios::beg);
    char* buffer = new char[size];

    // Copy file
    source.read(buffer, size);
    dest.write(buffer, size);

    // Cleanup
    delete[] buffer;
    source.close();
    dest.close();

    return 0;
}

LINUX-Ansatz: sendfile()-Funktion

Die Linux-spezifische sendfile()-Funktion nutzt die Optimierung auf Kernelebene und die direkte Datenübertragung zwischen Dateideskriptoren. Dieser Ansatz ist für seine Effizienz bekannt, insbesondere bei großen Dateiübertragungen.

// LINUX-WAY
#include <iostream> // cout, cin
#include <sys/sendfile.h> // sendfile
#include <fcntl.h> // open
#include <unistd.h> // close
#include <sys/stat.h> // stat
#include <sys/types.h> // stat
#include <ctime> // clock_t, clock()
using namespace std;

int main() {
    int source = open("from.ogv", O_RDONLY, 0);
    int dest = open("to.ogv", O_WRONLY | O_CREAT | O_TRUNC, 0644);

    // Determine file size
    struct stat stat_source;
    fstat(source, &stat_source);

    // Copy file
    sendfile(dest, source, 0, stat_source.st_size);

    close(source);
    close(dest);

    return 0;
}

Vergleich und Schlussfolgerung

Die bereitgestellten Ansätze unterscheiden sich in Komplexität, Effizienz und Kontrolle. Hier ist eine Zusammenfassung ihrer Stärken und Grenzen:

Approach	Pros	Cons
ANSI C	Low-level control, portable	Verbose, buffer management required
POSIX	More control than ANSI C, handles large files	Still requires explicit buffer management
KISS-C -Streambuffer	Concise, stream buffer manages I/O	High-level, less control over buffering
COPY-ALGORITHM-C	Efficient, STL iterators handle data transfer	Requires caution with large files to avoid buffering issues
OWN-BUFFER-C	Fine-grained control over buffer management	Memory management must be handled carefully to avoid leaks
LINUX-sendfile()	Fast, kernel-level optimization	Linux-specific, requires elevated privileges

Die Wahl des besten Ansatzes hängt von den spezifischen Anforderungen Ihrer Anwendung ab. Für kleine Dateien kann die Einfachheit von ifstream/ofstream ausreichen. Für große Dateien oder Szenarien, in denen Effizienz entscheidend ist, ist sendfile() eine großartige Option. Letztendlich empfiehlt es sich, verschiedene Ansätze zu testen und zu vergleichen, um die optimale Lösung für Ihren Anwendungsfall zu ermitteln.

Das obige ist der detaillierte Inhalt vonWas sind die besten Methoden zum sicheren und schnellen Kopieren von Dateien in C und was sind ihre jeweiligen Vor- und Nachteile?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!