C++ 如何在C++；？

我创建了一个矩阵。该矩阵具有随机字母[a-z]和[a-z]

函数的作用是创建随机字母。但我不想让这些信重复。我怎么做？我想整理信件

下面是代码：我能做什么

const int M = 5;
const int N = 10;



static const char harfler[] = // a-z arası büyük ve küçük harfleri tanımladığımız değişken.
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";

int harfBoyut = sizeof(harfler) - 1; 


char harfGetir() {

return harfler[rand() % harfBoyut];

}

int main()
{

int A[M][N];

srand(time(NULL)); // değerleri yeniden atamak için programı baştan aldı.

for (int i = 0; i < M; i++) // satır döngüsü
    for (int j = 0; j < N; j++) // sütun döngüsü
    {
        A[i][j] = harfGetir(); // matris değerleri atama


    }

cout << setw(5) << "Harf Matrisi" << endl;

cout << endl;
for (int i = 0; i < M; i++) // satırdaki harfler
{

    for (int j = 0; j < N; j++) // sütundakı harfler

        cout << setw(4) << harfGetir();  // harfleri çeken kod

    cout << endl;

}
cout << endl;





system("pause");
return 0;
}

const int M=5；
常数int N=10；
静态常数char harfler[]=//a-z arasıbüyük ve kükçk harfleri tanımladımız değişken。
“ABCDEFGHIJKLMNOPQRSTUVWXYZ”
“abcdefghijklmnopqrstuvwxyz”；
int harfBoyut=sizeof（harfler）-1；
char harfGetir（）{
返回harfler[rand（）%harfBoyut]；
}
int main（）
{
int A[M][N]；
srand（time（NULL））//değerleri yeniden atamak için programıbaştan aldı。
for（int i=0；icout您可以创建一个随机排列（使用
random
标题，而不是旧的
srand
），然后获取数组中的
n
项

然后你可以再把它们分类

例如，如果字符串
v
中包含所有可用字母：

std::random_device rd;
std::mt19937 g(rd());

std::shuffle(v.begin(), v.end(), g);

然后，如果您想要10个字母，您可以使用
v
的前10个条目，您可以使用from

首先,

#include <algorithm> // For shuffle
#include <random>    // For random-related things...

然后像这样使用它：

auto rng = std::default_random_engine{};
std::shuffle(harfler.begin(), harfler.end(), rng);

示例：

#include <iostream>
#include <algorithm>
#include <random>
#include <string>

static std::string harfler =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";

auto CONFINE(int const x, std::string const& container, std::default_random_engine rng)
{
    if (x > signed(container.size() - 1))
    {
        std::shuffle(harfler.begin(), harfler.end(), rng);
        return x - signed(container.size() - 1);
    }
    return x;
}

int main()
{
    constexpr auto MAT_X_SIZE = 8;
    constexpr auto MAT_Y_SIZE = 8;
    auto rng = std::default_random_engine{};
    std::shuffle(harfler.begin(), harfler.end(), rng);
    std::vector<std::vector<int>> matrix(MAT_Y_SIZE, std::vector<int>(MAT_X_SIZE, 0));
    for (auto i = 0; i < MAT_Y_SIZE; i++)
        for (auto j = 0; j < MAT_X_SIZE; j++)
            matrix[i][j] = *std::next(harfler.begin(), CONFINE(MAT_Y_SIZE * i + j, harfler));
    for (auto elem : matrix)
    {
        for (auto elem2 : elem)
            std::cout << char(elem2) << ' ';
        std::cout << std::endl;
    }
    std::cin.get();
    return 0;
}

#包括
#包括
#包括
#包括
静态std：：字符串harfler=
“ABCDEFGHIJKLMNOPQRSTUVWXYZ”
“abcdefghijklmnopqrstuvwxyz”；
自动限制（int const x，std:：string const&container，std:：default\u random\u engine rng）
{
如果（x>已签名（container.size（）-1））
{
std:：shuffle（harfler.begin（），harfler.end（），rng）；
返回x-签名（container.size（）-1）；
}
返回x；
}
int main（）
{
constexpr自动材料X尺寸=8；
constexpr自动材料尺寸=8；
auto rng=std:：default\u random\u引擎{}；
std:：shuffle（harfler.begin（），harfler.end（），rng）；
std：：向量矩阵（MAT_Y_大小，std：：向量（MAT_X_大小，0））；
用于（自动i=0；istd：：你能解释一下吗？我不太明白把字母放在向量中很容易。@MatthieuBrucher我不确定OP是否知道如何做…即使很容易…你甚至不需要把字母放在向量中，a
std：：string
就够了哦，是的，当然，任何容器都可以，我已经编辑了答案，谢谢。
#include <iostream>
#include <algorithm>
#include <random>
#include <string>

static std::string harfler =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";

auto CONFINE(int const x, std::string const& container, std::default_random_engine rng)
{
    if (x > signed(container.size() - 1))
    {
        std::shuffle(harfler.begin(), harfler.end(), rng);
        return x - signed(container.size() - 1);
    }
    return x;
}

int main()
{
    constexpr auto MAT_X_SIZE = 8;
    constexpr auto MAT_Y_SIZE = 8;
    auto rng = std::default_random_engine{};
    std::shuffle(harfler.begin(), harfler.end(), rng);
    std::vector<std::vector<int>> matrix(MAT_Y_SIZE, std::vector<int>(MAT_X_SIZE, 0));
    for (auto i = 0; i < MAT_Y_SIZE; i++)
        for (auto j = 0; j < MAT_X_SIZE; j++)
            matrix[i][j] = *std::next(harfler.begin(), CONFINE(MAT_Y_SIZE * i + j, harfler));
    for (auto elem : matrix)
    {
        for (auto elem2 : elem)
            std::cout << char(elem2) << ' ';
        std::cout << std::endl;
    }
    std::cin.get();
    return 0;
}