# std::tmpfile

> C++ Atlas: `cppatlas.com/w/cpp/io/c/tmpfile` | Source: https://en.cppreference.com/w/cpp/io/c/tmpfile | Domain: Input/output | Standards: C++17

Creates and opens a temporary file with a unique auto-generated filename.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <cstdio>
std::FILE* tmpfile();
```

Creates and opens a temporary file with a unique auto-generated filename.

The file is opened as a binary file for update (as by `std::fopen` with access mode `"wb+"`). At least `TMP_MAX` files may be opened during the lifetime of a program (this limit may be shared with `std::tmpnam` and may be further limited by `FOPEN_MAX`).

If the program closes the file, e.g. by executing `std::fclose`, the file is automatically deleted.

If the program terminates normally (by calling `std::exit`, returning from `main`, etc), all files that were opened by calling `std::tmpfile` are also automatically deleted.

If the program terminates abnormally, it is implementation-defined if these temporary files are deleted.

### Parameters

(none)

### Return value

The associated file stream or a null pointer if an error has occurred.

### Notes

On some implementations (e.g. older Linux), this function actually creates, opens, and immediately deletes the file from the file system: as long as an open file descriptor to a deleted file is held by a program, the file exists, but since it was deleted, its name does not appear in any directory, so that no other process can open it. Once the file descriptor is closed, or once the program terminates (normally or abnormally), the space occupied by the file is reclaimed by the filesystem. Newer Linux (since 3.11 or later, depending on filesystem) creates such invisible temporary files in one step, via special flag in the `open()` syscall.

On some implementations (e.g. Windows), elevated privileges are required as the function may create the temporary file in a system directory.

### Example

```cpp
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <iostream>
namespace fs = std::filesystem;

int main()
{
    std::cout << "TMP_MAX = " << TMP_MAX << '\n'
              << "FOPEN_MAX = " << FOPEN_MAX << '\n';
    std::FILE* tmpf = std::tmpfile();
    std::fputs("Hello, world", tmpf);
    std::rewind(tmpf);
    char buf[6];
    std::fgets(buf, sizeof buf, tmpf);
    std::cout << buf << '\n';

    // Linux-specific method to display the tmpfile name
    std::cout << fs::read_symlink(
                     fs::path("/proc/self/fd") / std::to_string(fileno(tmpf))
                 ) << '\n';
}
```

Possible output:

```text
TMP_MAX = 238328
FOPEN_MAX = 16
Hello
"/tmp/tmpfBlY1lI (deleted)"
```

### See also

- [`tmpnam`](https://en.cppreference.com/w/cpp/io/c/tmpnam): returns a unique filename (function)
- [`temp_directory_path`](https://en.cppreference.com/w/cpp/filesystem/temp_directory_path) (C++17): returns a directory suitable for temporary files (function)
- [C documentation for `tmpfile`](https://en.cppreference.com/w/c/io/tmpfile)

---
Attribution: content from https://en.cppreference.com/w/cpp/io/c/tmpfile (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.