web-dev-qa-db-fra.com

comment convertir int en char *?

Le seul moyen que je connaisse est:

#include <sstream>
#include <string.h>
using namespace std;

int main() {
  int number=33;
  stringstream strs;
  strs << number;
  string temp_str = strs.str();
  char* char_type = (char*) temp_str.c_str();
}

Mais y a-t-il une méthode avec moins de dactylographie?

c++integerconst-char
85
rsk82

  • En C++ 17, utilisez std::to_chars as:

    std::array<char, 10> str;
std::to_chars(str.data(), str.data() + str.size(), 42);

  • En C++ 11, utilisez std::to_string as:

    std::string s = std::to_string(number);
char const *pchar = s.c_str();  //use char const* as target type

  • Et en C++ 03, ce que vous faites est bien, sauf que vous utilisez const comme

    char const* pchar = temp_str.c_str(); //dont use cast
108
Nawaz

Vous pouvez utiliser boost

#include <boost/lexical_cast.hpp>
string s = boost::lexical_cast<string>( number );
8
maverik

Je pense que vous pouvez utiliser un sprintf:

int number = 33;
char* numberstring[(((sizeof number) * CHAR_BIT) + 2)/3 + 2];
sprintf(numberstring, "%d", number);
8
Pierre Pellegrino Milza

La solution de style C pourrait consister à utiliser itoa , mais le meilleur moyen consiste à imprimer ce nombre dans une chaîne à l'aide de sprintfsnprintf . Vérifiez cette question: Comment convertir un entier en chaîne de manière portable?

Notez que itoa function _/n'est pas défini dans ANSI-C et ne fait pas partie de C++, mais est pris en charge par certains compilateurs. C'est une fonction non standard, vous devriez donc éviter de l'utiliser. Vérifiez également cette question: Alternative à itoa () pour convertir un entier en chaîne C++?

Notez également que l'écriture de code de style C lors de la programmation en C++ est considérée comme une mauvaise pratique et est parfois appelée "style abominable". Voulez-vous vraiment le convertir en chaîne char* de style C? :)

5
LihO

Je ne voudrais pas typstart loin le const dans la dernière ligne car il est là pour une raison. Si vous ne pouvez pas vivre avec un caractère constant *, vous feriez bien de copier le tableau comme suit:

char* char_type = new char[temp_str.length()];
strcpy(char_type, temp_str.c_str());
5
user331471

Vous pouvez également utiliser le casting.

Exemple:

string s;
int value = 3;
s.Push_back((char)('0' + value));
1
elmaystro

C’est peut-être un peu tard, mais j’avais également le même problème… .. La conversion en caractères était traitée en C++ 17 avec la bibliothèque "charconv".

https://en.cppreference.com/w/cpp/utility/to_chars

1
AKJ

Voir cette réponse https://stackoverflow.com/a/23010605/2760919

Dans votre cas, changez simplement le type dans snprintf de long ("% ld") à int ("% n").

1
bonnyz

D'accord .. d'abord j'avais besoin de quelque chose qui a fait ce que cette question demande, mais j'en avais besoin RAPIDE! Malheureusement, le "meilleur" moyen est près de 600 lignes de code !!! Pardonnez le nom de cela qui n'a rien à voir avec ce qu'il fait. Le nom propre était Integer64ToCharArray (valeur int64_t);

https://github.com/JeremyDX/All-Language-Testing-Code/blob/master/C%2B%2B%20Examples/IntegerToCharArrayTesting.cpp

N'hésitez pas à essayer de nettoyer ce code sans nuire aux performances.

Entrée: Toute valeur signée de 64 bits comprise entre la plage min et la plage max.

Exemple:

std::cout << "Test: " << AddDynamicallyToBuffer(LLONG_MAX) << '\n';
std::cout << "Test: " << AddDynamicallyToBuffer(LLONG_MIN) << '\n';

Sortie:

Test: 9223372036854775807
Test: -9223372036854775808

Tests de vitesse d'origine: (Integer64ToCharArray ();)

Meilleur cas 1 valeur numérique.

Boucles: 100 000 000, Temps passé sur une boucle: 1381 (Milli), Temps par boucle 13 (Nano)

Pire cas, valeur à 20 chiffres.

Boucles: 100 000 000, Temps passé sur une boucle: 22 656 (Milli), Temps par boucle 226 (Nano

Nouveaux tests de vitesse de conception: (AddDynamicallyToBuffer ();)

Meilleur cas 1 valeur numérique.

Boucles: 100 000 000, Temps passé sur une boucle: 427 (Milli), Time Per Loop 4 (Nano)

Le plus mauvais cas sur 32 bits - Valeur à 11 chiffres.

Boucles: 100 000 000, Temps passé sur les boucles: 1 991 (Milli), Temps par boucle 19 (Nano)

Négatif 1 billion de dollars le pire des cas - Valeur à 14 chiffres.

Boucles: 100 000 000, Temps passé sur une machine: 5 681 (Milli), Temps par boucle 56 (Nano)

Pire cas de 64 bits - Valeur à 20 chiffres.

Boucles: 100 000 000, Temps passé sur les machines: 13 148 (Milli), Temps par boucle 131 (Nano)

Comment ça marche!

Nous effectuons une technique de division et de conquête et une fois que nous avons maintenant la longueur maximale de la chaîne, nous définissons simplement chaque valeur de caractère individuellement. Comme indiqué dans les tests de vitesse ci-dessus, les longueurs plus longues entraînent de lourdes pénalités de performances, mais elles sont encore bien plus rapides que la méthode de boucle d'origine et qu'aucun code n'a réellement changé entre les deux méthodes, à l'exception du bouclage qui n'est plus utilisé.

Dans mon utilisation, d'où le nom, je retourne l'offset à la place et je n'édite pas de tampon de tableaux de caractères, mais je commence à mettre à jour les données de sommet et la fonction a un paramètre supplémentaire pour l'offset afin qu'il ne soit pas initialisé à -1.

0
Jeremy Trifilo