Comment puis-je convertir un Int en une Chaîne de caractères en C# sans l'aide de ToString()?

C'est la solution que j'ai toujours utiliser:

    public static string numberBaseChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    public static string IntToStringWithBase(int n, int b) {
        return IntToStringWithBase(n, b, 1);
    }

    public static string IntToStringWithBase(int n, int b, int minDigits) {
        if (minDigits < 1) minDigits = 1;
        if (n == 0) return new string('0', minDigits);
        string s = "";
        if ((b < 2) || (b > numberBaseChars.Length)) return s;
        bool neg = false;
        if ((b == 10) && (n < 0)) { neg = true; n = -n; }
        uint N = (uint)n;
        uint B = (uint)b;
        while ((N > 0) | (minDigits-- > 0)) {
            s = numberBaseChars[(int)(N % B)] + s;
            N /= B;
        }
        if (neg) s = "-" + s;
        return s;
    }

Cela semble assez compliqué mais a les caractéristiques suivantes:

• Prend en charge radix 2 à 36
• Poignées de valeurs négatives
• Facultatif nombre total de chiffres

L'entier est traitée à partir de la du chiffre le moins significatif le plus significatif. Un seul chiffre est calculé utilisé modulo 10 (%10) qui est ensuite ajoutée à la valeur du caractère de '0'. Il en résulte l'un des personnages '0', '1', ... , '9'.

Les chiffres sont poussés dans une pile, car ils doivent être présentés dans l'ordre inverse qu'ils sont traités (la plus importante du chiffre le chiffre le moins significatif). Le faire comme ceci au lieu de cela, à plusieurs reprises, ajoutant les chiffres d'une chaîne de caractères peut être plus efficace, mais parce que le nombre de chiffres est assez faible, vous devez effectuer un test pour en être sûr.

Traitement supplémentaire est nécessaire pour gérer la non-positif numéros.

public string IntToString(int a) {
  if (a == 0)
    return "0";
  if (a == int.MinValue)
    return "-2147483648";
  var isNegative = false;
  if (a < 0) {
    a = -a;
    isNegative = true;
  }
  var stack = new Stack<char>();
  while (a != 0) {
    var c = a%10 + '0';
    stack.Push((char) c);
    a /= 10;
  }
  if (isNegative)
    stack.Push('-');
  return new string(stack.ToArray());
}

Ma première version utilisé un StringBuilder pour créer la chaîne à partir du tableau de caractères de la chaîne "de la" StringBuilder nécessite un appel à la méthode nommée ToString. Évidemment, cette méthode ne permet pas de faire tout l'int de conversion de chaîne de caractères qui pour moi, est ce que cette question est à propos.

Mais pour prouver que vous pouvez créer une chaîne sans appel ToString je suis passé à l'aide d'un string constructeur qui je voudrais également assumer d'être plus efficace par rapport à l'aide d'un StringBuilder.

Et si ToString dans toutes ses formes, est interdite, vous ne pouvez pas utiliser la concaténation de chaîne comme on le voit dans la documentation de string.Concat:

La méthode concatène arg0 et arg1by sans paramètre de l'appel de la méthode ToString de arg0 et arg1; il n'ajoute pas les délimiteurs.

afin d'exécution s += '1' appellera '1'.ToString(). Mais pour moi, ce n'est pas important. L'important, c'est comment vous convertir un int en une chaîne de caractères.

Voici mon prend sur elle à l'aide de l'itération et de la récursivité avec des temps d'exécution de l'analyse.

public static class IntegerToString
{
    static char[] d = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();

    public static string Iteration(int num, int radix = 10)
    {
        if (num == 0) return "0";
        if (num < 0) return "-" + Iteration(Math.Abs(num));
        var r = new List<char>();
        while (num > 0)
        {
            r.Insert(0, d[num % radix]);
            num /= radix;
        }
        return new string(r.ToArray());
    }

    public static string Recursion(int num, int radix = 10)
    {
        if (num == 0) return "0";
        if (num < 0) return "-" + Recursion(Math.Abs(num));
        return (num > radix - 1 ? Recursion(num / radix) : "") + d[num % radix];
    }
}

Points Clés

• Gère la base de 2 à 36 (mise en garde: vous devrez vous assurer que votre base est correcte, car il n'y a pas de gestion d'exception.
• La récursivité méthode est à seulement 3 lignes de long! (code de golf de style)

Analyse

La suivante est l'analyse de l'exécution des deux méthodes par rapport à la norme ToString() sur mon ordinateur.

50 runs of 100000 items per set

Running Time:
Iteration: 00:00:02.3459591 (00:00:00.0469191 avg)
Recursion: 00:00:02.1359731 (00:00:00.0427194 avg)
Standard : 00:00:00.4271253 (00:00:00.0085425 avg)

Ratios:
     | Iter | Rec  | Std
-----+------+------+-----
Iter | 1.00 | 0.91 | 0.18
Rec  | 1.10 | 1.00 | 0.20
Std  | 5.49 | 5.00 | 1.00

Les résultats indiquent l'itération et la récursivité des méthodes d'exécuter 5,49 et 5.00 fois plus lente que la norme ToString() méthode.

Et voici le code que j'ai utilisé pour l'analyse:

class Program
{
static void Main(string[] args)
{
var r = new Random();
var sw = new System.Diagnostics.Stopwatch();
var loop = new List<long>();
var recr = new List<long>();
var std = new List<long>();
var setSize = 100000;
var runs = 50;
Console.WriteLine("{0} runs of {1} items per set", runs, setSize);
for (int j = 0; j < runs; j++)
{
//create number set
var numbers = Enumerable.Range(1, setSize)
.Select(s => r.Next(int.MinValue,
int.MaxValue))
.ToArray();
//loop
sw.Start();
for (int i = 0; i < setSize; i++)
IntegerToString.Iteration(numbers[i]);
sw.Stop();
loop.Add(sw.ElapsedTicks);
//recursion
sw.Reset();
sw.Start();
for (int i = 0; i < setSize; i++)
IntegerToString.Recursion(numbers[i]);
sw.Stop();
recr.Add(sw.ElapsedTicks);
//standard
sw.Reset();
sw.Start();
for (int i = 0; i < setSize; i++)
numbers[i].ToString();
sw.Stop();
std.Add(sw.ElapsedTicks);
}
Console.WriteLine();
Console.WriteLine("Running Time:");
Console.WriteLine("Iteration: {0} ({1} avg)", 
TimeSpan.FromTicks(loop.Sum()),
TimeSpan.FromTicks((int)loop.Average()));
Console.WriteLine("Recursion: {0} ({1} avg)", 
TimeSpan.FromTicks(recr.Sum()),
TimeSpan.FromTicks((int)recr.Average()));
Console.WriteLine("Standard : {0} ({1} avg)", 
TimeSpan.FromTicks(std.Sum()),
TimeSpan.FromTicks((int)std.Average()));
double lSum = loop.Sum();
double rSum = recr.Sum();
double sSum = std.Sum();
Console.WriteLine();
Console.WriteLine("Ratios: \n" +
"     | Iter | Rec  | Std \n" +
"-----+------+------+-----");
foreach (var div in new[] { new {n = "Iter", t = lSum}, 
new {n = "Rec ", t = rSum},
new {n = "Std ", t = sSum}})
Console.WriteLine("{0} | {1:0.00} | {2:0.00} | {3:0.00}", 
div.n, lSum / div.t, rSum / div.t, sSum / div.t);
Console.ReadLine();
}

    public static string integerToString(int integerPassedIn)
{
if (integerPassedIn == 0) return "0";
var negative = integerPassedIn < 0;
var res = new List<char>();
while(integerPassedIn != 0)
{
res.Add((char)(48 + Math.Abs(integerPassedIn % 10)));
integerPassedIn /= 10;
}
res.Reverse();
if (negative) res.Insert(0, '-');
return new string(res.ToArray());
}

Si c'est le c++, alors:

public string IntToString(int a){    
char rc[20];
int x = a;
if(a < 0) x = -x;
char *p = rc + 19;
*p = 0;
do 
*--p = (x % 10) | '0';
while(x /= 10);
if(a < 0) *--p = '-';
return string(p);
}