Сокращение случайного равномерного распределения int на каждом проходе

Question

Работа над классом с размером блока 256 элементов. И каждый раз, когда моя функция добавления вызывается до того, как я что-то храню; Я хочу создать равномерный случайный int в диапазоне [0,255]. То, что я хотел бы сделать, это до того, как эта функция завершится, чтобы отслеживать предыдущие значения, используемые для того, чтобы в следующий раз через функцию равномерное распределение случайных чисел автоматически пропустило эти значения, вместо того, чтобы проверять, ,

template<class T> 
class SomeClass { 
    struct Node { 
     unsigned idx; 
     std::shared_ptr<T> pT; 

     Node() : idx(-1), pT(nullptr) {} 
     Node(unsigned idx_, std::shared_ptr<T>& pT_) : idx(idx_), pT(pT_) {} 
    }; // Node 

private: 
    Node m_storage[256]; 
    static unsigned m_elementCount; 
    std::set<unsigned> m_indexesUsed; 
public: 
    SomeClass(){} 
    ~SomeClass(){} 

    void add(T& obj); 
}; // SomeClass 

template<class T> 
unsigned SomeClass<T>::m_elementCount = 0;  

template<class T> 
void SomeClass<T>::add(T& obj) { 

    if (m_elementCount == 256) { 
     return; // My Code Base Is Bigger - If This Is Full This Array gets pushed into a vector, 
     // and all values get reset to default and we start over. 
    } 
    Node n; 

    // Generate Uniform Random In Distribution In The Range of [0,255] 
    // Excluding the Values from m_listIndexesUsed. 
    n.idx = std::uniform_random_int_distribution from [0,255] excluding previous selected numbers 
    n.pT = std::make_shared<T>(obj); 
    m_storage[n.idx] = n; 
    m_indexesUsed.insert(n.idx); 
    m_elementCount++; 
} 

Может определение значения между указанным диапазоном моего случаем [0255] генерируются, где на каждый последующего вызова определяет другое случайное значение, которое не было уже выбрано ранее с равномерным случайным распределением Int? Если да, то как это будет сделано?

EDIT

После рассмотрения некоторых комментариях ниже, они вырастили хороший момент. То, что действительно необходимо в моем случае, - это набор из 256 уникальных ключевых значений в диапазоне от 0 до 255, и их необходимо случайным образом перетасовать или скремблировать. Я дам ему подумать о том, как попытаться это сделать, но если кто-то захочет получить хороший пример того, что приемлемо. Я не против сдачи в работу, но иногда, когда я добираюсь до такой степени, что я не могу пройти мимо, и я начинаю тратить на нее слишком много времени, я просто хочу пройти мимо этого момента, чтобы я мог двигаться на.

Answer 1

У нас есть стандартный алгоритм для чередования последовательностей; это называется, ну, shuffle. Итак, сделайте последовательность 0 ... 255, перетасуйте ее, затем возьмите из результирующего списка, пока не исчерпаете его, и не повторите. Заверните все это в шаблон класса, если вы хотите:

template<size_t N> 
struct index_generator { 

    // seeding method for illustration purposes only 
    // see http://www.pcg-random.org/posts/cpp-seeding-surprises.html 
    index_generator() : rng(std::random_device()()) { 
     std::iota(indices.begin(), indices.end(), size_t{}); 
     reset(); 
    } 

    explicit operator bool() const { return current < N; } 

    // use [] if you don't need the bounds checking 
    size_t operator()() { return indices.at(current++); } 

    void reset() { 
     std::shuffle(indices.begin(), indices.end(), rng); 
     current = 0; 
    } 
private: 
    std::array<size_t, N> indices; 
    size_t current; 
    std::mt19937 rng; 
}; 

Использование вдоль линий

index_generator<256> gen; // static(?) data member 

// ... 
if (!gen) { 
    // we've exhausted the 256 indices 
    // do whatever you need to do 
    gen.reset(); 
    return; 
} 

Node n; 
n.idx = gen(); 
// other stuff