Random number generator generates the same number when called in a loop

I'm using the following strategy to generate random numbers in my project. The problem is that generating numbers in a loop gives me the same number over and over again.

#include <chrono>
#include <iostream>
#include <random>
class RandomNumberGenerator {
private:
    std::mt19937_64 generator_;

public:
    RandomNumberGenerator() {
        useClockSeed();
    }

    explicit RandomNumberGenerator(unsigned int seed) {
        generator_.seed(seed);
    }

    void setSeed(unsigned int seed) {
        generator_.seed(seed);
    }

    void useClockSeed() {
        generator_.seed(std::chrono::system_clock::now().time_since_epoch().count());
    }

    double uniform_real(double low, double high) {
        std::uniform_real_distribution<double> unif(low, high);
        return unif(generator_);
    }
};

class Options {
public:
    unsigned long long seed_ = std::chrono::high_resolution_clock::now().time_since_epoch().count();

    Options() = default;
    unsigned long long int getSeed() const {
        return seed_;
    }
    void setSeed(unsigned long long int seed) {
        seed_ = seed;
    }
    explicit Options(unsigned long long seed)
        : seed_(seed) {}
};

class AClassThatUsesRandomNumberGenerator {
    RandomNumberGenerator rng_;
    Options options_;

public:
    AClassThatUsesRandomNumberGenerator() = default;
    RandomNumberGenerator getRng() const {
        return rng_;
    }
    void setRng(const RandomNumberGenerator &rng) {
        rng_ = rng;
    }
    const Options &getOptions() const {
        return options_;
    }
    void setOptions(const Options &options) {
        options_ = options;
    }
    explicit AClassThatUsesRandomNumberGenerator(Options options)
        : options_(options){};
};

int main() {
    AClassThatUsesRandomNumberGenerator generator;

    std::cout << "Seed value is: " << generator.getOptions().getSeed() << std::endl;

    for (int i = 0; i < 10; i++) {
        std::cout << generator.getRng().uniform_real(0, 10) << std::endl;
    }
}

This produces:

Seed value is: 100761606907900
2.05241
2.05241
2.05241
2.05241
2.05241
2.05241
2.05241
2.05241
2.05241
2.05241

Could anybody spot the problem? Clearly, the expected output is a different number on each iteration of the loop.