如何用C++实现类似bash中mv /testdir/* /testdest/的文件移动功能？

Ah, I see the issue here—your current use of rename() is doing exactly what it's designed to do when given two directory paths, but that's not the same as the shell's mv /testdir/* /testdest/ behavior. Let's break this down and fix it.

Why Your Current Code Isn't Working #

When you call rename(argv[1], argv[2]) with /testdir/ and /testdest/:

• If /testdest/ doesn't exist, rename() will rename the entire /testdir/ directory to /testdest/—that's why your original directory disappears entirely.
• If /testdest/ already exists, rename() will move /testdir/ into /testdest/, resulting in /testdest/testdir/—still not the "move all files inside /testdir/ to /testdest/" effect you want.

The shell's mv /testdir/* /testdest/ expands the wildcard to every file/subdirectory inside /testdir/ and moves each one individually to /testdest/. We need to replicate that logic in C++.

Working Implementation #

Here's a revised version of your code that mimics the shell command's behavior:

#include <iostream>
#include <unistd.h>
#include <dirent.h>
#include <cstring>
#include <sys/stat.h>
#include <sys/errno.h>

using namespace std;

// Helper function to create a directory if it doesn't exist
bool createDirectory(const string& path) {
    struct stat st;
    if (stat(path.c_str(), &st) != 0) {
        // Directory doesn't exist, create it
        if (mkdir(path.c_str(), 0755) != 0) {
            cerr << "Failed to create directory " << path << ": " << strerror(errno) << endl;
            return false;
        }
    } else if (!S_ISDIR(st.st_mode)) {
        cerr << path << " exists but is not a directory!" << endl;
        return false;
    }
    return true;
}

int main(int argc, char *argv[]) {
    // Check if we have the right number of arguments
    if (argc != 3) {
        cerr << "Usage: " << argv[0] << " <source_directory> <destination_directory>" << endl;
        return EXIT_FAILURE;
    }

    string srcDir = argv[1];
    string destDir = argv[2];

    // Ensure source directory ends with a slash (to avoid path joining bugs)
    if (srcDir.back() != '/') srcDir += '/';
    // Ensure destination directory ends with a slash
    if (destDir.back() != '/') destDir += '/';

    // Validate source directory
    struct stat srcStat;
    if (stat(srcDir.c_str(), &srcStat) != 0 || !S_ISDIR(srcStat.st_mode)) {
        cerr << "Source " << srcDir << " is not a valid directory!" << endl;
        return EXIT_FAILURE;
    }

    // Create destination directory if it doesn't exist
    if (!createDirectory(destDir)) {
        return EXIT_FAILURE;
    }

    // Open the source directory
    DIR* dir = opendir(srcDir.c_str());
    if (!dir) {
        cerr << "Failed to open source directory " << srcDir << ": " << strerror(errno) << endl;
        return EXIT_FAILURE;
    }

    dirent* entry;
    // Iterate over each entry in the source directory
    while ((entry = readdir(dir)) != nullptr) {
        string entryName = entry->d_name;
        // Skip the special "." and ".." directories
        if (entryName == "." || entryName == "..") {
            continue;
        }

        // Build full paths for source and destination
        string srcPath = srcDir + entryName;
        string destPath = destDir + entryName;

        // Move the entry to the destination
        if (rename(srcPath.c_str(), destPath.c_str()) != 0) {
            cerr << "Failed to move " << srcPath << " to " << destPath << ": " << strerror(errno) << endl;
            // Continue moving other files instead of exiting immediately
            continue;
        }

        cout << "Moved: " << srcPath << " -> " << destPath << endl;
    }

    // Clean up: close the directory
    closedir(dir);

    return EXIT_SUCCESS;
}

Key Details About This Implementation #

• Wildcard Expansion Replication: We manually iterate over every entry in the source directory, just like the shell does when it expands *.
• Path Handling: We ensure paths end with a slash to avoid bugs when joining paths (e.g., /testdirfile instead of /testdir/file).
• Error Handling: The code checks for invalid directories, failed directory creation, and failed moves, with clear error messages using strerror(errno).
• Default Behavior Match: Like the shell's mv, if a file with the same name exists in the destination, it will be overwritten. If you want to prevent this, add a check using stat() on destPath before calling rename().
• Flat Move: This code moves only the direct children of the source directory. If you need to move nested subdirectories recursively, you'd need to add a recursive function that handles directory entries by calling itself on subdirectories.

Compilation & Usage #

Compile with a C++ compiler:

g++ -o static-mv static-mv.cpp

Run it like this (matching your original command):

./static-mv /testdir/ /testdest/

内容的提问来源于stack exchange，提问作者MajQel