Losowanie i mieszanie w tablicach - prawdopodobnie program blokuje się w nieskończonej pętli

Mam złe wrażenie że moja funkcja lockp blokuje się w nieskończonej pętli. Co jest tego powodem? Uświadomicie mnie? Dzięki za najmniejszą tego próbę. Pisałem sam.

Code::Blocks. C++. Z braku kompilatora budowałem .exe'a w DevC++.

returned lockpick(unsigned uIleCyfr) {
    cout << "funkcja\n--------------\n\n";

    bool bShowed = false;
    if (bEquipSpr) {
        cout << strImie << " uzywa sprayu aby bez cienia watpliwosci wymienic uzyte\nniedawno kombinacje cyfr.\n\n";
        bShowed = true;
    }

    unsigned tUzyteCyfry[uIleCyfr], tKombinacjaCyfr[uIleCyfr], tKombinacjaCyfrMixed[uIleCyfr];

    // LOSOWANIE POPRAWNEJ KOMBINACJI
    for (int a = 0; a < uIleCyfr - 1; ) {
            // Wylosowanie liczby z przedziaÂłu 1-49
            tKombinacjaCyfr[a] = rand() % 9 + 1;

            // Sprawdzenie, czy jest unikalna wobec reszty
            bool bPowtarzaSie = false;
            for (int c = 0; c < a; ++c)
            {
                if (tKombinacjaCyfr[c] == tKombinacjaCyfr[a])
                {
                           bPowtarzaSie = true;
                           break;
                }
            }

            // JeÂżeli liczba jest jednak unikalna, losujemy kolejnÂą
            if (!bPowtarzaSie) ++a;
    }

    // MIESZANIE KOMBINACJI DO WYĹšWIETLENIA
    unsigned tUzyteRandomy[uIleCyfr];
    for (int u = 0; u < uIleCyfr - 1; u++) {
        tUzyteRandomy[u] = 11;
    }
    for (int b = 0; b < uIleCyfr - 1; b++) {
        tUzyteRandomy[uIleCyfr] = random(uIleCyfr, 0);

        for (int x = 0; x < uIleCyfr - 1; ++x) {
                if (tUzyteRandomy[b] == tUzyteRandomy[x] && x != b)
                {
                           tUzyteRandomy[uIleCyfr] = random(uIleCyfr, 0);
                           --x; // cofnij siÄ™ i sprawdĹş znowu
                }
        }

        tKombinacjaCyfrMixed[b] = tKombinacjaCyfr[tUzyteRandomy[uIleCyfr]];

        // pamiętaj żeby to usunąć po teście outputu
        cout << "TESTOWANIE: prawidlowe " << tKombinacjaCyfr[0] << tKombinacjaCyfr[1] << tKombinacjaCyfr[2] << tKombinacjaCyfr[3] << "\n";
        cout << "pomieszane " << tKombinacjaCyfrMixed[0] << tKombinacjaCyfrMixed[1] << tKombinacjaCyfrMixed[2] << tKombinacjaCyfrMixed[3] << "\n\n";
    }

    for (int i = 0; i < uIleCyfr - 1; i++) {
        nLogic = random(9, 0); // cyfra
        nLogic2 = random(uOpen, 10);
        nLogic3 = random(100, 23);

        if (nLogic2 < nLogic3) {
            nLogic4 = random(2, 0);

            cout << "Brak pewnosci - ";
            if (nLogic4 == 1) cout << tKombinacjaCyfrMixed[i] << " czy " << nLogic3 % 1;
            else if (nLogic4 == 2) cout << nLogic3 % 10 << " czy " << tKombinacjaCyfrMixed[i];
            cout << "?\n--> ";
            cin >> tUzyteCyfry[i];
            cout << "\n";
        }
        if (nLogic2 >= nLogic3) {
            cout << tKombinacjaCyfrMixed[i] << "\n\n";
            wait(3);
        }
    }
    
    return success;
}

A z jaką wartością uIleCyfr to odpalasz?

To zależy od linii wywołania, bo to przecież parametr. W testowym odpaleniu biorę trzy, bo mam testową tablicę z 3 elementami.

Chodzi mi o to że na samym początku powinieneś dodać warunek:
if(uIleCyfr>9) { cerr<<"Chcesz zawiesin co!?"<<endl; exit(1); }

To moim zdaniem tylko idotoodporne zabezpieczenie. Ja wywoływałem 3. Powinno działać.

A co robi: random(uIleCyfr, 0) ?

Z nim nie było wcześniej żadnych problemów w innych funkcjach. Zwraca, zgodnie z nazwą, liczbę losową. Parametry to Liczba Maksymalna i Liczba którą odejmuje od wyniku (np. w przypadku "pomyłki o jedynkę").

Czy uważasz że jeżeli mam kod:
while(fun()) {}
a funkcja fun() nie sprawiała problemu w innych miejscach programu to oznacza że powyższy kod nigdy się nie zapętli?

Jeśli użyta zgodnie z "instrukcją", to tak:

int random(int skala, int odejmij)
{
    int nLosowana;
    do {
            nLosowana = (rand() % skala + 1) - odejmij;
    } while (nLosowana <= 0);

    return nLosowana;
}

Ja poprawiłem nieco pomyłek w kodzie. m.in zamieniłem random(uIleLiczb, 0) na random(9, 0) bo stare było źle. Bez rezultatu.

Problem jest w tej pętli:

        for (int x = 0; x < uIleCyfr - 1; ++x) {
                if (tUzyteRandomy[b] == tUzyteRandomy[x] && x != b)
                {
                           tUzyteRandomy[uIleCyfr] = random(uIleCyfr, 0);
                           --x; // cofnij siÄ™ i sprawdĹş znowu
                }
        }

Jeżeli się raz wejdzie w ten warunek to już nigdy pętla się nie skończy, nie mówiąc już o mazaniu po pamięci: tUzyteRandomy nie ma indeksu uIleCyfr.

Co więc proponujesz? Nie chcę usuwać tego warunku gdyż sprawdza on, czy wybrany element poprawnej kombinacji nie został już nadpisany do tablicy pomieszanej kolejności.

Być może przyczyna tkwi w --x. I to na pewno. Jednak póki co nie widzę możliwości, aby przekazać komputerowi swój zamiar w jego języku.