[C++]Delucidazioni New E Delete nell'Allocazione Dinamica

[Warioss]

Salve a tutti!
Vorrei chiedere se qualcuno è tanto gentile da spiegarmi bene l'uso delle funzioni new e delete nell'ambito dell'allocazione dinamica.

In particolare quello che non ho capito è la differenza tra delete e delete[].

Se ho ben capito bene delete serve a cancellare oggetti semplici tipo un'istanza di un intero o un vettore mentre delete[] si usa per cancellare dei vettori di puntatori (?)

Quindi se devo allocare dinamicamente un vettore e poi dopo averlo stampato a video disallocarlo dovrei fare :

int *vet;
int n; // riempimento=dim massima

//Richiesta del riempimento/dimensione massima che sarà allocata run time
cout<<"Quanti elementi si voglioni inserire nel vettore?\n";
cin>>n;

//Alloco dinamicamente il vettore 
vet = new int[n];

//Specificazione tramite tastiera degli elementi dell'array dinamico
for(int i=0;i<n;i++){
    cout<<"Inserire l'elemento "<<i+1<<endl;
    cin>>*(vet+i);
}

//Stampa Del Vettore 
for(int i=0;i<n;i++)
    cout<<*(vet+i)<<endl;

//Deallocazione del Vettore
delete vet;

Giusto?

Mentre se devo allocare dinamicamente una matrice e poi dopo averla stampata a video disallocarla dovrei fare :

int **matrix;
int righe;
int colonne;

//Richiesta all'utente di righe e colonne
cout<<"Specificare righe\n";
cin>>righe;
cout<<"Specificare Colonne\n";
cin>>colonne;

//Allocazione Dinamica Matrice
matrix = new int*[righe]; //cioe' creo un array di puntatori
for(int i=0;i<righe;i++)
    matrix[i]=new int[colonne]; //creo ora un array di interi 

//Specificazione tramite tastiera degli elementi della matrice dinamica
for(int i=0;i<righe;i++)
    for(int j=0;j<colonne;j++){
        cout<<"Inserire l'elemento della righa "<<i+1<<" e della colonna "<<j+1<<endl;
        cin>>matrix[i][j];
        }

//Stampa Della Matrice
for(int i=0;i<righe;i++){
    for(int j=0;j<colonne;j++){
        cout<<matrix[i][j]<<" ";
    }
    cout<<endl;
}

//Deallocazione Matrice
for(int i=0;i<righe;i++)
   delete[]matrix[i]; //Mi cancello l'array di interi

delete[]matrix; //Mi cancello l'array di puntatori.

Sarei lieto se qualcuno di voi potesse dirmi se quanto ho detto e giusto e chiarirmi meglio l'uso di new e delete ,grazie in anticipo

[Warioss]

Curiosità dell'ultima ora :

Ma l'allocazione dinamica è possibile solo nel main e non nei sottoprogrammi?

Perché se io faccio:

MAIN:

#include <iostream>
#include "swapAndarray.h"
using namespace std;
int main(int argc, char** argv) {
    int vettore,r;
    LeggiArray(&vettore,&r);
    StampaArray(&vettore,&r);
    return 0;
}

HEADER

void LeggiArray(int*,int*);
void StampaArray(int*,int*);

BODY

#include <iostream>
#include "swapAndarray.h"
using namespace std;


void LeggiArray(int* vettore ,int* r){
    cout<<"Quanti elementi si vuole inserire nel vettore?\n";
    cin>>*r;
    vettore[*r];
    for(int i=0;i<*r;i++){
        cout<<"inserire l'elemento in posizione "<<i<<endl;
        cin>>*(vettore+i);
    }
}


void StampaArray(int* vettore,int* r){
        for(int i=0;i<*r;i++)
            cout<<*(vettore+i)<<endl;
}

Funziona benissimo e sto usando solo dei puntatori (come si fa in C , senza usare il passaggio per riferimento tipico del C + + )

Ma se faccio :
MAIN:

#include <iostream>
#include "swapAndarray.h"
using namespace std;
int main(int argc, char** argv) {
    int vettore,r;
    LeggiArray(&vettore,&r);
    StampaArray(&vettore,&r);
    return 0;
}

HEADER

void LeggiArray(int*,int*);
void StampaArray(int*,int*);

BODY

#include <iostream>
#include "swapAndarray.h"
using namespace std;

void LeggiArray(int* vettore ,int* r){
    cout<<"Quanti elementi si vuole inserire nel vettore?\n";
    cin>>*r;
    vettore=new int[*r];
    for(int i=0;i<*r;i++){
    cout<<"inserire l'elemento in posizione "<<i<<endl;
    cin>>*(vettore+i);
    }
}


void StampaArray(int* vettore,int* r){
        for(int i=0;i<*r;i++)
            cout<<*(vettore+i)<<endl;
}

Allora non funziona più poiché stampa 3 elementi a caso nel vettore anziché quelli specificati da tastiera ...

Quindi DEDUCO (poi non so se ho sbagliato io ad usare la new nel sottoprogramma) che non si può usare l'allocazione dinamica nei sottoprogrammi perché l'allocazione dinamica interessa la memoria Heap mentre i sottoprogrammi interessano lo Stack Point Register
Giusto?

Scusatemi se vi chiedo molte cose, ma ne ho bisogno

P.S.: Ho creato un nuovo messaggio perché non mi permetteva più di modificare il precedente

[shodan]

Per il primo post.
No, delete serve per cancellare singoli puntatori allocati con new mentre delete[] si usa per deallocare puntatori allocati con new[]
Es.

   int* alfa = new int; // alloco un singolo elemento con new
   delete alfa; // cancello l'elemento con delete

   int* beta = new int[16]; // alloco un array con new[]
   delete[] beta; // cancello l'array con delete[]

Fare una semplice delete su qualcosa allocato con new[] ha comportamento indefinito.
Non centrano nulla le matrici.

Per il secondo post.

Funziona benissimo...

...finché inserisci un elemento. Se provi a inserirne più di uno, prima o poi avrai un crash.
int vettore; è UN int e basta, NON è un array di int. Usarlo come hai fatto nel primo esempio è un grave errore.

Puoi allocare dove e quando ti pare, non ci sono limitazioni (memoria d sistema a parte), ma se vuoi che il secondo esempio funzioni devi passare il puntatore al puntatore in modo da poter modificare ciò che è all'esterno.
(Come avviene con le liste.)

void LeggiArray(int** vettore ,int r){
    cout<<"Quanti elementi si vuole inserire nel vettore?\n";
    cin>>r;
    (*vettore)=new int[r];
    for(int i=0;i<r;i++){
    cout<<"inserire l'elemento in posizione "<<i<<endl;
    cin>>*((*vettore)+i);
    }
}
void StampaArray(int* vettore,int r){
        for(int i=0;i<r;i++)
            cout<<*(vettore+i)<<endl;
}

int main(int argc, char** argv) {
    int *vettore,r;
    LeggiArray(&vettore,r);
    StampaArray(vettore,r);
    delete[] vettore; // non dimenticare questa.
    return 0;
}

Se ti sembra strano, rifletti sul fatto che se scrivi:

int alfa = 10;
int* beta = &alfa;
*beta = 20;

e ti ritrovi con alfa che vale 20, allo stesso modo se scrivi;

int* alfa = nullptr;
int** beta = &alfa;
(*beta) = new int(30); // Attenzione! Non [30]. Con (30) do direttamente il valore al singolo elemento.

in *alfa ti ritrovi 30. Il motivo è che (*beta) è proprio alfa.

[Warioss]

Per il primo post.
No, delete serve per cancellare singoli puntatori allocati con new mentre delete[] si usa per deallocare puntatori allocati con new[]
Es.

   int* alfa = new int; // alloco un singolo elemento con new
   delete alfa; // cancello l'elemento con delete

   int* beta = new int[16]; // alloco un array con new[]
   delete[] beta; // cancello l'array con delete[]

Fare una semplice delete su qualcosa allocato con new[] ha comportamento indefinito.
Non centrano nulla le matrici.

Per il secondo post.

...finché inserisci un elemento. Se provi a inserirne più di uno, prima o poi avrai un crash.
int vettore; è UN int e basta, NON è un array di int. Usarlo come hai fatto nel primo esempio è un grave errore.

Puoi allocare dove e quando ti pare, non ci sono limitazioni (memoria d sistema a parte), ma se vuoi che il secondo esempio funzioni devi passare il puntatore al puntatore in modo da poter modificare ciò che è all'esterno.
(Come avviene con le liste.)

void LeggiArray(int** vettore ,int r){
    cout<<"Quanti elementi si vuole inserire nel vettore?\n";
    cin>>r;
    (*vettore)=new int[r];
    for(int i=0;i<r;i++){
    cout<<"inserire l'elemento in posizione "<<i<<endl;
    cin>>*((*vettore)+i);
    }
}
void StampaArray(int* vettore,int r){
        for(int i=0;i<r;i++)
            cout<<*(vettore+i)<<endl;
}

int main(int argc, char** argv) {
    int *vettore,r;
    LeggiArray(&vettore,r);
    StampaArray(vettore,r);
    delete[] vettore; // non dimenticare questa.
    return 0;
}

Se ti sembra strano, rifletti sul fatto che se scrivi:

int alfa = 10;
int* beta = &alfa;
*beta = 20;

e ti ritrovi con alfa che vale 20, allo stesso modo se scrivi;

int* alfa = nullptr;
int** beta = &alfa;
(*beta) = new int(30); // Attenzione! Non [30]. Con (30) do direttamente il valore al singolo elemento.

in *alfa ti ritrovi 30. Il motivo è che (*beta) è proprio alfa.

Perfetto, grazie mille. Tutto chiaro, alla prossima