C/C++ - Problema su "Errore di Segmentazione"

Dunque il codice che posto è ridotto al minimo (è all'interno di una parte più corposa, ma son riuscito a ridurlo a questa sezione, che è quella critica). Mi dà errore di segmentazione non riesco a capirne il motivo. Quello che credo faccia questo codice è: inizializzo un array di oggetti tipo ADJ_node, e inizializzo ciascun campo "valore" al valore "i" , dopodichè vado a stampare questo valore.
Mi dà errore di segmentazione.

#include <iostream>
using namespace std;

int main(int argc, char *argv[]) {

struct ADJ_node{       
int peso;
int valore;
ADJ_node* next;
};

int nodi=10;
ADJ_node** ADJ=new ADJ_node* [nodi];
for(int i=0;i<nodi;i++)
    ADJ[i]->valore=i;
    
    
for(int i=0;i<nodi;i++){
        cout<<ADJ[i]->valore;
}

return 0;
     
}

nel primo ciclo, prova a fare cosi

for(int i=0;i<nodi;i++)
{
    ADJ[i] = new ADJ_node();
    ADJ[i]->valore=i;
}

Mmh il problema, in generale, è questo: ho un progetto in cui devo generare un grafo con random nodi, aventi random adiacenze, controllarne il grafo connesso e il cammino minimo.
Quindi non posso creare i nodi al momento della loro stampa, perchè la loro generazione avviene nel modulo "Genera_grafo.cc" (in maniera indipendente dalla stampa come ho detto).

EDIT:: grazie per la risposta, ho capito, sono un babbo, mi son scordato di fare il new per creare singolarmente i nodi... grazie mille

EDIT2:: dunque il problema è cambiato: se metto tutto il codice di "genera_grafo_casuale()" nel corpo del "main()" funziona bene, se invece provo a chiamare quel codice tramite chiamata di funzione dal "main()" mi dà Errore di segmentazione.

Allego versione codice NON funzionante

#include <iostream>
#include <stdlib.h>
using namespace std;

//definizione lista per nodi adiacenti a un generico nodo V
struct ADJ_node{       
int peso;
int valore;
ADJ_node* next;
};

const int min_adiacenze=1, max_adiacenze=4, min_nodi=15, max_nodi=25;        //vincoli sulla 
int nodi;                                                                    //densità del grafo


//definizione array, ogni cella composta dalla testa di una lista
ADJ_node** ADJ; 

//sentinella unica per tutte le liste di adiacenza
ADJ_node* sentinella;


int random(const int min, const int max){

srand(time(0));

int n;
n=min+rand()% (max - min);

return n;

}

void aggiungi_adiacenza(ADJ_node** ADJ, int u, int v, int peso){

ADJ_node* p=new ADJ_node;
p->next=ADJ[u]->next;
ADJ[u]->next=p;
p->valore=v;
p->peso=peso;

}

int length_list(ADJ_node** ADJ, int n){     //conto i nodi di una lista, serve per non superare max_autoadiacenze

int count=0;
for(ADJ_node* p=ADJ[n]->next;p!=0;p=p->next)
    count++;

return count;

}


void genera_grafo_casuale(int &nodi, const int min_nodi, const int max_nodi, ADJ_node** ADJ, ADJ_node* sentinella, const int min_adiacenze, const int max_adiacenze){ //ADJ e sentinella costanti?

int adiacenze;
nodi=random(min_nodi, max_nodi); 
ADJ=new ADJ_node* [nodi];

sentinella=new ADJ_node;  //sentinella unica per tutte le liste di adiacenza
sentinella->valore=0;
sentinella->peso=0;
sentinella->next=0;


for(int i=0;i<nodi;i++){
    ADJ[i]=new ADJ_node;
    ADJ[i]->valore=i;
    ADJ[i]->peso=0;
    ADJ[i]->next=sentinella;
    }
    


for(int i=0;i<nodi;i++){   
   adiacenze=random(min_adiacenze+1, max_adiacenze);  //stabilisco, per ciascun nodo, il suo numero indicativo di adiacenze, il +1 è riferito alla sentinella che è già stata inserita, ma non deve essere influente nel num adiacenze
   for(int j=0;((j<adiacenze)&&((length_list(ADJ, i))<max_adiacenze));j++){    //inserimento adiacenza(j) nella lista di ADJ[i] e viceversa
       int n=rand()% nodi, peso=rand()% 30+1;
       if((n!=i)&&((length_list(ADJ, n))<max_adiacenze)){       //no autoadiacenza e adiacenze di troppo
          aggiungi_adiacenza(ADJ, i, n, peso);
          aggiungi_adiacenza(ADJ, n, i, peso);
       }
       else
          j--; //se il nodo trovato random ha gia adiacenze=max_adiacenze, mantengo invariate il num di adiacenze per il nodo i
   }

}


}


int main(int argc, char *argv[]) {

genera_grafo_casuale(nodi,min_nodi,max_nodi,ADJ,sentinella,min_adiacenze,max_adiacenze);

for(int i=0;i<nodi;i++){
    for(ADJ_node* p=ADJ[i];p!=0;p=p->next)
        cout<<p->valore<<" ";
    cout<<endl;
}


return 0;
     
}

Sei un babbo nel senso che hai dei figli ?

(Era una battuta ... benvenuto)

hehe nono è ancora presto, per adesso siamo agli studi in facoltà^^
Comunque ho fatto l'EDIT2, il problema continua (sempre segmentation fault, ma credo sia più sottile il problema rispetto a prima)

Nel tuo ultimo codice, "nodi" non e' inizializzato (o forse lo e', implicitamente a zero).

Si ma il valore casuale di "nodi" viene rimpiazzato subito, prima dell'accesso ai nodi in questione: come si entra nella funzione si ha

nodi=random(min_nodi, max_nodi);
ADJ=new ADJ_node* [nodi];

quindi ancora non ho un accesso fuori dagli indirizzi

Io non capisco che senso ha definire variabili globali come nodi, ADJ, min_adiacenze, etc. e poi passarle come parametro ad una funzione; se sono globali sono globali!

Questa confusione e' anche la causa del problema.

    int main(int argc, char *argv[]) {
     
    genera_grafo_casuale(nodi,min_nodi,max_nodi,ADJ,sentinella,min_adiacenze,max_adiacenze);
     
    
    for(int i=0;i<nodi;i++){
        for(ADJ_node* p=ADJ[i];p!=0;p=p->next)
            cout<<p->valore<<" ";
        cout<<endl;
    }
     
     
    return 0;
         
    }

ADJ all'interno del ciclo for fa riferimento all'istanza globale di ADJ, che ha valore zero (che non puoi dereferenziare). ADJ lo stai passando by-value, non by-reference a genera_grafo_casuale.