Numbered unique files - c++

Question

I would like to create unique files, appending a number to their name if neccessary (similar to how browsers usually name downloaded files).
Here is what I am trying to do, but with directories (using the <filesystem> library) :
#include <filesystem>
namespace fs = std::filesystem;
template <typename... Args> std::string concatenate(Args&&... args) {
std::ostringstream sstr;
(sstr << ... << std::forward<Args>(args));
return sstr.str();
}
fs::path unique_dir(const fs::path &base, unsigned max_tries) {
if(fs::create_directories(base))
return base;
for(unsigned i = 1; i < max_tries; ++i) {
fs::path p = base;
p += concatenate('_', i);
if(fs::create_directory(p))
return p;
}
throw std::runtime_error("unique_dir: gave up");
}
int main() {
unique_dir("my_dir", 3); // creates my_dir
unique_dir("my_dir", 3); // creates my_dir_1
unique_dir("my_dir", 3); // creates my_dir_2
unique_dir("my_dir", 3); // throws
}
How can I do the same with files ?
Some precisions :
It does not need to be highly-performing (it is for a very cold part of the code)
Non-cross-platform is fine, as long as there is a variant for Linux, Windows and Mac
I do not want to use a mkstemp-type function that would require to put a non-user-friendly id in the filename
Thank you in advance.

Answer 1

With directories, you are checking if the creation of a directory worked. With files you can achieve this effect by checking if the particular path is pointing at an existing file, and if not, then creating it:
fs::path unique_file(const fs::path &base, unsigned max_tries) {
if(!fs::exists(base)) {
std::ofstream ofs(base);
return base;
}
for(unsigned i = 1; i < max_tries; ++i) {
fs::path p = base;
p += concat() << '_' << i;
if(!fs::exists(p)) {
std::ofstream ofs(p);
return p;
}
}
throw std::runtime_error("unique_file: gave up");
}

Answer 2

Here is a solution for POSIX systems, using open():
#include <fcntl.h> // open()
#include <unistd.h> // close()
fs::path unique_file(const fs::path &base, unsigned max_tries) {
fs::path p(base);
for(unsigned i = 1; i <= max_tries; ++i) {
// O_CREAT | O_EXCL will create the file if it does not exist, and fail otherwise
// 0666 : Read + Modify permissions for everybody
int fd = open(p.c_str(), O_CREAT | O_EXCL, 0666);
if(fd != -1) {
if(close(fd) == -1) // We immediately close the file, which might be a waste
throw fs::filesystem_error("unique_file: POSIX close() error", p, std::error_code(errno, std::generic_category()));
return p;
}
// EEXIST is set if open() failed because the file already existed
if(errno != EEXIST)
throw fs::filesystem_error("unique_file: POSIX open() error", p, std::error_code(errno, std::generic_category()));
errno = 0;
p = base.parent_path() / base.stem();
p += concatenate('_', i);
p += base.extension();
}
throw std::runtime_error("unique_file: gave up");
}
Windows seems to offer the _sopen_s function which offers the same _O_CREAT | _O_EXCL flag combination.