# std::fsetpos

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

Sets the file position indicator and the multibyte parsing state (if any) for the C file stream stream according to the value pointed to by pos.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <cstdio>
int fsetpos( std::FILE* stream, const std::fpos_t* pos );
```

Sets the file position indicator and the multibyte parsing state (if any) for the C file stream `stream` according to the value pointed to by `pos`.

Besides establishing new parse state and position, a call to this function undoes the effects of `std::ungetc` and clears the end-of-file state, if it is set.

If a read or write error occurs, the error indicator (`std::ferror`) for the stream is set.

### Parameters

- `stream` - file stream to modify
- `pos` - pointer to a `fpos_t` object obtained from `std::fgetpos` called on a stream associated with the same file

### Return value

`​0​` upon success, nonzero value otherwise. Also, sets `errno` on failure.

### Notes

After seeking to a non-end position in a wide stream, the next call to any output function may render the remainder of the file undefined, e.g. by outputting a multibyte sequence of a different length.

### Example

```cpp
#include <cstdio>
#include <cstdlib>

int main()
{
    // Prepare an array of floating-point values.
    const int SIZE = 5;
    double A[SIZE] = {1., 2., 3., 4., 5.};
    // Write array to a file.
    std::FILE * fp = std::fopen("test.bin", "wb");
    std::fwrite(A, sizeof(double), SIZE, fp);
    std::fclose(fp);

    // Read the values into array B.
    double B[SIZE];
    fp = std::fopen("test.bin", "rb");
    std::fpos_t pos;
    if (std::fgetpos(fp, &pos) != 0)      // current position: start of file
    {
       std::perror("fgetpos()");
       std::fprintf(stderr, "fgetpos() failed in file %s at line # %d\n",
                    __FILE__, __LINE__-3);
       std::exit(EXIT_FAILURE);
    }

    int ret_code = std::fread(B, sizeof(double), 1, fp);      // read one value
    // current position: after reading one value
    std::printf("%.1f; read count = %d\n", B[0], ret_code);   // print one value and ret_code

    if (std::fsetpos(fp, &pos) != 0)   // reset current position to start of file
    {
       if (std::ferror(fp))
       {
          std::perror("fsetpos()");
          std::fprintf(stderr, "fsetpos() failed in file %s at line # %d\n",
                       __FILE__, __LINE__-5);
          std::exit(EXIT_FAILURE);
       }
    }

    ret_code = std::fread(B, sizeof(double), 1, fp);         // re-read first value
    std::printf("%.1f; read count = %d\n", B[0], ret_code);  // print one value and ret_code
    std::fclose(fp);

    return EXIT_SUCCESS;
}
```

Output:

```text
1.0; read count = 1
1.0; read count = 1
```

### See also

- [`fgetpos`](https://en.cppreference.com/w/cpp/io/c/fgetpos): gets the file position indicator (function)
- [`ftell`](https://en.cppreference.com/w/cpp/io/c/ftell): returns the current file position indicator (function)
- [`fseek`](https://en.cppreference.com/w/cpp/io/c/fseek): moves the file position indicator to a specific location in a file (function)
- [C documentation for `fsetpos`](https://en.cppreference.com/w/c/io/fsetpos)

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