DOMANDA Dubbio risoluzione con array con C++

[Fabifont]

Secondo me ti stai complicando la vita . Non è uno standard dichiarare un array con dimensione di una variabile . È possibile solo se lo fai dinamicamente


Sent from my iPhone using Toms Hardware Italia Forum

 

[DispatchCode]

si scusa avevo cancellato mi ero accorto della stupidata mia...
Chiedo pero' altra cosa.. DEFINE DIM non l'ho mai fatta a scuola è quello il problema, come faccio a presentare un codice con parti mai fatte ??

Define dim definisce una costante ovvero una “variabile” il cui valore resta fisso per la durata di tutto il programma.
O fai la define o fai la new come ti hanno detto prima ... non esistono altri modi che io sappia ...
Ma scusa tu vai a scuola e ti hanno fatto iniziare con il c++? Senza basi di c o almeno intruduzione alla differenza tra variabili e costanti e le cose basilari?


Inviato da iPhone tramite App ufficiale di Tom\\\'s Hardware Italia Forum

Non è corretto in realtà.
Fare #define DIM, significa usare una direttiva per il preprocessore, che non è una costante (viene risolta prima della compilazione).
Inoltre puoi inizializzare l'array con la dimensione letta successivamente, in quanto inserita in input e quindi conosciuta (spazio che verrà creato sullo stack, e non nello heap).

 

[Fabifont]

si scusa avevo cancellato mi ero accorto della stupidata mia...
Chiedo pero' altra cosa.. DEFINE DIM non l'ho mai fatta a scuola è quello il problema, come faccio a presentare un codice con parti mai fatte ??

Define dim definisce una costante ovvero una “variabile” il cui valore resta fisso per la durata di tutto il programma.
O fai la define o fai la new come ti hanno detto prima ... non esistono altri modi che io sappia ...
Ma scusa tu vai a scuola e ti hanno fatto iniziare con il c++? Senza basi di c o almeno intruduzione alla differenza tra variabili e costanti e le cose basilari?


Inviato da iPhone tramite App ufficiale di Tom\\\'s Hardware Italia Forum

Non è corretto in realtà.
Fare #define DIM, significa usare una direttiva per il preprocessore, che non è una costante (viene risolta prima della compilazione).
Inoltre puoi inizializzare l'array con la dimensione letta successivamente, in quanto inserita in input e quindi conosciuta (spazio che verrà creato sullo stack, e non nello heap).

Peccato che non tutti i compilatori possono accettare quello che stai dicendo ... tra l’altro se non vuoi usare define usi const int


Inviato da iPhone tramite App ufficiale di Tom\\\'s Hardware Italia Forum

 

[Fabifont]

si scusa avevo cancellato mi ero accorto della stupidata mia...
Chiedo pero' altra cosa.. DEFINE DIM non l'ho mai fatta a scuola è quello il problema, come faccio a presentare un codice con parti mai fatte ??

Define dim definisce una costante ovvero una “variabile” il cui valore resta fisso per la durata di tutto il programma.
O fai la define o fai la new come ti hanno detto prima ... non esistono altri modi che io sappia ...
Ma scusa tu vai a scuola e ti hanno fatto iniziare con il c++? Senza basi di c o almeno intruduzione alla differenza tra variabili e costanti e le cose basilari?


Inviato da iPhone tramite App ufficiale di Tom\\\'s Hardware Italia Forum

Non è corretto in realtà.
Fare #define DIM, significa usare una direttiva per il preprocessore, che non è una costante (viene risolta prima della compilazione).
Inoltre puoi inizializzare l'array con la dimensione letta successivamente, in quanto inserita in input e quindi conosciuta (spazio che verrà creato sullo stack, e non nello heap).

Oltretutto il tuo metodo funziona con array di piccole dimensioni , man mano che diventa grande rischi l’overflowing


Inviato da iPhone tramite App ufficiale di Tom\\\'s Hardware Italia Forum

 

[DispatchCode]

si scusa avevo cancellato mi ero accorto della stupidata mia...
Chiedo pero' altra cosa.. DEFINE DIM non l'ho mai fatta a scuola è quello il problema, come faccio a presentare un codice con parti mai fatte ??

Define dim definisce una costante ovvero una “variabile” il cui valore resta fisso per la durata di tutto il programma.
O fai la define o fai la new come ti hanno detto prima ... non esistono altri modi che io sappia ...
Ma scusa tu vai a scuola e ti hanno fatto iniziare con il c++? Senza basi di c o almeno intruduzione alla differenza tra variabili e costanti e le cose basilari?


Inviato da iPhone tramite App ufficiale di Tom\\\'s Hardware Italia Forum

Stavo solo contestando il "define definisce una costante...".
Chiaro che lo stack non è illimitato. Ma dare come dimensione DIM un valore elevato sortirebbe lo stesso risultato, considerando che DIM verrebbe risolta in fase di pre compilazione.

 

[MPG]

Cava quel stdio.h. E ripeto, si scrive <cnomefile> non <nomefile.h>.
Chiamalo size o altro nome, se non proviene da una direttiva non si mette il nome di una variabile in maiuscolo.
E ultima cosa non va mai messa come globale. E dichiara l’array all’inizio.

SI mi è era rimasto quel stdio.h. ora lo tolgo. Il DIM maiuscolo era rimasto per quello che mi aveva scritto Fabifont.
Cosa vuol dire che "non va mai messa come globale"? ti riferisce sempre a DIM?
Per l'arrary all'inizio intendi " int array[DIM];"?
Ma se lo metto sotto a int val (ho chiamato val la ex DIM) non va poi... cosa intendi?
Comunque devo ben capire questa int array [val] la funzione fondamentale che ha, ripeto non ho mai fatto un esercizio cosi', a volte magari dite cose per voi ovvie ma non tutti ci arrivano o hanno avuto gli stessi insegnamenti anche a parità di scuola.

Ora ho fatto cosi'

#include <iostream>

using namespace std;
int val;

int main()
{
  int dim, j = 0;
  do
  {
    j++;
    cin >> dim;
  } while (j < 3 && dim < 2);
  if (j != 3)
  {

    int array[val];
    for (int i = 0; i < dim; i++)
    {
      do
      {
        cin >> array[i];
      } while (array[i] < 1 || array[i] > 9);
    }
    for (int g = 0; g < dim; g++)
    {
      cout << array[g] << ' ';
    }
  }

  return 0;
}

 

[MPG]

Le due variabili che chiamate dim sono appunto diverse.
dim viene valorizzata con il valore in input; l'altra invece viene valorizzata con un valore N appartenente all'intervallo del tipo int. Quindi funziona solo perché quell'array viene inizializzato con N elementi.
Prova a stampare il valore di DIM.

Mi spieghi bene questo concetto scusa?

 

[MPG]

Ora ho fatto cosi'

#include <iostream>
using namespace std;
int i;


int main()
{
  int dim, j = 0;
  do
  {
    j++;
    cin >> dim;
  } while (j < 3 && dim < 2);
  if (j != 3)
  {
    int array[i];
    for (int i = 0; i < dim; i++)
    {
      do
      {
        cin >> array[i];
      } while (array[i] < 1 || array[i] > 9);
    }
    for (int g = 0; g < dim; g++)
    {
      cout << array[g] << ' ';
    }
  }

  return 0;
}

Vedo che va bene anche cosi'!

 

[DispatchCode]

Ora ho fatto cosi'

#include 
using namespace std;
int i;


int main()
{
int dim, j = 0;
do
{
j++;
cin >> dim;
} while (j < 3 && dim < 2);
if (j != 3)
{
int array[i];
for (int i = 0; i < dim; i++)
{
do
{
cin >> array[i];
} while (array[i] < 1 || array[i] > 9);
}
for (int g = 0; g < dim; g++)
{
cout  }
}

return 0;
}

Vedo che va bene anche cosi'!

Domanda: sai cos'è un array? Perché da come li utilizzi, pare tu non li conosca nemmeno.

L'array è fondamentalmente di 2 tipi, statico e dinamico. Quello statico si chiama "fixed length" oppure "variable length", in quanto la dimensione è stabilita a runtime, ma non allocate dinamicamente (che è ciò a cui mi riferivo io). Tecnicamente però si tratta sempre di un array a lunghezza fissa.

Quello dinamico è allocato con malloc/calloc.
Meriterebbero altre considerazioni, ma per ora non aggiungerei altro.

Piccola nota a latere: quello variable length, non è presente in C standard (e deduco che l'altro utente si riferisse a questo) ma è presente da C99 (usare precedenti standard non ha molto senso).
Verrebbe dichiarato così:

int dim;
scanf("%d", &dim);
int array[dim];

Nel tuo caso l'input ha anche un range ben preciso e molto piccolo, quindi non ci sono problemi con lo stack.

In ultimo, se non inizializzi una variabile e la utilizzi comunque, non sai che valore avrà.

 

[MPG]

L'array so cos'è abbiamo appena iniziato a farlo in c++ ma solo le cose basilari (quindi che cos'e') , ma non ho basi di C o altro, è stato frutto di iniziale lezione (dopo il do, do while, for..) e poi da studiare a casa ma abbiamo un piccolo libro in merito al C++ a scuola.
Per cui quando mi parli di "Quello dinamico è allocato con malloc/calloc." non capisco perchè non mi è stato spiegato.
INfine "In ultimo, se non inizializzi una variabile e la utilizzi comunque, non sai che valore avrà." a cosa ti riferisci?

 

[DispatchCode]

L'array so cos'è abbiamo appena iniziato a farlo in c++ ma solo le cose basilari (quindi che cos'e') , ma non ho basi di C o altro, è stato frutto di iniziale lezione (dopo il do, do while, for..) e poi da studiare a casa ma abbiamo un piccolo libro in merito al C++ a scuola.
Per cui quando mi parli di "Quello dinamico è allocato con malloc/calloc." non capisco perchè non mi è stato spiegato.
INfine "In ultimo, se non inizializzi una variabile e la utilizzi comunque, non sai che valore avrà." a cosa ti riferisci?

Hai ragione, mi ero perso il C++. Nel tuo caso allocchi con l'operatore new la memoria, ma valgono le considerazioni esposte sopra.

Mi riferisco al tuo:

int array[i];

Quella i, se non ho visto male, non è inizializzata. Idem il tuo caso sopra, dove utilizzavi DIM.[/i]

 

[MPG]

Scusa pero' hai visto qui:
"
int array;
for (int i = 0; i < dim; i++)
"
Nel for c'è int i=0.. non va bene qui?

 

[rodhellas]

Scusa pero' hai visto qui:
"
int array;
for (int i = 0; i < dim; i++)
"
Nel for c'è int i=0.. non va bene qui?

Nel momento della dichiarazione dell'array i non è ancora inizializzato, contando poi che quell'int i è interno al ciclo for.

 

[MPG]

Ma scusa dovrei mettere cosi'?
#include <iostream>
using namespace std;
int i=0;

Ma se non mettessi cosi' cosa succerebbe?

 

[_Achille]

Regola molto importante: dare alle variabili nomi sensati, parole complete pure se lunghe finché siamo in codici per uso educativo. Quindi variabili con nomi tipo i, j, k, ecc... si usano come contatori. Punto.
Altra cosa, se hai due varibili che devono contenere stesse cose, tipo due somme, non le si chiamano somma e SOMMA. Le si chiamano somma1 e somma2 e se possibile piuttosto che 1 e 2 cosa sono specializzate.
Seconda cosa, non, e ripeto non si dichiarano variabili globali. Non stiamo facendo problemi per le Olimpiadi di Informatica.

Un array deve avere una dimensione ben specificata perché sia inserito sullo Stack. Di solito si usano variabili costanti o valori costanti.
Ad esempio

const int dimensione = 5;

int array1[dimensione];
int array2[5];

Sono entrambe giuste. Dimensione è costante (variabile a sola lettura) e inizializzata mentre 5 è un valore costante.

Roba tipo

int i;
int array[i];

È assurda. i quanto è? Non è inizializzata. Potrebbe essere 0, potrebbe. E pure se lo fosse sarebbe più che sbagliato.

Poi

int i;
for ( int i = 0;  ; )

Una dichiarazione di una variabile già dichiarata? Sbagliatissimo. Nulla però vieta di fare così:

int i;
for ( i = 0;  ; )

Non lo faccio mai e non lo consiglio ma è corretto.

Quindi che si fa?
Se si vuole fare una cosa fatta bene si usa la memoria dinamica

int qualsiasivaloremaggioreugualeaduno = 28478;
int array = new int [qualsiasivaloremaggioreugualeaduno];
...
//Lo si elimina poi così
delete[] array;

Non penso ci sia tanto da dire, si usa new per dire che roba è la variabile. Delete (più [] se è un array) per liberare la memoria quando non serve più.
Altrimenti

int array[256];
int qualsiasivaloremaminoredi256 = 255;

for (int i = 0; i < qualsiasivaloremaminoredi256; i++)
   cin >> array[i];

Sullo stack c'è array con una dimensione di 256