Newsgroup: it.comp.lang.c++
Titolo: Array ciclico

Salve,
devo implementare un array ciclico sapete indicarmi un tutorial?
grazie

 grazie
Non capisco che tutorial ti occorra per perfezionare qualcosa di simile a:
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char* argv[])
{
        int prova[] = { 1,2,3,4,5 };
        const int sz=sizeof(prova)/sizeof(*prova);
        vector<int> C(prova,prova+sz);
        for(int i=0;i<3*sz;++i)
                cout << "C[" << i << "] = " << C[i % sz] << endl;
        return 0;
}
magari ti fai una classe che al posto di sz usa il metodo size() del
vettore.
ciao.



ma non che č per caso ti serve una deque (della STL)?
Dovresti spiegare con qualche parola in piů cosa intendi per array ciclico.

 grazie
un array circolare???
-- 
arwen_h
/*
when you do things right, people wont be sure you've done anything at all.
*/

 Non capisco che tutorial ti occorra per perfezionare qualcosa di simile a:
presto spiegato, volevo farlo io dopo aver letto come fare.
Tutto li'.
Cmq non ho capito il tuo esempio.
A me serve gestire un array di 10 elementi dove terro' una cronostoria di
un utente che se le volte precedenti, rispetto a quella attuale, ha
compiuto la stessa operazione, deve essere fermato.
Esempio, sono all'elemento array[0] devo controllare l'elemento array[9]
per saperlo.
Dopo saro' all'elemento array[1] e per me questo sara' il mio nuovo punto
di partenza, quindi dovro' controllare l'elemento array[0]. In pratica mi
serve ciclico affinche' posso sempre mettere nuovi elementi nello stesso
array e "spostarne" il punto di partenza.
Spero d'esser stato chiaro.
Grazie

 con qualche parola in più cosa intendi per array ciclico.
l'ho scritto in risposta al msg di Paolo.
Grazie

 Spero d'esser stato chiaro.
Non tanto.
Vediamo perché l'esempio che ho fatto non è proprio quello che vuoi te ma
avrebbe dovuto farti accendere la lampadina...
Vediamo il primo caso:
array[0] e array[9]
il tuo problema è con un indice che sta a zero es int i=0, indirizzare gli
elementi 0 e 9 (di un array di dieci elementi), mentre con un indice i=1 di
poter saltare da capo a partire dal primo elemento, infatti con i=1 devi
indirizzare array[1] e non 10, ma array[0] (zero), scommetto che se hai i=2
invece devi indirizzare array[2] e array[1]...
guarda caso un "indirizzamento" di questo tipo, stabilendo offset la
distanza tra il primo elemento e il secondo (nel tuo esempio è 9) e size la
dimensione del tuo array è proprio array[ i % size] e array [ (i+offset) %
10 ].
Chiaro?

 Non tanto.
ci ritento ((:
allora
int ultima_operazione[10];
// caso nuovo si inizia dal primo elemento
ultima_operazione[0] = 1;
...
...
// altra operazione
ultima_operazione[1] = 1;
...
...
// altra operazione
ultima_operazione[2] = 3;
...
...
// operazione n
ultima_operazione[9] = 1;
// adesso ricomincio a riscrivere nell'array xche' sono arrivato
all'ultimo elemento
...
...
// altra operazione
ultima_operazione[0] = 1;
...
...
// altra operazione
ultima_operazione[1] = 1;
// controllo se le ultime due operazioni sono uguali, per poter far cio'
devo settare l'inizio dell'array dall'elemento 1 xche' l'ultima operazione
e' stata compiuta li'.
...
...
// ricomincio a scrivere nell'array dall'elemento 2 etc etc etc
spero cosi' d'esser stato un po' piu' chiaro (:

 ha scritto nel messaggio
news:pan.2004.05.05....@tiscali.it...

Scusami ma forse č l'ora tarda... continuo a capire poco o niente... mi
spiace, č sicuramente colpa mia.
Spiegami con che criterio giudichi due operazioni uguali?
Sono uguali se
op[indice1]=valore1;
op[indice2]=valore2;
sono uguali se indice1==indice2 && valore1==valore2 ?
Se vuoi rilevare questo devi crearti una classe che memorizza l'ultimo
accesso (indice) e l'ultimo valore dell'ultima operazione valida e la
confronta con quella in corso. L'accesso all'elemento i-esimo dell'array
incapsulato nella classe lo puoi fare attraverso due metodi, uno
d'assegnamento e l'altro di lettura.
Settare invece " l'inizio dell'array ", cosa intendi ?
Scusa il linguaggio "tera a tera"... Intendi che da un qualsiasi indice,
puoi riassegnarli girandoli tutti e dieci ?
Allora puoi usare, ad esempio.
for (int i=0;i<10;++i) op[( i + indice_di_riferimento ) % 10 ] =
quello_che_mi_pare;
Cosģ te li "rigiri" tutti e dieci, da qualsiasi indice di riferimento.
indice_di_riferimento viene impostato dal metodo d'assegnamento della tua
classe (o lettura) quando verifichi l'ugualianza (secondo i tuoi criteri) di
due operazioni consecutive, es.
if (indice1==indice2 && valore1==valore2) indice_di_riferimento=indice2;
Ti chiedo scusa se non ho ancora capito niente... vorrą dire che c'abbiamo
provato.
ciao e in bocca al lupo.

 c'abbiamo provato.
nessun problema, ci abbiamo provato cmq mi sei stato d'aiuto ((:
grazie e ciao