La bonne façon de copier des C-strings

Est-il un moyen facile de copier des C-strings?

J'ai const char *stringA, et je veux char *stringB de prendre la valeur (note que stringB n'est pas const). J'ai essayé stringB=(char*) stringA, mais qui fait stringB pointent toujours vers le même emplacement de mémoire, de sorte que lorsque stringA modifications ultérieures, stringB ne trop.

J'ai aussi essayé de strcpy(stringB,stringA), mais il me semble que si stringB n'était pas initialisé à un assez grand tableau, il y a une erreur de segmentation. Je ne suis pas super expérimenté avec C-strings bien, suis-je raté quelque chose d'évident? Si je viens d'initialiser stringB comme char *stringB[23], parce que je sais que je ne serai jamais une chaîne de plus de 22 personnages (et en permettant le terminateur null), est-ce le bon chemin? Si stringB est vérifiée pour l'égalité avec les autres C-strings, l'espace supplémentaire affecte en rien?

(et seulement à l'aide de cordes n'est pas une solution, car j'ai besoin d'un minimum de frais généraux et d'un accès facile à des caractères individuels)

Re: "et juste à l'aide de cordes n'est pas une solution, car j'ai besoin d'un minimum de frais généraux et d'un accès facile à des caractères individuels": je soupçonne fortement que vous êtes en train de surestimer les frais généraux, et vous êtes certainement en train de surestimer les difficultés d'accès aux caractères individuels: c = s[10] et s[10] = c à la fois le travail tout aussi bien si s est un std::string que si c'est une char*.
Veuillez formater votre question. Vous pouvez utiliser des backticks pour désigner code en ligne et retrait en quatre espaces d'avoir des blocs de code.
Utilisation std::string sauf si vous avez une autre raison que celle qui ne pas.
std::string est la solution. Vous êtes travaillant sous la fausse idée qu'il sera plus cher.
Désolé pour la mise en forme; je n'arrivais pas à comprendre ce que backticks (apostrophes ne semblent pas faire quoi que ce soit).

OriginalL'auteur akroy | 2012-03-06

c++copy cstring string

15

Vous pouvez utiliser strdup() de retourner une copie d'un C-string, comme dans:
```
#include <string.h>

const char *stringA = "foo";
char *stringB = NULL;

stringB = strdup(stringA);
/* ... */
free(stringB);    
```
Vous pouvez également utiliser strcpy(), mais vous avez besoin d'allouer de l'espace tout d'abord, ce qui n'est pas dur à faire, mais peut conduire à une erreur de dépassement de capacité, si ne pas fait correctement:
```
#include <string.h>

const char *stringA = "foo";
char *stringB = NULL;

/* you must add one to cover the byte needed for the terminating null character */
stringB = (char *) malloc( strlen(stringA) + 1 ); 
strcpy( stringB, stringA );
/* ... */
free(stringB);
```
Si vous ne pouvez pas utiliser strdup(), je vous recommande l'utilisation de strncpy() au lieu de strcpy(). Le strncpy() fonction copie jusqu'à et seulement jusqu'à n octets, ce qui permet d'éviter les erreurs de dépassement. Si strlen(stringA) + 1 > n, cependant, vous avez besoin de mettre fin stringB, vous-même. Mais, généralement, vous saurez quelles sont les tailles dont vous avez besoin pour les choses:
```
#include <string.h>

const char *stringA = "foo";
char *stringB = NULL;

/* you must add one to cover the byte needed for the terminating null character */
stringB = (char *) malloc( strlen(stringA) + 1 ); 
strncpy( stringB, stringA, strlen(stringA) + 1 );
/* ... */
free(stringB);
```
Je pense que strdup() est plus propre, moi-même, j'ai donc essayer de l'utiliser là où le travail avec les chaînes exclusivement. Je ne sais pas si il y a de graves inconvénients pour la POSIX/non-POSIX approche, en terme de performance, mais je ne suis pas un C ou C++ expert.

Remarque que j'ai jeté le résultat de malloc() à char *. C'est parce que votre question est étiqueté comme une c++ question. En C++, il est nécessaire de jeter le résultat de malloc(). En C, cependant, vous pas cast.

MODIFIER

Là vous allez, il y a une complication: strdup() n'est pas en C ou C++. Donc, utiliser strcpy() ou strncp() avec un tableau de taille ou un malloc-ed pointeur. C'est une bonne habitude d'utiliser strncp() au lieu de strcpy(), partout où vous pourriez utiliser cette fonction. Il permettra de réduire la possibilité d'erreurs.

strdup est dans POSIX, pas du C et C++.
strdup() est à peine plus qu'un wrapper pour strlen(), malloc, et memset. Je dis, si vous faites cela comme un exercice d'apprentissage, l'utilisation strlen() et memset de sorte que vous pouvez apprendre comment les choses fonctionnent dans la peur, puissant monde de l'édition directe de la mémoire 🙂
Non, ne pas utiliser strncpy au lieu de strcpy. strncpy a été créé pour l'insertion des chaînes dans d'autres chaînes. Ainsi, il n'est pas null mettre fin à la chaîne. C'est la négociation d'un problème pour un autre de même ampleur.

OriginalL'auteur Alex Reynolds

Si je viens d'initialiser stringB comme char *stringB[23], parce que je sais que je ne serai jamais une chaîne de plus de 22 caractères (et permettant le terminateur null), est-ce le bon chemin?

Presque. En C, si vous savez à coup sûr que la chaîne ne sera jamais trop longtemps:

char stringB[MAX+1];
assert(strlen(stringA) <= MAX));
strcpy(stringB, stringA);

ou, s'il y a une possibilité que la chaîne peut être trop long:

char stringB[MAX+1];
strncpy(stringB, stringA, MAX+1);
if (stringB[MAX] != 'char stringB[MAX+1];
strncpy(stringB, stringA, MAX+1);
if (stringB[MAX] != '\0') {
//ERROR: stringA was too long.
stringB[MAX] = '\0'; //if you want to use the truncated string
}
') {
    //ERROR: stringA was too long.
    stringB[MAX] = 'char stringB[MAX+1];
strncpy(stringB, stringA, MAX+1);
if (stringB[MAX] != '\0') {
//ERROR: stringA was too long.
stringB[MAX] = '\0'; //if you want to use the truncated string
}
'; //if you want to use the truncated string
}

En C++, vous devez utiliser std::string, sauf si vous l'avez prouvé que la surcharge est prohibitif. De nombreuses implémentations ont un "court optimisation de la chaîne", ce qui permettra d'éviter l'allocation dynamique de chaînes courtes; dans ce cas, il y aura peu ou pas de frais généraux sur l'aide d'un C-gamme de style. L'accès aux caractères individuels est tout aussi pratique que d'un C-gamme de style; dans les deux cas, s[i] donne le caractère à la position i comme un lvalue. La copie devient stringB = stringA; aucun risque de comportement indéfini.

Si vraiment vous trouvez que std::string est inutilisable, envisager std::array<char,MAX+1>: un copiable classe contenant un tableau de taille fixe.

Si stringB est vérifiée pour l'égalité avec les autres C-strings, l'espace supplémentaire affecte en rien?

Si vous utilisez strcmp, puis il s'arrêtera à la fin de la plus courte chaîne, et ne sera pas affecté par l'espace supplémentaire.

OriginalL'auteur Mike Seymour

Si vous voulez le faire dans le plus pur style C que:

char* new_string = strdup(old_string);
free(new_string);

Si vous voulez le faire (genre de) C++ style:

char* new_string = new char[strlen(old_string) + 1];
strcpy(new_string,old_string);
delete[] new_string;

OriginalL'auteur sirgeorge

0

Vous êtes probablement à la recherche pour strncpy, qui vous permet de copier la première n caractères d'une chaîne. Assurez-vous simplement d'ajouter de la valeur null-terminator à la position n du copié-string.

OriginalL'auteur Ken Wayne VanderLinde

Vous devez vous connecter pour publier un commentaire.