Comment faire pour supprimer les zéros en tête de chaîne à l'aide de C++?

Je veux supprimer les zéros à gauche de la chaîne "0000000057".

J'ai fait comme ça, mais ne l'a pas obtenir un résultat:

string AccProcPeriNum = strCustData.substr(pos, 13);

string p48Z03 = AccProcPeriNum.substr(3, 10);

Je veux uniquement la sortie 57.

Une idée en C++?

Voulez-vous dire que vous souhaitez supprimer les zéros à gauche?
Vous voulez supprimer pointe zéros, par la manière.
oui .....ma valeur en tant que maintenant 57 il peut être au bout de 3 chiffres ou 4 chiffres je veux o supprimer les zéros à gauche à partir de 10 charatcters chaîne
Pourquoi? Si vous voulez que la valeur, le convertir en entier, avec dire aoti(). Si vous voulez garder comme une chaîne de caractères, il y a sûrement quelque chose de mal, comme les zéros n'était pas par accident. Sûrement, ils font partie de la définition de format ou de taille fixe?

OriginalL'auteur samio peter | 2014-09-08

c++string

19

Piotr S la réponse est bonne, mais il existe un cas, il sera de retour en cas de réponse incorrecte, c'est le zéro tous les cas:

000000000000

Tenir compte de ce, utilisation:
```
str.erase(0, min(str.find_first_not_of('0'), str.size()-1));
```
Même vous str.taille() 0, il fonctionne également.

OriginalL'auteur intijk

#include <string>    

std::string str = "0000000057";
str.erase(0, str.find_first_not_of('0'));

assert(str == "57");

DÉMO

si str = "0", il ne faut pas faire n'importe quoi, mais votre code en fait une chaîne vide

OriginalL'auteur Piotr Skotnicki

2

Bien que c'est probablement pas le plus efficace (en termes de temps d'exécution de la vitesse) façon de faire les choses, je serais tenté de faire quelque chose comme:
```
std::cout << std::stoi(strCustData);
```
C'est simple et facile à utiliser, et donne un raisonnable de sortie (un seul '0') lorsque l'entrée est entièrement constitué de 0s. Seulement quand/si le profilage a montré que cette solution simple a été un problème je considère l'écriture beaucoup plus complexe de code dans l'espoir d'améliorer la vitesse (et je doute que cela entraînerait).

La limite évidente ici, c'est que cela ne suppose que les caractères après les zéros sont des chiffres. C'est clairement vrai dans votre échantillon, mais je suppose qu'il est concevable que vous avez données, où il n'est pas vrai.

Cela suppose également que le nombre résultant est assez petit pour tenir dans une int.
Pourquoi ne pas utiliser std::stoi64, il fit pour les deux 32 (int) et 64 (unsigned int - pas de 64 ans, mais atteint le nombre maximum de 32)

OriginalL'auteur Jerry Coffin

Cela devrait fonctionner comme une fonction générique qui peut être appliqué à n'importe quel std::basic_string types (y compris std::string):

template <typename T_STR, typename T_CHAR>
T_STR remove_leading(T_STR const & str, T_CHAR c)
{
    auto end = str.end();

    for (auto i = str.begin(); i != end; ++i) {
        if (*i != c) {
            return T_STR(i, end);
        }
    }

    //All characters were leading or the string is empty.
    return T_STR();
}

Dans votre cas vous pouvez l'utiliser comme ceci:

string x = "0000000057";
string trimmed = remove_leading(x, '0');

//trimmed is now "57"

(Voir une démo.)

OriginalL'auteur cdhowie

#include<algorithm>
#include<iostream>
#include<string>
using namespace std;


int main()
{
   string s="00000001";
   cout<<s<<endl;
   int a=stoi(s);
   cout<<a;
   //1 is ur ans zeros are removed


}

Alors que ce code peut répondre à la question, en fournissant plus de contexte sur le pourquoi et/ou comment ce code répond à la question améliore sa valeur à long terme.

OriginalL'auteur Mohit Jawale

Ce langage C amicale code supprime les zéros non significatifs et peut être utilisé tant que le char longueur du tableau s'inscrit dans une int:

char charArray[6] = "000342";
int inputLen = 6;

void stripLeadingZeros() {
    int firstNonZeroDigitAt=0, inputLen = strlen(charArray);

    //find location of first non-zero digit, if any
    while(charArray[firstNonZeroDigitAt] == '0')
        firstNonZeroDigitAt++;

    //string has no leading zeros
    if(firstNonZeroDigitAt==0)
        return; 

    //string is all zeros
    if(firstNonZeroDigitAt==inputLen) {
        memset(charArray, 0, sizeof charArray);
        strcpy(charArray, "0");
        inputLen = 1;
        return;
    }

    //shift the non-zero characters down
    for(int j=0; j<inputLen-firstNonZeroDigitAt; j++) {
        charArray[j] = charArray[firstNonZeroDigitAt+j];
    }

    //clear the occupied area and update string length
    memset(charArray+inputLen-firstNonZeroDigitAt, 0, inputLen-firstNonZeroDigitAt+1);
    inputLen -= firstNonZeroDigitAt;
}

OriginalL'auteur Yoga

Vous devez vous connecter pour publier un commentaire.