How to create a temporary text file in C++?

Here's a complete example:

#include <unistd.h> int main(void) { char filename[] = "/tmp/mytemp.XXXXXX"; // template for our file. int fd = mkstemp(filename); // Creates and opens a new temp file r/w. // Xs are replaced with a unique number. if (fd == -1) return 1; // Check we managed to open the file. write(fd, "abc", 4); // note 4 bytes total: abc terminating '\0' /* ... do whatever else you want. ... */ close(fd); unlink(filename); // Delete the temporary file. } 

If you know the name of the file you want to create (and are sure it won't already exist) then you can obviously just use open to open the file.

tmpnam and tmpfile should probably be avoided as they can suffer from race conditions - see man tmpfile(3) for the details.

On Linux (starting with kernel 3.11), there's flag to open(2) O_TMPFILE that creates a temporary file that doesn't have a name (i.e. it doesn't show up in the filesystem). This has a few interesting features:

• No worries about unique names, it's just an inode, there is no name.
• No race conditions during creation (e.g. symlink attacks).
• No stray files if your app crashes, it's always automatically deleted.

This may be a little off-topic because the author wanted to create a tmp.txt and delete it after using it, but that is trivial - you can simple open() it and delete it (using boost::filesystem of course).

mkstemp() is UNIX-based. With Windows you use GetTempFileName() and GetTempPath() to generate a path to a temp file. Sample code from MSDN:

http://msdn.microsoft.com/en-us/library/aa363875%28VS.85%29.aspx

I wonder why most of you guys showed him the C way of doing it instead of the C++ way.
Here's fstream.
Try that, deleting a file is OS depended but you can use boost.filesystem to make things easy for you.

A clean, portable and non-deprecated way of creating a temporary file is provided by Boost:

auto temporary_file = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path(); // ... boost::filesystem::remove(temporary_file); 

Alternatively using std::filesystem:

char temporary_file_path_buffer[L_tmpnam]; if (const errno_t return_value = tmpnam_s(temporary_file_path_buffer, L_tmpnam); return_value != 0) { throw std::runtime_error("Failed to generate temporary file name"); } std::filesystem::path temporary_file_path = temporary_file_path_buffer; // ... std::filesystem::remove(temporary_file_path); 

Note that tmpnam is deprecated and std::filesystem::unique_path was sadly removed.

If you need a named file (for example, so you can pass the name to another process, perhaps a compiler or editor), then register a cleanup function that removes the file with atexit(). You can use either C++ <iostream> or C FILE * (<cstdio>) to create the file. The not completely standard but widely available mkstemp() function creates a file and tells you its name as well as returning a file descriptor (a third I/O mechanism); you could use the fdopen() function to convert the file descriptor into a FILE *.

If you don't need a named file a C-style FILE * is OK, then look at tmpfile() as suggested by @Tom.

If you want to remove the file as soon as your application closes, use std::tmpfile(). It is safe, you can open a few thousand file per process (see TMP_MAX value) and platform independent.

It will create an empty file, and delete it as soon as it is closed.

#include <cstdio> int main() { std::FILE* temp_file = std::tmpfile(); // create file if(temp_file == nullptr) { // error, temp file cannot be created return -1; } std::fprintf(temp_file, "Some temporary text"); // use the file (write and read content) std::fclose(temp_file); // file removed from disk return 0; } 

Note if your program exits abnormally, it is implementation defined whether the file gets deleted or not.
To get the path of the file, we could use the following (linux implementation is from cppreference, for more details on windows implementation see the last paragraph of my other answer):

#ifdef WIN32 #include <windows.h> #include <io.h> std::string get_path_from_FILE(FILE* file) { int fd = _fileno(file); if (fd == -1) return ""; HANDLE h = (HANDLE)_get_osfhandle(fd); if (h == INVALID_HANDLE_VALUE) return ""; char path[MAX_PATH]; DWORD ret = GetFinalPathNameByHandleA(h, path, MAX_PATH, FILE_NAME_NORMALIZED); if (ret == 0 || ret >= MAX_PATH) return ""; return std::string(path+4); // it starts with "\\?\C:\...." this is why we need +4 } #elif defined __unix__ std::string get_path_from_FILE(FILE* file) { // Linux-specific method to display the tmpfile name char fname[FILENAME_MAX], link[FILENAME_MAX] = {0}; sprintf(fname, "/proc/self/fd/%d", fileno(tmpf)); if (readlink(fname, link, sizeof link - 1) > 0) { return fname; } return ""; } #endif 

If you stick with linux and C style creation, use open() with O_TMPFILE flag. In this case, the file won't be written to disk, unless a name is given to it.

#include <fcntl.h> #include <unistd.h> int main() { int temp_file = open("/tmp/", O_TMPFILE|O_RDWR, 0); if(temp_file == -1) { return -1; // error, temp file cannot be created } const char* my_temporary_content = "It is temporary"; write(temp_file, my_temporary_content, 15); // 15 is length of the const char above close(temp_file); return 0; } 

Here, the open's first parameter is a directory. Since c++17, we can use temp_directory_path() to determine the temporary directory path.

What is the danger of tmpnam()?
It gives a name that was unique in the time of calling the function, not when creating the file. Therefore, someone (e.g. an attacker, or another process) can create the file after the tmpnam() call, but before the open() call.
This is why one should use the O_EXCL flag to make sure the file is created by us (and handle error properly).

In this case, the file won't be removed after the process finished

#include <stdio.h> #include <fcntl.h> #include <unistd.h> int main() { int temp_file = -1; while(temp_file == -1){ const char* temp_name = tmpnam(nullptr); // this is the dangerous part temp_file = open(temp_name, O_CREAT|O_EXCL|O_RDWR, S_IRUSR | S_IWUSR); // it is left to the reader to prevent infinite loop } const char* my_temporary_content = "It is temporary"; write(temp_file, my_temporary_content, 15); // 15 is length of the const char above close(temp_file); return 0; } 

Well, assuming you have been successful in creating the temporary file, you can use the remove function to delete it.

The function is declared in stdio.h -

#include <stdio.h> int remove(const char *pathname); 

For example, if you want to delete a file named myfile.txt the code will be

#include<stdio.h> int main() { if(remove("myfile.txt") == -1) { fprintf(stderr,"Remove failed"); exit(EXIT_FAILURE); } exit(EXIT_SUCCESS); } 

I hope by now, you already know how to create the temp file, so this should resolve your query. Hope it helps.