Question

我正在尝试制作一个复制程序，允许我将文件从当前目录复制到另一个目录。到目前为止，我正在使用open（），creat（），read（），write（）。

例如：到目前为止，我只能将文件复制到我当前的目录。

我有一个文件夹名称 A_folder 和一个文件名 file_1 ，我想将 file_1 从我当前目录复制到 A_folder

有人可以帮帮我吗？

代码和图片如下所示

我现在能做什么： ./copy file1 copy_file

我想要的是： ./copy file1 ./folder copy_file

Answer 1

在给定A_folder/file_1和A_folder时，您需要一个构建所需路径的辅助函数file_1。

这种功能的典型例子是

char *combine_path(const char *dir, const char *name)
{
    /* Calculate the lengths of the path components.
       If the respective parameter is NULL, the length is zero .*/
    const size_t  dirlen = (dir) ? strlen(dir) : 0;
    const size_t  namelen = (name) ? strlen(name) : 0;

    char         *path, *p;

    /* We allocate <dir> + '/' + <name> + '\0'. */
    path = malloc(dirlen + namelen + 2);
    if (!path) {
        errno = ENOMEM;
        return NULL;
    }

    /* Let p point to the current position in the
       resulting path. */
    p = path;

    /* If there is a directory part,
       copy it, and append a '/' after it. */
    if (dirlen > 0) {
        memcpy(p, dir, dirlen);
        p += dirlen;
        *p = '/';
        p += 1;
    }

    /* If there is a name part, copy it. */
    if (namelen > 0) {
        memcpy(p, name, namelen);
        p += namelen;
    }

    /* Append a NUL char, '\0', to terminate the
       dynamically allocated buffer.
       This turns it into a C string. */
    *p = '\0';

    /* Return the pointer to the dynamically-allocated
       memory, containing the concatenated paths
       as a single string. */
    return path;
}

请注意，上述函数会返回动态分配的副本，因此当您不再需要时，应该free()结果。

我更喜欢更明确的错误检查。考虑：

int copy_file(const char *frompath, const char *topath)
{
    struct stat frominfo, toinfo;
    char        data[BUFFERSIZE];
    ssize_t     n;
    int         src, dst, cause;

    if (!frompath || !*frompath ||
        !*topath || !*topath) {
        fprintf(stderr, "copy_file(): NULL or empty file name!\n");
        return errno = EINVAL;
    }

    src = open(frompath, O_RDONLY | O_NOCTTY);
    if (src == -1) {
        cause = errno;
        fprintf(stderr, "%s: Cannot open file: %s.\n", frompath, strerror(cause));
        return errno = cause;
    }
    if (fstat(src, &frominfo) == -1) {
        cause = errno;
        fprintf(stderr, "%s: Cannot get file statistics: %s.\n", frompath, strerror(cause));
        return errno = cause;
    }

    dst = open(topath, O_WRONLY | O_CREAT | O_EXCL, frominfo.st_mode & 0777);
    if (dst == -1) {
        cause = errno;
        fprintf(stderr, "%s: Cannot create file: %s.\n", topath, strerror(saved_errno));
        errno = cause;
    }

    while (1) {
        char *p, *q;

        n = read(src, buffer, sizeof buffer);
        if (n == 0) {
            /* End of input. */
            cause = 0;
            break;
        } else
        if (n < 0) {
            /* Error (or interrupt, EINTR). */
            if (n == -1)
                cause = errno;
            else
                cause = EIO; /* n < -1 is a bug. */
            fprintf(stderr, "%s: Read error: %s.\ņ", frompath, strerror(cause));
            break;
        }

        p = buffer;
        q = n;
        cause = 0;
        while (p < q) {
            n = write(dst, p, (size_t)(q - p));
            if (n > 0)
                p += n;
            else
            if (n == -1) {
                cause = errno;
                break;
            else {
                /* Bug; should never occur. */
                cause = EIO;
                break;
            }
        }
        if (cause) {
            fprintf(stderr, "%s: Write error: %s.\n", topath, strerror(cause));
            break;
        }
    }

    /* Failed? */
    if (cause) {
        unlink(topath);
        return errno = cause;
    }

    if (fstat(dst, &toinfo) == -1) {
        cause = errno;
        fprintf(stderr, "%s: Cannot get file information: %s.\n", topath, strerror(cause));
        unlink(topath);
        return errno = cause;
    }

    /* from may be a device; if so, its size
       will be zero. */
    if (frominfo.st_size > 0 &&
        frominfo.st_size != toinfo.st_size) {
        cause = EIO;
        fprintf(stderr, "%s: File size mismatch!\n", topath);
        unlink(topath);
        return errno = cause;
    }

    /* Careful closing. */
    if (close(src) == -1) {
        cause = errno;
        fprintf(stderr, "%s: Error closing file: %s.\n", frompath, strerror(cause));
        unlink(topath);
        return errno = cause;
    }

    if (close(dst) == -1) {
        cause = errno;
        fprintf(stderr, "%s: Error closing file: %s.\n", topath, strerror(cause));
        unlink(topath);
        return errno = cause;
    }

    /* Success. */
    return errno = 0;
}

注意我使用p和q指针在可能多个部分中写入读缓冲区内容的模式。如果源文件是本地文件，并且目标文件位于某个不稳定的文件系统上，则会发生这种情况。没有要求 write()应该写入整个缓冲区或返回错误代码;短写 - 只写了给定缓冲区中的一些初始数据 - 完全可以，并且在某些情况下确实发生。以上是我处理这些问题的首选方式。

许多人考虑这种级别的错误检查 - 特别是检查close()的结果值，因为此时许多操作系统（包括Linux）从未在那里返回错误 - 愚蠢或至少是偏执。

我个人认为这种错误检查“robust”，因为我希望我的代码告诉我，如果发生了任何不幸的事情，请告诉我;我绝对不希望它只是假设一切都很好，我希望它是偏执的。（我并不是说OP的代码不会检查错误代码;我只是说这个版本更加小心并且直言不讳。）

Unix：将文件从当前复制到C中的另一个目录

1 个答案: