[C++] Creare array dinamico

[Super Squirrel]

Premetto che conosco giusto le basi del C++. In ogni caso mi servirebbe un modo per creare nuovi array di dimensioni note durante l'esecuzione del programma e utilizzare tali array in funzioni.

Dovrei inoltre aver modo di accedere in ogni momento ad uno dei suddetti array, magari se è possibile dando loro nomi in successione del tipo v_1, v_2, v_3 ... per poi utilizzarlo in una funzione ( per esempio riempi_array(int v_2[10]) ).

Se possibile potreste spiegarmi come utilizzare queste librerie/funzionalità con qualche riga di codice?

[vict85]

Il C++ dispone di una ampia Standard Template Library. Per i tuoi scopi la libreria vector (il sito inglese è più completo) è penso più che sufficiente.

[Super Squirrel]

Gli ho dato un'occhiata, ma non sono riuscito a trovare quello che mi serve.

Nel caso potresti postare qualche riga di codice in cui venga creato un nuovo array in esecuzione e il richiamo di tale array in una funzione?

[apatriarca]

Non mi sono chiari i tuoi obiettivi. Potresti cercare di spiegare meglio quello che stai cercando di fare e perché?

[Super Squirrel]

Ho fatto un programma in C++ che applicando varie strategie tenta di risolvere un sudoku e se alla fine non ci riesce lo risolve andando a tentativi.
Il problema è sorto proprio nell' implementare quest'ultima funzione in quanto essa deve creare schemi successivi finchè non si arriva ad uno schema impossibile e quindi tornare a quello precedente provando un altro candidato.

Alla fine ieri sono riuscito ad implementare questa funzione creando una super matrice di 729x9 che potesse contenere tutti gli schemi successivi ( 729 = 81 x 9). Per farlo ho dovuto anche creare funzioni che facessero le stesse cose di funzioni già esistenti, ma che avessero come argomento una matrice 729x9 anzichè 9x9.
Quindi per ora il programma funziona, ma se potessi creare quando necessario nuove matrici 9x9 invece di utilizzare quella 729x9 potrei eliminare funzioni ridondanti e avere, credo, un minor consumo di memoria.

[apatriarca]

Conosci l'allocazione dinamica della memoria?

[Super Squirrel]

No, potrebbe fare al mio caso?

[Super Squirrel]

Ho letto qualcosina sulle funzioni new/delete e i puntatori.

Andando un po' ad intuito ho provato a fare un programmino su array dinamici monodimensionali che racchiudesse le cose di cui ho bisogno nel mio programma sul sudoku, ossia generare un massimo di n nuovi array (per farlo ho creato un array di puntatori di dimensione n... si può fare?) di dimensioni note, richiamarli in funzioni ed eliminarli.
Probabilmente ci saranno errori concettuali, ma sembra funzionare. Ecco il codice.

Codice:

#include <iostream>

void riempi_array(int v[5])
{
    for(int i = 0; i < 5; i++)
    {
        std::cin >> v[i];
    }
}

void mostra_array(int v[5])
{
    for(int i = 0; i < 5; i++)
    {
        std::cout << v[i] << " ";
    }
}

int main()
{
    int n, *p[3];
    for(int i = 0; i < 3; i++)
    {
        p[i] = new int [5];
    }
    riempi_array(p[1]);
    mostra_array(p[1]);
    std::cout << "n: ";
    std::cin >> n;
    std::cout << p[1][n];
    for(int i = 0; i < 3; i++)
    {
        delete [] p[i];
    }
}


riempiendo il secondo array dinamico per esempio con 4 7 13 54 32 e digitando n = 3 mi mostra 54, quindi anche se ci sono errori il programma fa quello che mi serve.
Il problema è che nel programma sul sudoku utilizzo array tridimensionali e provando a riscrivere il codice con la stessa logica usata nel programmino che ho postato sopra non mi compila.
ho provato quindi a restringere il campo modificando il precedente programma in array bidimensionali e lo stesso non compila.

Codice:

#include <iostream>

void riempi_array(int v[5][5])
{
    for(int i = 0; i < 5; i++)
    {
        for(int j = 0; j < 5; j++)
        {
            std::cin >> v[i][j];
        }
    }
}

void mostra_array(int v[5][5])
{
    for(int i = 0; i < 5; i++)
    {
        for(int j = 0; j < 5; j++)
        {
            std::cout << v[i][j] << " ";
        }
    }
}

int main()
{
    int n, *p[3];
    for(int i = 0; i < 3; i++)
    {
        p[i] = new int [5][5];
    }
    riempi_array(p[1][1]);
    mostra_array(p[1][1]);
    std::cout << "n: ";
    std::cin >> n;
    std::cout << p[1][n][n];
    for(int i = 0; i < 3; i++)
    {
        delete [] p[i];
    }
}

Presumo quindi che per fare quello di cui ho bisogno con array a più dimensioni bisogna ragionare e/o scrivere diversamente, tipo utilizzare un puntatore per ogni array monodimensionale... Sto cercando in rete, ma non ho trovato ancora nulla. Quindi oltre a chiedervi se è corretto l'utilizzo dell'allocazione dinamica fatto nel programmino sugli array monodimensionali ne approfitto anche per chiedere delucidazioni per il caso di array pluridimensionali.

[apatriarca]

Gli array n-dimensionali in C o C++ sono una specie di farsa. Praticamente inutili per come sono implementati. Finché si parla di dimensioni fisse (definite in tempo di compilazione), ma tutto bene, ma è molto difficile fare qualsiasi altra cosa.

La soluzione normalmente adottata è quella di usare una classe che contenga un array monodimensionale di dimensione opportuna e una funzione per accedere ai singoli elementi usando indici di dimensione opportuna. Esistono librerie che implementano già tali classi..

In alternativa si può fare qualcosa se si conoscono tutte le dimensioni tranne una. In tal caso è possibile creare un array dinamico in cui gli elementi sono array di dimensione fissa. Qualcosa tipo il seguente codice:

Codice:

#include <cstdlib>
#include <ctime>
#include <iostream>

typedef int vector[9];

int main(void)
{
    std::srand(std::time(nullptr));

    vector *v = new vector[10];
    for (int i = 0; i < 10; ++i) {
        for (int j = 0; j < 9; ++j) {
            v[i][j] = rand() % 10;
        }
    }

    for (int i = 0; i < 10; ++i) {
        for (int j = 0; j < 9; ++j) {
            std::cout << v[i][j] << " ";
        }
        std::cout << std::endl;
    }

    delete[] v;
}


[vict85]

Considerando il tuo scopo (il sudoku) puoi anche creare un std::vector o ancora meglio un std::stack di array statici. Comunque non hai bisogno di salvare tutti quei dati per ogni mossa, solo quelli necessari per annullare la mossa.

Detto questo imparare a gestire la memoria dinamica è una abilità utile da conoscere.