Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Problema con array multidimensionale (credo)
Forum - C/C++ - Problema con array multidimensionale (credo)

Avatar
edo42 (Member)
Pro


Messaggi: 102
Iscritto: 30/07/2009

Segnala al moderatore
Postato alle 20:38
Mercoledì, 07/10/2009
Ho un problema: un un array multidimensionale e devo assegnarli un valore; mi riesco forse a spiegare meglio con la riga di codice in cui ho il problema:
Codice sorgente - presumibilmente Plain Text

  1. temparrayden[indexarray][indexden[indexarray] - 1] += input[indexenumerator];


temparrayden è il mio array multidimensionale; indexden è un array mono di interi in cui devo selezionare l'array che sto modificando. indexarray è il mio indice per selezionare uno tra i vari array e tutti i suoi corrispondenti input è una stringa dove è contenuto l'imput dell'utente, indexenumerator è un indice che mi serve per poter scegliere carattere per carattere la stringa. Quando compilo tutto ok ma quando eseguo g++ su mac mi dice:
unable to read unknown load command 0x80000022 ripetuto una ventina di volte e poi si ferma e segnala una pausa per eccesso di errori su quella linea. Potete risolvere il mio problema grazie.


Se passi a mac da win non sai cosa ti trovi, ma stai sicuro che non tornerai mai indietro
PM Quote
Avatar
NickoMaiden (Normal User)
Pro


Messaggi: 115
Iscritto: 10/06/2009

Segnala al moderatore
Postato alle 21:22
Mercoledì, 07/10/2009
Codice sorgente - presumibilmente Plain Text

  1. temparrayden[indexarray][[b]indexden[indexarray] - 1][/b] += input[indexenumerator];



credo che l'errore sia li.
se gli dai un vettore [indexden[indexarray] - 1] forse va oltre la dimensione massima stabilita nella dichiarazione
cmq posta tutto il codice, magari l'errore è un altro


char segreto[100]={"Abaca da cala da ciaccia"};
for(int i=0;i<100;i++)
  {
  if(segreto[ i ]=='a'||segreto[ i ]=='A')
    {
    segreto[ i ]='u';
    }
  }
cout<<segreto;
system("pause");
return EXIT_SUCCESS;
PM Quote
Avatar
edo42 (Member)
Pro


Messaggi: 102
Iscritto: 30/07/2009

Segnala al moderatore
Postato alle 17:58
Giovedì, 08/10/2009
Il codice che interessa completo è questo:
Codice sorgente - presumibilmente C#

  1. //1.1.4.5 Modificate varie cose tra cui la prima parte di riorganizzazione e conversione agli array multidimensionali
  2.         //Inizializzo variabili e array
  3.         bool riduci = true;
  4.                 //1.1.4.0 Serve per attivare una funzione che corregge un bug matematico
  5.                 //1.1.4.5 variabili globali
  6.         bool numactive = false;
  7.         bool denactive = false;
  8.                 //variabili ed array riferiti a una singola parentesi
  9.                 //operatori
  10.                 string tempoperator [20][50];
  11.                 int indexoperator [20];
  12.                 for(int f = 0; f < 20; f++) indexoperator[f] = 0;
  13.                 //numeratori
  14.         string temparraynum [20][100];
  15.                 int indexnum[20];
  16.                 for(int f = 0; f < 20; f++) indexnum[f] = 0;
  17.                 //denominatori
  18.         string temparrayden [20][100];
  19.                 int indexden[20];
  20.                 for(int f = 0; f < 20; f++) indexnum[f] = 0;
  21.                 //1.1.4.5 Aggiunto indice per chiamare uno degli array qui sopra
  22.                 int indexarray = 0;
  23.                 //1.1.4.5 Aggiunto array per identificare gli array da risolvere per primi
  24.                 int firstarray [20];
  25.                 for(int f = 0; f < 20; f++) firstarray[f] = 0;
  26.                 // Scrivo l'altro messaggio console
  27.         cout << "Inserire l'espressione (è necessario scrivere le frazioni in questo modo: es. 1|2) e premere invio, oppure scrivere fine per chiudere il programma." << endl;
  28.         string input;
  29.                 cin >> input;
  30.                 //1.1.4.5 For debug only
  31.                 if(input == "t")
  32.                 {
  33.                         input = "13|3-{2|3+[(4|3-1|5-12|5)*3|4*(5|4-1|2-1|12)]*(7|5+2|1)}*5|37";
  34.                 }
  35.                 if(input == "fine")
  36.                 {
  37.                         return 1;
  38.                 }
  39.         // Divido caratteri e elaboro gli elaboro per individuare i numeratore, i denominatori, gli operatore e (1.1.3.0) le parentesi
  40.         for (int indexenumerator = 0; indexenumerator < input.size(); indexenumerator++)
  41.         {
  42.                 switch (input[indexenumerator])
  43.                 {
  44.                         // Se il carattere corrente è un numero...
  45.                                 case '1':
  46.                                 case '2':
  47.                                 case '3':
  48.                                 case '4':
  49.                                 case '5':
  50.                                 case '6':
  51.                                 case '7':
  52.                                 case '8':
  53.                                 case '9':
  54.                                 case '0':
  55.                         {
  56.                                         // individuo di che cosa fa parte il numero
  57.                                         if (numactive == true && denactive == false)
  58.                                         {
  59.                                                 //1.1.4.5 Usato += e migliorato codice
  60.                                                 // se è un numeratore lo inserisco nell'array dei numeratori
  61.                                                 --indexnum[indexarray];
  62.                                                 temparraynum[indexarray][indexnum[indexarray]] += input[indexenumerator];
  63.                                                 ++indexnum[indexarray];
  64.                                         }
  65.                                         else if (numactive == false && denactive == false)
  66.                                         {
  67.                                                 // se è il primo numero letto è sicuramente un numeratore per cui lo metto nell'array dei numeratori
  68.                                                 temparraynum[indexarray][indexnum[indexarray]++] = input[indexenumerator];
  69.                                                 numactive = true;
  70.                                         }
  71.                                         else if (numactive == false && denactive == true)
  72.                                         {
  73.                                                 // se c'è appena stata una linea di frazione, questa cifra è sicuramente il denominatore
  74.                                                 // 1.1.4.0 Migliorato codice
  75.                                                 temparrayden[indexarray][indexden[indexarray] - 1] += input[indexenumerator];
  76.                                                 denactive = true;
  77.                                         }
  78.                                         break;
  79.                         }
  80.                         case '|':
  81.                         {
  82.                                 // se trovo una linea di frazione predispongo le variabili in modo che il prossimo numero si riconosciuto come un denominatore
  83.                                 numactive = false;
  84.                                 denactive = true;
  85.                                 indexden[indexarray]++;
  86.                                 break;
  87.                         }
  88.                         case '+':
  89.                         {
  90.                                 // se trovo un + vorrà dire che questa operazione sarà un addizione
  91.                                 tempoperator[indexoperator[indexarray]++][indexarray] = "+";
  92.                                 denactive = false;
  93.                                 numactive = false;
  94.                                 riduci = false;
  95.                                 break;
  96.                         }
  97.                         case '-':
  98.                         {
  99.                                 // se trovo un - vorrà dire che questa operazione sarà un sottrazione
  100.                                 tempoperator[indexoperator[indexarray]++][indexarray] = "-";
  101.                                 denactive = false;
  102.                                 numactive = false;
  103.                                 riduci = false;
  104.                                 break;
  105.                         }
  106.                         case '*':
  107.                         {
  108.                                 // se trovo un * vorrà dire che questa operazione sarà un moltiplicazione
  109.                                 tempoperator[indexoperator[indexarray]++][indexarray] = "*";
  110.                                 denactive = false;
  111.                                 numactive = false;
  112.                                 riduci = false;
  113.                                 break;
  114.                         }
  115.                         case '/':
  116.                         {
  117.                                 // se trovo un / vorrà dire che questa operazione sarà un divisione
  118.                                 tempoperator[indexoperator[indexarray]++][indexarray] = "/";
  119.                                 denactive = false;
  120.                                 numactive = false;
  121.                                 riduci = false;
  122.                                 break;
  123.                         }
  124.                         case '(':
  125.                         {
  126.                                         //1.1.4.5 inserisco nell'arraynum corrente x + il numero dell'array seguente
  127.                                         temparraynum[indexnum[indexarray++]++][indexarray] = ("x"+Tostring(indexarray+1));
  128.                                         firstarray[indexarray] = 3;
  129.                                 break;
  130.                         }
  131.                         case ')':
  132.                         {
  133.                                         //1.1.4.5 qui diminuisco l'indice in modo da
  134.                                 indexarray--;
  135.                                 break;
  136.                         }
  137.                                 case '[':
  138.                         {
  139.                                         //1.1.4.5 inserisco nell'arraynum corrente x + il numero dell'array seguente
  140.                                         temparraynum[indexnum[indexarray++]++][indexarray] = ("x"+Tostring(indexarray+1));
  141.                                         firstarray[indexarray] = 2;
  142.                                 break;
  143.                         }
  144.                         case ']':
  145.                         {
  146.                                         //1.1.4.5 qui diminuisco l'indice in modo da
  147.                                 indexarray--;
  148.                                 break;
  149.                         }
  150.                                 case '{':
  151.                         {
  152.                                         //1.1.4.5 inserisco nell'arraynum corrente x + il numero dell'array seguente
  153.                                         temparraynum[indexnum[indexarray++]++][indexarray] = ("x"+Tostring(indexarray+1));
  154.                                         firstarray[indexarray] = 1;
  155.                                 break;
  156.                         }
  157.                         case '}':
  158.                         {
  159.                                         //1.1.4.5 qui diminuisco l'indice in modo da
  160.                                 indexarray--;
  161.                                 break;
  162.                         }
  163.                                        
  164.                 }
  165.         }


E' un po' lungo spero che ci capiate e che ci stia...


Se passi a mac da win non sai cosa ti trovi, ma stai sicuro che non tornerai mai indietro
PM Quote