Comment supprimer le premier caractère de C-string?

Quelqu'un peut-il m'aider? J'ai besoin de supprimer le premier caractère d'un char * dans C.

Par exemple, char * contents contient un '\n' comme premier caractère dans le tableau. J'ai besoin de détecter et d'éliminer ce personnage, à la modification de la variable d'origine après son été "épurés".

Quelqu'un peut m'aider avec le code? Je suis complètement novice en C, et n'arrive pas à le comprendre.

Pour un débutant, il est très bénéfique pour la lire sur pointer arithmetic. Google le terme, vous obtiendrez de nombreux hits. Cela vous aidera à comprendre ce que les autres sont en train de parler. Par exemple: char* contents_chopped = contents + 1;.

OriginalL'auteur Ash | 2010-11-28

c cstring string

49
```
if (contents[0] == '\n') 
    memmove(contents, contents+1, strlen(contents));
```
Ou, si le pointeur peut être modifié:
```
if (contents[0] == '\n') contents++;
```
+1 me battre pour elle.
ahh, c'est ce que le " mem " fonctions de chaînes de caractères.h au frais. Cette première suggestion fonctionne parfaitement!
et notez que vous devez utiliser memmove, pas memcpy, parce que memmove est nécessaire pour gérer le chevauchement de source/de destination correctement.
Notez également que si vous utilisez ++ version, alors le programme va planter si vous essayez de libérer le incrémenté pointeur. Utiliser @Grigori suggerstion dans ce cas. Aussi, sur de courtes chaînes, memmove pourrait effectuer plus lentement que d'une simple boucle en raison de son coût d'initialisation.

OriginalL'auteur ruslik
20

char* contents_chopped = contents + 1;

Ce résultat contents_chopped pointant vers la même chaîne, à l'exception du premier char sera le prochain après \n

Aussi, cette méthode est plus rapide.

Notez que le pointeur de la validité dépend de la validité de contents, donc c'est bien si vous voulez seulement faire quelques processus rapide sur contents_chopped. Également besoin de vérifier pour la chaîne vide.
+1 pour donner la réponse que tout le monde réel code doit utiliser. Copier/déplacer une chaîne entière juste pour faire usage de sa queue est d'un ridicule perte de temps, mais il y a malheureusement beaucoup de programmes qui en fait faire de telles choses...
J'aime comment il est simple, mais vous ne pouvez pas libérer contents_chopped, car il a besoin que.

OriginalL'auteur

Ne suffit d'incrémenter le pointeur si vous avez malloc avais toute la mémoire ou votre programme plantera. libre a besoin de l'original de pointeur. Vous pouvez copier le pointeur, faites un nouveau bloc de mémoire et memcpy, y accéder comme ptr+1 ou tout un tas d'autres façons, mais les gens qui disent juste incrémenter le pointeur de vous donner dangereux conseils. Vous pouvez exécuter cet exemple de programme et de voir ce qui se passe quand vous "juste incrémenter le pointeur".

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(void)
{
    char *str = (char *)malloc(10);
    strcpy(str, "1234567890");
    printf("%s\n", str);
    str++;
    printf("%s\n", str);
    free(str);
}

Astuce: Voici le résultat:

[mfisch@toaster ~]$ ./foo
1234567890
234567890
*** glibc detected *** ./foo: free(): invalid pointer: 0x08c65009 ***
======= Backtrace: =========
/lib/tls/i686/cmov/libc.so.6(+0x6b591)[0x724591]
/lib/tls/i686/cmov/libc.so.6(+0x6cde8)[0x725de8]
/lib/tls/i686/cmov/libc.so.6(cfree+0x6d)[0x728ecd]
./foo[0x80484e3]
/lib/tls/i686/cmov/libc.so.6(__libc_start_main+0xe6)[0x6cfbd6]
./foo[0x80483f1]
======= Memory map: ========
001c9000-001e4000 r-xp 00000000 08:01 2883609    /lib/ld-2.11.1.so
001e4000-001e5000 r--p 0001a000 08:01 2883609    /lib/ld-2.11.1.so
001e5000-001e6000 rw-p 0001b000 08:01 2883609    /lib/ld-2.11.1.so
006b9000-0080c000 r-xp 00000000 08:01 3015690    /lib/tls/i686/cmov/libc-2.11.1.so
0080c000-0080d000 ---p 00153000 08:01 3015690    /lib/tls/i686/cmov/libc-2.11.1.so
0080d000-0080f000 r--p 00153000 08:01 3015690    /lib/tls/i686/cmov/libc-2.11.1.so
0080f000-00810000 rw-p 00155000 08:01 3015690    /lib/tls/i686/cmov/libc-2.11.1.so
00810000-00813000 rw-p 00000000 00:00 0
00e4d000-00e4e000 r-xp 00000000 00:00 0          [vdso]
00fe0000-00ffd000 r-xp 00000000 08:01 2883667    /lib/libgcc_s.so.1
00ffd000-00ffe000 r--p 0001c000 08:01 2883667    /lib/libgcc_s.so.1
00ffe000-00fff000 rw-p 0001d000 08:01 2883667    /lib/libgcc_s.so.1
08048000-08049000 r-xp 00000000 08:01 9700477    /home/mfisch/foo
08049000-0804a000 r--p 00000000 08:01 9700477    /home/mfisch/foo
0804a000-0804b000 rw-p 00001000 08:01 9700477    /home/mfisch/foo
08c65000-08c86000 rw-p 00000000 00:00 0          [heap]
b7600000-b7621000 rw-p 00000000 00:00 0
b7621000-b7700000 ---p 00000000 00:00 0
b776f000-b7770000 rw-p 00000000 00:00 0
b7780000-b7783000 rw-p 00000000 00:00 0
bfc22000-bfc37000 rw-p 00000000 00:00 0          [stack]
Aborted

Bon point, ce qui se passe pour moi en ce moment depuis que je suis à l'aide de la méthode increment, je suis aussi de voir une erreur similaire à ce que vous montrons ici. Le seul problème avec cette réponse, il n'y a pas de solution de code.

OriginalL'auteur mfisch

3

Il semble que si vous êtes sous l'impression qu'un char* "contient" des personnages. Il ne le fait pas. Il se contente de points à un octet. Le reste de la chaîne est implicite, se composent de l'octet en mémoire jusqu'à la prochaine octet null. (Vous devriez aussi être conscient que, bien que le 'char' type de données est un octet, par définition, il n'est pas vraiment un personnage - s'il vous plaît être conscient de l'Unicode - et ni est un octet nécessairement un octet.)

Le char* n'est pas un tableau, soit, bien qu'il puisse exister un tableau de caractères tels que le pointeur pointe vers le début de ce tableau.

OriginalL'auteur Karl Knechtel

#include <stdio.h>
#include <string.h>
int main ()
{
char src[50] = "123456789123434567678";
char dest[16]={0};
memcpy(dest, src+1,sizeof(src));
printf("%s\n",dest);
return(0);
}
src+1 -> indicate how many char you want to remove

OriginalL'auteur deepak kumar Pranjay

-1

Voici mon code

char  * bastakiniSil(char *contents){
char *p = malloc( sizeof(*p) * strlen(contents) );
int i;
for(i=0; i<strlen(contents); i++)
{
p[i]=contents[i+1];
}
return p;

}

OriginalL'auteur Sam

Vous devez vous connecter pour publier un commentaire.