La fonction de permutation de 2 éléments dans un tableau ne fonctionne pas

Je suis nouveau avec C# et je ne comprends pas pourquoi ce code ne fonctionne pas.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            char[] sw = "ab".ToCharArray();
            swap(sw[0], sw[1]);
            string end = new string(sw);
            Console.Write(end);
        }

        static void swap(char a, char b)
        {
            char temp = a;
            a = b;
            b = temp;
        }
    }
}

Ce que j'attends de la console est "ba", mais j'obtiens un "ab". J'ai été en mesure de trouver autre approche pour résoudre ce problème, mais ce que je voudrais savoir c'est quelle est l'erreur dans ce code.
Merci pour l'aide!

InformationsquelleAutor user2373458 | 2013-05-11

c#swap

11

Le problème est que le swap méthode est en fait que manipuler des copies locales de a et b. Vous devez passer les arguments par référence. Si vous définissez la swap méthode comme ceci:
```
    static void swap(ref char a, ref char b)
    {
        char temp = a;
        a = b;
        b = temp;
    }
```
Et de l'appeler comme ceci:
```
    swap(ref sw[0], ref sw[1]);
```
- C'est probablement la voie à suivre!
- Je suis d'accord c'est probablement la voie à suivre pour le swap, parce que c'est tellement simple. Mais de manière générale, j'essaie d'éviter le mot-clé ref car il a tendance à conduire à messier Api de l'OMI.
- C'est exactement ce que je ferais, mais faire Swap générique de sorte qu'il fonctionne pour tout les tableaux, puis le mettre dans certains utilitaires de la classe.
InformationsquelleAutor James Holderness

Il devrait être modifié comme suit (Note: dans cet exemple, ref char[] arr est préfixé avec ref principalement pour but didactique: tableau sera passé par ref par défaut)

namespace ConsoleApplication1
{

        class Program
        {
            static void Main(string[] args)
            {
                char[] sw = "ab".ToCharArray();
                swap(0, 1, ref sw );
                string end = new string(sw);
                Console.Write(end);
            }

            static void swap(int indexA, int indexB, ref char[] arr)
            {
                char temp = arr[indexA];
                arr[indexA] = arr[indexB];
                arr[indexB] =temp;
            }
        }
    }

InformationsquelleAutor Alexander Bell

1

Votre swap est de prendre deux types de valeur et d'échange des valeurs entre les variables. Il n'y a rien qui permettrait de modifier le tableau d'origine. Vous devez modifier votre méthode d'échange de quelque chose comme:
```
static void Swap(char[] array, int a, int b)
{
    char temp = array[a];
    array[a] = array[b];
    array[b] = temp;
}
```
Vous pouvez ensuite appeler à partir Main() comme:
```
Swap(array, 0, 1);
```
InformationsquelleAutor Justin Niessner

Plus générique de la matrice de fonction de permutation:

    public static void Swap<T>(this T[] array, int indexA, int indexB)
    {
        T temp        = array[indexA];
        array[indexA] = array[indexB];
        array[indexB] = temp;
    }

Aussi, une fonction générique de swap de plusieurs éléments d'un tableau:

    public static void Swap<T>(this T[] array, int indexA, int indexB, int length)
    {
        while (length-- > 0)
            Swap(array, indexA++, indexB++);
    }

InformationsquelleAutor DragonSpit

Vous passez vos arguments a et b en valeur.
Voir Quelle est la différence entre le passage par référence vs passage par valeur? pour plus d'informations.

Voici deux solutions pour résoudre votre problème.

//Pass by value and return the values
static Tuple<char, char> swap2(char a, char b)
{
    char temp = a;
    a = b;
    b = temp;
    return new Tuple<char, char>(a, b);
}

//Pass by reference
static void swap3(ref char a, ref char b)
{
    char temp = a;
    a = b;
    b = temp;
}

public static void Main(string[] args)
{
    char[] sw2 = "ab".ToCharArray();
    var chars2 = swap2(sw2[0], sw2[1]);
    sw2[0] = chars2.Item1;
    sw2[1] = chars2.Item2;
    //Will print "ba"
    Console.WriteLine(sw2);

    char[] sw3 = "ab".ToCharArray();
    swap3(ref sw3[0], ref sw3[1]);
    //Will print "ba"
    Console.WriteLine(sw3);
}

Voici une question sur si vous devez utiliser ou essayer d'éviter le mot-clé ref. En dehors de la plus simple utilise, il est souvent conseillé d'éviter réf lorsque cela est possible. Swap tombe dans la catégorie des "plus simple utilise," mais je suggère que vous essayez d'éviter d'utiliser ref dans la plupart des situations pratiques.

Quand est-ce en utilisant le C# mot-clé ref jamais une bonne idée?

Merci, pensé que C# est-il toujours par ref, le problème est résolu.

InformationsquelleAutor Steven Wexler

Vous devez vous connecter pour publier un commentaire.