readdir(): re-reading certain files

Question

I got a function which task is to rename all files in a folder however, it re-rename certain files: http://i.imgur.com/JjN8Qb2.png, the same kind of "error" keeps occurring for every tenth number onwards. What exactly is causing this "error"?

The two arguments to the function is the path for the folder and what start value the first file should have.

int lookup(std::string path, int *start){
        int number_of_chars;
        std::string old_s, file_format, new_s;
        std::stringstream out;
        DIR *dir;
        struct dirent *ent;

        dir = opendir (path.c_str());
        if (dir != NULL) {
            // Read pass "." and ".."
            ent = readdir(dir);
            ent = readdir(dir);
            // Change name of all the files in the folder
            while((ent = readdir (dir)) != NULL){
                // Old string value
                old_s = path;
                old_s.append(ent->d_name);
                // Get the format of the image
                file_format = ent->d_name;
                number_of_chars = file_format.rfind(".");
                file_format.erase(0,number_of_chars);
                // New string value
                new_s = path;
                out << *start;
                new_s += out.str();
                new_s.append(file_format);
                std::cout << "Successfully changed name on " << ent->d_name << "\tto:\t" << *start << file_format << std::endl;
                // Switch name on the file from old string to new string
                rename(old_s.c_str(), new_s.c_str());

                out.str("");
                *start = *start+1;
            }
            closedir (dir);
        }
        // Couldn't open
        else{
            std::cerr << "\nCouldn't open folder, check admin privileges and/or provided file path\n" << std::endl;
            return 1;
        }

        return 0;
    }

Answer 1

You are renaming files to the same folder in which the original files were, resulting in an infinite loop. You renamed 04.png to 4.png but since you are iterating over all files in the folder, at some point you're going to iterate to the "new" 4.png file (in your smaple, on the 40th iteration) and rename that file to 40.png and so on...

The easiest way to resolve this with minimal changes to the existing code is to "rename" (move) the files to a temporary folder with their new names. Something like:

new_s = temp_path;
out << *start;
new_s += out.str();
new_s.append(file_format);
// Switch name on the file from old string to new string
rename(old_s.c_str(), new_s.c_str());

and when you are done renaming all the files in path (outside the while loop), delete the folder and "rename" (move) temp_path to `path:

closedir (dir);
deletedir(path);
rename(temp_path, path);

`

Answer 2

Possible problems I see:

• Renaming files causes them to be fed to your algorithm twice.
• Your algorithm for computing the new filename is wrong.

You should be able to write a test for this easily, which in turn should help you fix the problem or write a more specific question. Other than that, I don't see any grave issues, but it would help if you reduced the scope of variables a bit, which would make sure that different iterations don't influence each other.