Problema dichiarazione Variabili Globali/Locali nel progetto e nelle Librerie

Comunque non capisco il bisogno di avere array di lunghezza variabile ma i cui valori si mantengano. Sapendo che tu scrivi il programma la successione degli eventi é questa: 0) ti serve un array per delle ragioni (farci cose) 1) lo crei 3) lo riempi 4) ci fai cose 5) l'array non ti é più necessario, quindi perché tenerlo? 6) torna a 0

E se la successione é questa non ci sono problemi, basta creare un normale array in una funzione e usarlo prima che la funzione finisca, e questo lo sai fare

Beh, una qualche utilità la avrebbe, comunque Ma con arduino diventa duretta... Per paolo311 Se si ridefinissero (overloading) anche gli operatori [ ] un oggetto di una tale classe sarebbe indistinguibile nell'uso da un array, o sbaglio?

Standardoil: Se si ridefinissero (overloading) anche gli operatori [ ] un oggetto di una tale classe sarebbe indistinguibile nell'uso da un array, o sbaglio?

Diciamo che ci assomiglia.. :)

Però tieni presente che una cosa del genere ha senso solo se hai dei metodi a corredo dell'array che manipolano in modo particolare i dati memorizzati, oppure se vuoi vincolare in qualche modo l'accesso diretto ai dati.

Tant'è che l'allocazione con il new funziona anche a "secco"..

  byte* mdaob;
  int size = analogRead(A0);
  mdaob = new byte[size];
  

  Serial.println(size);
  for (int i = 0; i < size; i++)
  {
    Serial.println(mdaob[i]);
  }

PS. Grazie del complimento, però per me riprendere a sviluppare in c\c++ è come guidare dopo tanti anni una macchia senza servosterzo.

Grazie Ciao

E così ricadiamo nella mia prima risposta, dove però io usavo una alloc () non conoscendo io bene il c++
Si, in effetti le soluzioni quelle sono…

Standardoil: Ma tu hai letto le mie risposte?

Ho letto tutto ma non trovato una soluzione alle tue due risposte.

Standardoil: Tu saresti (leggo dalla tua presentazione) un po' arrugginito? Quando riprenderai appieno cosa farai? Riscriverai lo IDE per farlo girare su una MEGA?

Sono arrugginito su questo argomento in tale post che io ho pubblicato.

Diciamo che il progetto è di creare una libreria che implementi un mio protocollo seriale con real time interno e vorrei avere come parametro il numero di byte massimi che il buffer di ricezione può contenere ed il numero di byte massimi che la funzione interna del Real Time mi invia al colpo in base ad un tempo prefissato.

NB: il blocco Real Time è una funzione a parte e serve solo per aggiornare i dati per una sicurezza di stabilità quindi può essere anche disattivato e l'invio e la recezione funzionano tranquillamente.

E visto che sono programmatore di PLC dove si lavora a linguaggio grafico a blocchi mi viene naturale generare delle librerie come se fossero i blocchi funzionali come le Macro nel PLC o più semplicemente funzioni e quindi desidero farlo bene in modo robusto per poi anche pubblicarle con tutta la documentazione :)

Io di media uso microcontrollori STM32 principalmente STM32F103C8T6 ed la versione cicciona STM32F407ZGT6 per motivi di presentazioni elevate (overclok, tanti GPIO e potenza da 32bit).

Ma come regola cerco sempre di fare girare il codice su un ATMega328P per esser sicuro che anche un micro ad 8 bit "semplice" lo supporti poiché noto di più gli errori come calcoli sulla latenza ecc (tramite l'oscilloscopio) per poi usarlo su Micro un po' più seri...

paolo311: Perdonami, ma "interno" rispetto a cosa?

Se intendi dichiarare un array "interno" ad una funzione e aspettarti che mantenga lo stato anche fuori, devi cambiare la logica perchè questo non accadrà mai, una volta usciti dal blocco le variabili dichiarate in esso non sono più referenziabili a meno di non usare i trucchi che ti hanno già indicato (appoggi il riferimento su un alias globlale o con scope più ampio e poi lo vai a riprendere, etc..)

Oppure cambi la logica, la funzione può diventare un metodo di classe, all'interno della quale c'è un membro privato che è l'array, in questo modo l'array resta nascosto ma mantiene lo stato all'uscita dal metodo

Una cosa così:

#include 

class MyDumbArrayOfBytes { private:     byte* internalArray;     int size;

public:     MyDumbArrayOfBytes(int _size);     ~MyDumbArrayOfBytes();

    void Set(int _index, byte _value);     byte Get(int _index);     int Size(); };

MyDumbArrayOfBytes::MyDumbArrayOfBytes(int _size) {     internalArray = new byte[_size];     size = _size; }

MyDumbArrayOfBytes::~MyDumbArrayOfBytes() { }

void MyDumbArrayOfBytes::Set(int _index, byte _value) {     internalArray[_index] = _value; }

byte MyDumbArrayOfBytes::Get(int _index) {     return internalArray[_index]; }

int MyDumbArrayOfBytes::Size() {     return size; }




Che si può usare così:


include

include

void setup() {   Serial.begin(9600);

  MyDumbArrayOfBytes mdaob(analogRead(A0));

  Serial.println(mdaob.Size());   for (int i = 0; i < mdaob.Size(); i++)   {     Serial.println(mdaob.Get(i));   } }




Per adattarlo alle tue necessità devi effettuare una scelta, o separi il metodo che alloca l'array da quello che lo utilizza e in questo caso la classe va più o meno bene così, oppure se vuoi mantenere la logica attuale devi dotarti di flagettino che setti a true alla prima inizializzazione e lo testi sulle successive in modo da non ripetere l'allocazione dell'array.

Ciao


Intendo interna alla Libreria che desidero creare.

IN SPECIFICO:

Vorrei fare una libreria dove adotta un protocollo seriale per mandare dati binari ovvero singoli bit e quindi tale libreria deve avere come parametri il numero di bit in ingresso in modo da "collegarlo" direttamente ad un PIN della scheda dichiarato ingresso ed il numero di bit d'uscita usati per comandare direttamente un PIN digitale. (Può valere anche con i Bytes la logica per il calcolo dei Byte tramite i Bit o viceversa la so fare).

La libreria fa praticamente tutto; invio e recezione dati tramite bit che gestisco io dal programma nel loop. Ci sono ovviamente parametri d'indirizzo, marcatori ecc ma la cosa che non so fare è rendere flessibile la libreria e far scegliere all'utente quanti sengali digitali (bit) inviare e quanti ricevere.

(Sto leggendo e cercando di apprendere il più possibile dalle risposte e noto che ci sono molte cose sul codice mai viste)

Sempre per Paolo311 il tuo codice sembra proprio letto velocemente a quello che pensavo con le corrispettive funzioni di writer e read ma non capisco da dove sia stato tirato fuori il nome "mdaob" e poi il codice è tutto intero o è diviso uno nel file.h e le funzioni nel file.ccp ? Perché vedo le dichiarazioni delle variabili e poi subito sotto le funzioni di Get() Set() ecc ecc XD sono confuso di librerie non ne ho fatte molte ma ho sempre usato due file uno .h e uno .ccp e avvolte vedendo librerie di altri hanno tanti file .h penso o tanti file ccp. Sono confuso XD

Se uno sa o ha usato librerie che implementano tale metodo le condivida così forse leggendo il loro interno capsico bho XD

non credo che tu abbia letto le mie risposte, per due ragioni: 1) non hai nemmeno capito quando scrivo a te e quando no 2) ci sono scritte, nelle mie risposte, tutte e due le "sole" due soluzioni possibili, di una poi ti è stata anche indicata la versione c++ inoltre: 3) tu hai già trovato e letto le librerie che fanno quello che cerchi, hai esattamente trovato quello che ti indicavo io, ma non ne hai fatto niente e quindi? cosa aspetti adesso a prenderti un buon libro e a studiare quello che ti abbiamo detto? credimi: è escluso che, ad esempio, io ti scriva la tua "funzione magica", fai molto prima a studiare per il resto: buon viaggio

Partiamo dall'inizio, tu hai questo problema: devi dichiarare un array quando non sai ancora la sua dimensione.

Una delle soluzioni disponibili è quella che ti ho mostrato: dichiari un puntatore e poi quando conosci la dimensione dell'array, lo inizializzi con il numero di valori che ti serve.

La classe è un "fiorellino" in più perchè permette di definire con precisione lo scope dell'array, e di aggiungere metodi specifici per manipolarlo.

MizzardNet: Sempre per Paolo311 il tuo codice sembra proprio letto velocemente a quello che pensavo con le corrispettive funzioni di writer e read ma non capisco da dove sia stato tirato fuori il nome "mdaob"

"mdaob" è arbitrario, è il nome di una variabile di tipo MyDumbArrayOfBytes

MizzardNet: e poi il codice è tutto intero o è diviso uno nel file.h e le funzioni nel file.ccp ?

Le best pratices c++ credo che indichino di creare per ogni classe un file *.h con le dichiarazioni e un file *.cpp con l'implementazione, io però sono pigro (estremamente pigro..) quindi, sacrifico una regola "da manuale" a favore di una maggiore leggibilità e minore dispersione.

P.

Standardoil: non credo che tu abbia letto le mie risposte, per due ragioni: 1) non hai nemmeno capito quando scrivo a te e quando no 2) ci sono scritte, nelle mie risposte, tutte e due le "sole" due soluzioni possibili, di una poi ti è stata anche indicata la versione c++ inoltre: 3) tu hai già trovato e letto le librerie che fanno quello che cerchi, hai esattamente trovato quello che ti indicavo io, ma non ne hai fatto niente e quindi? cosa aspetti adesso a prenderti un buon libro e a studiare quello che ti abbiamo detto? credimi: è escluso che, ad esempio, io ti scriva la tua "funzione magica", fai molto prima a studiare per il resto: buon viaggio

Senti in poche parole le tue risposte non sono state esaustive come quelle di paolo311 ed non serve alzare la cresta approfittando del fatto di aver sbagliato a rispondere ad una tua risposta riferita ad qualcun'altro, non hai messo i "quote" e dalla mia visione sembrava fosse riferita a me tutto qui.

Poi non ho trovato affatto librerie che fanno al caso mio e l'unica che ha quello che cerco l'ho postata in file .zip e l'ho fatto se qualcuno è in grado di spiegarmi con funziona il codice per poi così utilizzarlo nelle mie librerie personali.

Io vedo solo una tua versione, io vedo dalla seconda risposta un codice esempio che non ho capito e non riesco ad implementarlo rispetto a quello di paolo311 che ok sarà simile al tuo come hai detto tu in un'altra risposta dove però hai usato un alloc()...

Standardoil: E così ricadiamo nella mia prima risposta, dove però io usavo una alloc () non conoscendo io bene il c++ Si, in effetti le soluzioni quelle sono...

E poi è facile dire "studia c" e fine... non so... qualche suggerimento di libri su C buoni ? Tranquillo che non mi aspetto il "codice magico" da te... mi bastano avanzano le tue risposte inconcludenti.

Paolo 311 mi ha fatto capire meglio.

paolo311: Partiamo dall'inizio, tu hai questo problema: devi dichiarare un array quando non sai ancora la sua dimensione.

Una delle soluzioni disponibili è quella che ti ho mostrato: dichiari un puntatore e poi quando conosci la dimensione dell'array, lo inizializzi con il numero di valori che ti serve.

La classe è un "fiorellino" in più perchè permette di definire con precisione lo scope dell'array, e di aggiungere metodi specifici per manipolarlo.

"mdaob" è arbitrario, è il nome di una variabile di tipo MyDumbArrayOfBytes

Le best pratices c++ credo che indichino di creare per ogni classe un file *.h con le dichiarazioni e un file *.cpp con l'implementazione, io però sono pigro (estremamente pigro..) quindi, sacrifico una regola "da manuale" a favore di una maggiore leggibilità e minore dispersione.

P.

Ahh si vero il nome mdaob è il nome dell'istanza MyDumbArrayOfBytes usata nel progretto vero. Quindi il codice con le funzioni lo metto tutto interno in un file con un determianto nome ? con l'estensione .h ?

Ho provato a mettere il codice .h in un file e l'altro nel progetto principale e mi fa errore di compilazione. I file sono tutti e due nella stessa cartella. Il nome del file è MyDumbArrayOfBytes.h

Codice erorre:

Arduino:1.8.5 (Windows 10), Scheda:"Arduino/Genuino Uno"

C:++++++++++++\AppData\Local\Temp\cc2zQSTq.ltrans0.ltrans.o: In function `main':

C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/main.cpp:46: undefined reference to `loop'

collect2.exe: error: ld returned 1 exit status

exit status 1 Errore durante la compilazione per la scheda Arduino/Genuino Uno.

Questo report potrebbe essere più ricco di informazioni abilitando l'opzione "Mostra un output dettagliato durante la compilazione" in "File -> Impostazioni"

Chiedo subito perchè so' che c'è qualcosa che mi sfugge.

MizzardNet:
…serve alzare la cresta approfittando del fatto di aver sbagliato a rispondere ad una tua risposta riferita ad qualcun’altro, non hai messo i “quote” e dalla mia visione sembrava fosse riferita a me tutto qui.

Poi non ho trovato affatto librerie che fanno al caso mio e l’unica che ha quello che cerco l’ho postata in file .zip e l’ho fatto se qualcuno è in grado di spiegarmi con funziona il codice per poi così utilizzarlo nelle mie librerie personali.

Io vedo solo una tua versione, io vedo dalla seconda risposta un codice esempio che non ho capito e non riesco ad implementarlo rispetto a quello di paolo311 che ok sarà simile al tuo come hai detto tu in un’altra risposta dove però hai usato un alloc()…

E poi è facile dire “studia c” e fine… non so… qualche suggerimento di libri su C buoni ?
Tranquillo che non mi aspetto il “codice magico” da te… mi bastano avanzano le tue risposte inconcludenti.

chiedo scusa alla moderazione per la citazione quasi completa, ma ci sono talemtnte tanti spunti che non potevo evitare
per lo OP

  1. non sono io che alzo la cresta, se misurassimo la “lunghezza” delle risposte, sarebbe evidente chi sta “alzando” qualcosa… e non serve nemmeno accusarmi di non aver messo i tag, sei TU che non hai capito, non io che ho sbagliato, infatti altri hanno capito benissimo
  2. che tu non abbia trovato librerie che fanno al caso tu ci credo, non le sai “capire”, nemmeno quando te le spiegano
    _digitalValues = (uint8_t *)malloc(numberOfShiftRegisters * sizeof(uint8_t));

questa riga viene esattamente dalla libreria che hai allegato tu
e funziona esattamente come ti ho spiegato io nel mio post #1 (il primo che hai letto)
la riga si legge:
assegni a puntatore il risultato di un cast a tipo specifico del puntatore restituito da una malloc che alloca la memoria calcolata con la sizeof
prova a dirmi che non è quello che ti ho scritto al post #1; se non sei capace non lamentarti e non accusare gli altri. Per tua norma, se mi accusi ancora una volta di un fatto non vero ti segnalo alla moderazione
3) che tu non abbia capito il codice esempio non mi stupisce, anche perchè nella mia altra risposta io ho usato una malloc(), non sei nemmeno andato a vedere, hai solo copincollato risposte a casaccio
4)è facile dire studia il ‘C’, però io non solo lo ho detto, ho anche fatto: ho un intero trhead “aiutateci ad aiutarvi” che tu non hai nemmeno cercato, sei venuto qui, hai chiesto e adesso aspetti che ti diano la “pappa fatta” (che è un mio altro trehad al riguardo)
se tu, non dico avessi cercato, ma solo ti fossi minimamente guardato intorno, avresti trovato TUTTE le info che ti servono, invece aspetti solo la “soluzione”, che oltretutto deve essere anche facile da capire per te, altrimenti non la riconosci e ti metti a accusare

quindi non mi rimane da dirti che:
buon viaggio

PS spero che tutto questo rimanga qui, a futura memoria…

Standardoil: ... se mi accusi ancora una volta di un fatto non vero ti segnalo alla moderazione ...

... io leggo e vedo TUTTO, anche se non intervengo ... ora prego entrambi di abbassare i toni e riportare il tutto ad una normale discussione tecnica. Grazie.

Guglielmo

Standardoil: chiedo scusa alla moderazione per la citazione quasi completa, ma ci sono talemtnte tanti spunti che non potevo evitare per lo OP 1) non sono io che alzo la cresta, se misurassimo la "lunghezza" delle risposte, sarebbe evidente chi sta "alzando" qualcosa... e non serve nemmeno accusarmi di non aver messo i tag, sei TU che non hai capito, non io che ho sbagliato, infatti altri hanno capito benissimo 2) che tu non abbia trovato librerie che fanno al caso tu ci credo, non le sai "capire", nemmeno quando te le spiegano

    _digitalValues = (uint8_t *)malloc(numberOfShiftRegisters * sizeof(uint8_t));

questa riga viene esattamente dalla libreria che hai allegato tu e funziona esattamente come ti ho spiegato io nel mio post #1 (il primo che hai letto) la riga si legge: assegni a puntatore il risultato di un cast a tipo specifico del puntatore restituito da una malloc che alloca la memoria calcolata con la sizeof prova a dirmi che non è quello che ti ho scritto al post #1; se non sei capace non lamentarti e non accusare gli altri. Per tua norma, se mi accusi ancora una volta di un fatto non vero ti segnalo alla moderazione 3) che tu non abbia capito il codice esempio non mi stupisce, anche perchè nella mia altra risposta io ho usato una malloc(), non sei nemmeno andato a vedere, hai solo copincollato risposte a casaccio 4)è facile dire studia il 'C', però io non solo lo ho detto, ho anche fatto: ho un intero trhead "aiutateci ad aiutarvi" che tu non hai nemmeno cercato, sei venuto qui, hai chiesto e adesso aspetti che ti diano la "pappa fatta" (che è un mio altro trehad al riguardo) se tu, non dico avessi cercato, ma solo ti fossi minimamente guardato intorno, avresti trovato TUTTE le info che ti servono, invece aspetti solo la "soluzione", che oltretutto deve essere anche facile da capire per te, altrimenti non la riconosci e ti metti a accusare

quindi non mi rimane da dirti che: buon viaggio

PS spero che tutto questo rimanga qui, a futura memoria........

AHHH perfetto adesso ho capito ! Ti sei spiegato bene XD

Comunque tranquillo io non ti accuso di niente ho solo detto che dalle tue risposte non ho capito bene e quindi per me inconcludenti. Una buona risposta equivale a fare capire l'argomento ad uno che non sa niente su tale.

Per quanto riguarda la risposta non riferita a me mi son sentito sminuito per il fatto che hai usato il mio errore e lo hai sottolineato come per il resto del fatto che non leggo, non cerco, accuso ecc ma stai tranquillo che l'ho fatto prima di scrivere questa discussione ed per adesso non ho visto altri utenti citare il mio stesso problema su altri post e ho dedotto forse che è un argomento mai citato prima.

Sicuramente ci sono post dove parlano ti tale discussione sotto altre voci e quindi ho pensato che sia più efficace scrivere direttamente un post specifico per aprire una nuovo argomento che può aiutare altri che s'imbattono in questo problema.

E non voglio essere preso per quello che vuole la pappa in bocca. Semplicemente non ho capito le tue risposte che sicuramente per un'altro saranno perfette ma per me no, quindi non volevo offenderti se ritengo le tue risposte incomplete.

Ma adesso avendolo rispiegato con il codice sotto mano tutto torna e ti RINGRAZIO ! XD

E mi scuso di tutto, Pace a Amore!

Adesso ho fatto un esempio con l’utilizzo di quel pezzo di codice che Standaroil mi ha fatto capire.

File Memoria_Dinamica.h

#ifndef Memoria_Dinamica_h
#define Memoria_Dinamica_h
#include "Arduino.h"

class Memoria_Dinamica {

  public:

    uint8_t * _digitalValues;

    Memoria_Dinamica(int Buffer);

  private:

};

#endif

Memoria_Dinamica.cpp

#include "Memoria_Dinamica.h"
#include "Arduino.h"

Memoria_Dinamica::Memoria_Dinamica(int Buffer) {

  // allocates the specified number of bytes and initializes them to zero
  _digitalValues = (uint8_t *)malloc(Buffer * sizeof(uint8_t));

  //memset(_digitalValues, 0, Buffer * sizeof(uint8_t));
}

Memoria_Dinamica.ino

//19/08/2019
//by MizzardNet
//Arduino Forum > Problema dichiarazione Variabili Globali/Locali nel progetto e nelle Librerie
//Link          > https://forum.arduino.cc/index.php?topic=631143.0

#include "Memoria_Dinamica.h"

//Pin I/O
#define I1 2
#define I2 3
#define I3 4
#define I4 5
#define I5 6
#define I6 7
#define I7 8
#define I8 9
#define Q1 A0
#define Q2 A1
#define Q3 A2
#define Q4 A3
#define Q5 A4
#define Q6 A5

//Il parametro numerico è il valore della dimensione dell'array della variabile _digitalValues[]

//PROBLEMA
//Se s'imposta come valore di dimensione 6, e si utilizzano indici superiori
//a 6, funziona comunque O.O

Memoria_Dinamica Memoria_1(6);

void setup() {

  //Serial.begin(115200);

  //Mappatura I/O
  pinMode(I1, INPUT);
  pinMode(I2, INPUT);
  pinMode(I3, INPUT);
  pinMode(I4, INPUT);
  pinMode(I5, INPUT);
  pinMode(I6, INPUT);
  pinMode(I7, INPUT);
  pinMode(I8, INPUT);
  pinMode(Q1, OUTPUT);
  pinMode(Q2, OUTPUT);
  pinMode(Q3, OUTPUT);
  pinMode(Q4, OUTPUT);
  pinMode(Q5, OUTPUT);
  pinMode(Q6, OUTPUT);

}

void loop() {

  //Lettura degli ingressi e scrittura dei valori sulle variabili _digitalValues[]
  Memoria_1._digitalValues[0] = digitalRead(I1);
  Memoria_1._digitalValues[1] = digitalRead(I2);
  Memoria_1._digitalValues[2] = digitalRead(I3);

  //Lettura delle variabili _digitalValues[] e scrittura del valore sui pin d'uscita
  digitalWrite(Q1, Memoria_1._digitalValues[0]);
  digitalWrite(Q2, Memoria_1._digitalValues[1]);
  digitalWrite(Q3, Memoria_1._digitalValues[2]);

}

Come scritto anche nel progetto funziona praticamente tutto ma c’è un problema per quanto riguarda la dimensione effettiva dell’array della variabile pubblica interna alla libreria _digitalValues.

Nell’esempio se imposto se le variabili ad indici elevati come 100, 101, 102 funziona comunque sempre con il parametro impostato a 6 ovvero un array di 6 variabili da 0 a 5

Memoria_Dinamica Memoria_1(6);
void loop() {

  //Lettura degli ingressi e scrittura dei valori sulle variabili _digitalValues[]
  Memoria_1._digitalValues[100] = digitalRead(I1);
  Memoria_1._digitalValues[101] = digitalRead(I2);
  Memoria_1._digitalValues[102] = digitalRead(I3);

  //Lettura delle variabili _digitalValues[] e scrittura del valore sui pin d'uscita
  digitalWrite(Q1, Memoria_1._digitalValues[100]);
  digitalWrite(Q2, Memoria_1._digitalValues[101]);
  digitalWrite(Q3, Memoria_1._digitalValues[102]);

}

C’è qualcosa di losco in tutto questo ? E stabile come funzione se usata in un progetto complesso o fa disastri ?

Perchè per funzionare funziona ma sono sicuro che qualcosa mi sfugge…

PS: ho allegato qua il progetto in .zip d’esempio intero fresco fresco :slight_smile:

Memoria_Dinamica.zip (1.39 KB)

OK, OK come esempio potrebbe anche andare, lasciamo stare che crei una classe per allocare un array di byte dei quali usi un solo bit, ma la memoria è tua, usala come preferisci cosa non ti è chiaro? io ho capito una cosa: che tu hai dimensionato un array di 6 elementi e ti stai stupendo che se tenti di usare ad esempio il 101 va lo stesso è questo che ti domandi?

Standardoil: OK, OK come esempio potrebbe anche andare, lasciamo stare che crei una classe per allocare un array di byte dei quali usi un solo bit, ma la memoria è tua, usala come preferisci cosa non ti è chiaro? io ho capito una cosa: che tu hai dimensionato un array di 6 elementi e ti stai stupendo che se tenti di usare ad esempio il 101 va lo stesso è questo che ti domandi?

Sì perfettamente, mi sto stupendo del fatto che posso usare più byte di quanti "dichiarati".

L'esempio è solo di prova per testare velocemente la funzione dopo farò in modo che mi legge i singoli bit nei byte ovviamente.

Noto anche che nella compilazione la memoria dinamica non cambia dice che usa 21 byte l'1% della memoria dinamica ecc ecc e se cambia, cambia di poco...

Cioè alla fine è una cosa normale ? Non capisco cosa serve il parametro per settare la dimensione se poi posso usare tutta la memoria che desidero.

So come mi è capitato mille volte di andare in overflow negli array ed il compilatore questo non lo rileva come errore con tremendi problemi sulla funzione del codice invece in tale esempio va tutto quando mi aspettavo il macello.

E perché dovrebbe essere un macello? Il problema dell'overflow dell'array si ha se lo spazio dove si sta andando a scrivere/leggere risulta già occupato da altre variabili. Nel tuo esempio, che io possa vedere, le uniche variabili presenti sono l'array di 6 bytes che hai creato. Di co seguenza al 100 esimo byte dal l'inizio dell'array non ci va nulla, e più essere usato come stai facendo. Il problema nascerebbe se avessi qualcosa che scrive/legge in quel punto, di diverso dall'array

Allo OP serve assolutamente leggere il k&r E bene

Silente: E perché dovrebbe essere un macello? Il problema dell'overflow dell'array si ha se lo spazio dove si sta andando a scrivere/leggere risulta già occupato da altre variabili. Nel tuo esempio, che io possa vedere, le uniche variabili presenti sono l'array di 6 bytes che hai creato. Di co seguenza al 100 esimo byte dal l'inizio dell'array non ci va nulla, e più essere usato come stai facendo. Il problema nascerebbe se avessi qualcosa che scrive/legge in quel punto, di diverso dall'array

Cioè non so se ho capito: se utilizzo i byte al di fuori dal valore che ho dichiarato posso riscontrare problemi poichè possono essere usati per altre locazioni di memoria ?

Di diverso dall'array intendi singole variabili con un loro singolo nome per esempio ?

Standardoil: Allo OP serve assolutamente leggere il k&r E bene

Scusa la mia IGNORANZA, cosa intendi per OP ? Leggere il K&r ? Cos'è ? XD

Secondo voi se uso le variabili entro la dimensione impostata posso stare tranquillo ?

Cioè problemi come l'overflow, come mi ha spiegato Silente, che succede solo se lo spazio in avanti partendo dall'indice zero dell'array è usato per altre variabili giusto ?

Il problema del superamento dei confini dell’array chiaramente non si pone se non superi tali confini (es: se dichiaro un array di cinque elementi posso usare tutti quelli compresi tra gli indici 0 e 4 inclusi). Come “di diverso dall’array” intendo qualsiasi cosa non sia quell’array, ovvero una qualsiasi variabile, array, oggetto o puntatore che scriva o legga in quella data area di memoria (che sia locale o globale)

OP (Original Poster) sei tu, MizzardNet
K&R é la sigla, dei nomi degli autori, che indica IL manuale di C (Cristianesimo:bibbia=‘C’:K&R)

Silente: Il problema del superamento dei confini dell'array chiaramente non si pone se non superi tali confini (es: se dichiaro un array di cinque elementi posso usare tutti quelli compresi tra gli indici 0 e 4 inclusi). Come "di diverso dall'array" intendo qualsiasi cosa non sia quell'array, ovvero una qualsiasi variabile, array, oggetto o puntatore che scriva o legga in quella data area di memoria (che sia locale o globale)

OP (Original Poster) sei tu, MizzardNet K&R é la sigla, dei nomi degli autori, che indica IL manuale di C (Cristianesimo:bibbia='C':K&R)

CAPITO TUTTO ! :D