Retour des tableaux

Question

main()  
{  
    .... 

    i = index;     
    while (i < j)  
    {  
    if (ip[i] == "/")  
     {  
     ip[i - 1] = (double.Parse(ip[i - 1])/double.Parse(ip[i + 1])).ToString(); 

     for (int k = i; k < (ip.Length - 2); k++) 
     { 
      ip[k] = ip[k + 2]; 
     } 

     Array.Resize(ref ip, ip.Length - 2);  
     j = j - 2;  
     i--;  
     }  
    i++;  
    }  
} 

Pour le code ci-dessus, je voulais appliquer les concepts d'Oop.

Ce motif se répète presque 5 fois (pour div, mul, add, sub, pow) dans le programme principal, avec quatre lignes identiques.

Pour diminuer le nombre de lignes et là pour augmenter l'efficacité du code, j'ai écrit la même chose comme ça.

i = index; 

while (i < j) 

    {  
    if (ip[i] == "/")  
    {  
     ip[i - 1] = (double.Parse(ip[i - 1])/double.Parse(ip[i + 1])).ToString();  

     ext.Resize(ip, i, j); 
    }  
    i++;  
    } 


class ext 
{ 
    public static void Resize(string [] ip, int i, int j)  
    { 

     for (int k = i; k < (ip.Length - 2); k++) { ip[k] = ip[k + 2]; }  
     Array.Resize(ref ip, ip.Length - 2);  
     j=j-2; i--;  
     return ;  
    }  
} 

Le code a été compilé avec succès. Mais le problème est que les changements dans le tableau et les variables qui ont eu lieu dans la fonction appelée ne sont pas reflétés dans le programme principal. Le tableau et les variables restent inchangés dans le programme principal. Je ne suis pas capable de comprendre où je me suis trompé. Plz guide moi.

Merci.

Answer 1

Je ne pense pas que vous comprenez ce que ref paramètres sont pour - une fois que vous comprenez les (et le fait que les tableaux ne peuvent se changer en taille), vous verrez pourquoi Array.Resize prend un paramètre ref. Jetez un oeil à mon parameter passing article pour plus de détails.

Vous pouvez corriger votre code en changeant comme ceci:

public static void Resize(ref string [] ip, ref int i)  
{ 
    for (int k = i; k < (ip.Length - 2); k++) 
    { 
     ip[k] = ip[k + 2]; 
    }  
    Array.Resize(ref ip, ip.Length - 2);  
    j = j - 2; 
    i--; 
} 

et de l'appeler comme ceci:

ext.Resize(ref ip, ref i); 

Cependant, je pense que l'utilisation d'une structure de données plus appropriée serait votre code plus clair. Y at-il une raison pour laquelle vous ne pouvez pas utiliser un List<string> à la place?

Answer 2

Vous supprimez des éléments au milieu d'une séquence, réduisant ainsi sa longueur. Donc, en utilisant des tableaux rend juste difficile.

Si ip était un List<string> au lieu de string[]:

i = index;     
while (i < j)  
{  
    if (ip[i] == "/")  
    {  
     ip[i - 1] = (double.Parse(ip[i - 1])/double.Parse(ip[i + 1])).ToString(); 

     ip.RemoveAt(i); 
     ip.RemoveAt(i); 
     j = j - 2;  
     i--;  
    }  
    i++;  
} 

On dirait que vous êtes l'analyse d'une expression arithmétique. Cependant, vous pourriez vouloir autoriser les parenthèses à contrôler l'ordre d'évaluation, et cela va être difficile avec cette structure.

Mise à jour: Ce que votre code dit est: Vous allez scanner une séquence de chaînes. Partout dans cette séquence, vous pouvez trouver un symbole d'opérateur de division: /. Si oui, vous supposez que les choses de chaque côté peuvent être analysées avec double.Parse. Mais:

(5 + 4)/(6 - 2) 

Les jetons de chaque côté du / dans cet exemple sont ) et ( donc double.Parse ne va pas travailler.

Donc, je vérifie juste que vous avez une autre couche de logique en dehors de ce qui concerne les parenthèses. Par exemple, vous utilisez peut-être d'abord une descente récursive, puis vous exécutez uniquement le morceau de code que vous avez publié sur des séquences qui ne contiennent aucune parenthèse.

Si vous voulez la chose à être plus « objecty », vous pouvez traiter le problème comme l'un de transformer une séquence de jetons dans un arbre. Chaque noeud de l'arbre peut être évalué. La valeur du noeud racine est la valeur de l'expression entière. Un nombre est un nœud très simple qui évalue la valeur du nombre lui-même. Un opérateur a deux nœuds enfants. Les groupes de parenthèses disparaîtraient simplement de l'arbre - ils sont utilisés pour guider la façon dont vous le construisez. Si j'ai un peu de temps, je pourrais développer cela en un court exemple.

Et une autre question: comment allez-vous diviser la chaîne entière en jetons?