Tableau de découpage en c++

Je suis en train de découper les 4 derniers caractères hors d'un tableau de caractères et j'ai essayé la méthode que python utilise sans succès;

char *charone = (char*)("I need the last four")
char *chartwo = charone[-4:]

cout << chartwo << endl;

Je veux que ce code de retour;

four

mais c/c++ ne semble pas être facile...

Où pourrais-je trouver une alternative simple qui va renvoyer les 4 derniers caractères de l'un char tableau dans un autre tableau de char?

Pourquoi avez-vous choisi? Est-ce parce que vous utilisez gcc et il donne un avertissement?
Ouais XP, et quand je n'en ai pas, j'obtiens une erreur de Segmentation d'habitude.
Droit, en C++, les littéraux de chaîne sont const char, donc vous devez utiliser un const char* point à elle. C'est probablement ce que le compilateur vous dit trop.
Ce n' [-4:] veux dire, de quelle langue s'agit-il?
c'est Python découpage, je crois. Cela signifie aller à quatre caractères en arrière dans le tableau et la tranche à la fin.

OriginalL'auteur MetaDark | 2011-02-19

c++

13

Essayer:
```
int len = strlen(charone);
char *chartwo = charone + (len < 4 ? 0 : len - 4);
```
En C++, vous pouvez la remplacer avec:
```
char* chartwo = charone + (std::max)(strlen(charone), 4) - 4;
```
Le code utilise une propriété particulière de chaînes C qui ne fonctionne que pour les hacher éteint le début d'une chaîne.

Votre méthode est plus robuste, mais la mienne est une constante de compilation. 😉 Donc, les avantages et les inconvénients de chacun, je suppose. 🙂
gcc n', j'ai juste couru un test. Les deux versions de générer le même code assembleur sous -O2.
Comme il est courant, c'est juste un exemple. L'OP a déclaré que le code réel fonctionne avec des chaînes dynamiques, auquel cas jmilloy point est valide. C'est généralement une bonne idée de penser au cas général et ne pas être trop à la langue lawyerly sur un comportement indéfini dans des cas spécifiques.
Mieux encore: faire le cas de l'exemple correspondre le cas réel. L'OP n'a même pas il est évident qu'il n'a pas de correspondance dans cet aspect, sauf sur l' (en cours) plus bas voté réponse.
Vous avez été de répondre pour moi et je répond à vous, et...? Je ne vois pas ce que vous avez souligné. Je suis désolé, j'ai raté l'essentiel commentaire enterré sur cette autre réponse.

OriginalL'auteur Jeremiah Willcock
7

Tout d'abord, nous allons supprimer le obsolète conversion:
```
char const *charone = "I need the last four";
```
Tableaux ne sont pas des valeurs de première classe en C++, et ils ne supportent pas de le trancher. Cependant, tout comme le ci-dessus charone est pointe vers le premier élément d'un tableau, vous pouvez pointer vers n'importe quel autre élément. Les pointeurs sont utilisés avec les caractères de faire C-style de cordes: de la pointe-char jusqu'à une valeur null char est le contenu de la chaîne. Parce que les personnages sont à la fin de l'actuelle (charone est) chaîne de caractères, vous pouvez pointer sur le "f":
```
char const *chartwo = charone + 16;
```
Ou, pour gérer la chaîne arbitraire de valeurs:
```
char const *charone = "from this arbitrary string value, I need the last four";
int charone_len = strlen(charone);
assert(charone_len >= 4);  //Or other error-checking.
char const *chartwo = charone + charone_len - 4;
```
Ou, parce que vous êtes à l'aide de C++:
```
std::string one = "from this arbitrary string value, I need the last four";
assert(one.size() >= 4);  //Or other error-checking, since one.size() - 4
//might underflow (size_type is unsigned).
std::string two = one.substr(one.size() - 4);

//To mimic Python's [-4:] meaning "up to the last four":
std::string three = one.substr(one.size() < 4 ? 0 : one.size() - 4);
//E.g. if one == "ab", then three == "ab".
```
En particulier, notez que std::string vous donne distinctes valeurs, de sorte que la modification soit de la chaîne de ne pas modifier les autres, comme il arrive avec les pointeurs.

OriginalL'auteur Fred Nurk
5

C++ et Python sont très différents. C++ ne prend pas en Python-comme la chaîne des installations, mais son Bibliothèque De Modèles Standard a une pratique std::string type, que vous devriez regarder dans.

OriginalL'auteur Nikolai Fetissov
3

Si vous êtes à la recherche pour juste brièvement l'accès des quatre derniers caractères, alors quelque chose comme
```
char* chartwo = charone + (strlen(charone) - 4);
```
sera très bien (en plus de certains de vérification d'erreur).

Mais si vous voulez reproduire la fonctionnalité python, vous aurez besoin de copie les quatre derniers caractères. Encore une fois, utiliser strlen () pour obtenir la longueur (ou le stocker dans un endroit à l'avance), et ensuite utiliser strcpy (ou probablement une meilleure fonction stl qui a la même fonction). quelque chose comme...
```
char chartwo[5];
strcpy(chartwo, charone + strlen(charone) - 4);
```
(Note: Si vous ne copiez pas, alors vous ne pouvez pas libérer charone est jusqu'à ce que vous avez terminé d'utiliser chartwo. Aussi, Si vous ne copiez pas, si vous changez ensuite charone est plus tard, chartwo va changer aussi. Si c'est bon, c'est sûr que, juste à point pour le décalage.)

Bon point sur la copie, cependant n'oubliez pas d'allouer de l'espace pour chartwo. Laisser de côté l' ", 4" (ce qui est une erreur pour la fonction strcpy) comme nous savons que nous sommes de la copie de la valeur null (et faire attention à correctement un zéro à la fin avec strncpy si vous avez besoin de copier à partir du milieu).
merci, écrit ça vite... est-ce mieux?
Mieux, mais chartwo besoin d'une longueur de 5. 🙂

OriginalL'auteur jmilloy
1

Cela fera:
```
char* chartwo = charone + 16;
```
Mes tableaux de char vont être dynamique afin que ce ne sera probablement pas travailler

OriginalL'auteur Chris Jester-Young
1

tableau de découpage en c++:
```
array<char, 13> msg  = {"Hello world!"};
array<char, 6>  part = {"world"};

//this line generates no instructions and does not copy data
//It just tells the compiler how to interpret the bits
array<char, 5>& myslice = *reinterpret_cast<array<char,5>*>(&msg[6]); 

//now they are the same length and we can compare them
if( myslice == part )
   cout<< "huzzah";
```
C'est juste l'un des emamples où le découpage est utile

J'ai fait une petite bibliothèque qui fait ce avec la compilation des limites de contrôles à https://github.com/Erikvv/array-slicing-cpp

Approche intéressante pour de véritables tableaux. Cependant, il nécessite plus de code pour le faire fonctionner pour les chaînes de caractères comme myslice n'est pas nulle terminée. En outre, cette comparaison ne fonctionne pas comme les matrices de tailles différentes. Donc je suis downvoting que ce n'est pas de répondre à la question.

OriginalL'auteur Erik van Velzen

Vous devez vous connecter pour publier un commentaire.