Supprimer le premier caractère de la chaîne C

Im essayant de supprimer le premier caractère de la chaîne et de garder le reste, mon code ne marche pas, de compiler et d'im confus sur la façon de le résoudre.

Mon code:

char * newStr (char * charBuffer)
{
    int len = strlen(charBuffer);
    int i = 1;
    char v;
    if(charBuffer[0] == 'A' || charBuffer[0] == 'Q'){
        for(i=1;i<len;i++)
            v = v + charBuffer[i];
    }
    v = v + 'char * newStr (char * charBuffer)
{
int len = strlen(charBuffer);
int i = 1;
char v;
if(charBuffer[0] == 'A' || charBuffer[0] == 'Q'){
for(i=1;i<len;i++)
v = v + charBuffer[i];
}
v = v + '\0';
return v;
}
';
    return v;
}

Gcc: "Avertissement: retour rend pointeur d'entier sans un cast"

Aussi: "char * newStr (char * charBuffer)" doit rester le même.

OriginalL'auteur Dacto | 2010-07-28

c char gcc-warning string

Chaînes ne fonctionnent pas comme cela dans C. Vous êtes en additionnant tous les caractères dans la mémoire tampon dans la v variable. Vous ne pouvez pas utiliser + pour concaténer. Le code que vous avez posté, et de graves problèmes qui indiquent qu'il y a une compréhension de l'écart avec l'utilisation de C.

Essayez ceci:

char *newStr (char *charBuffer) { 
int longueur = strlen(charBuffer); 
char *str; 
si (longueur <= 1) { 
str = (char *) malloc(1); 
str[0] = 'char *newStr (char *charBuffer) { 
int longueur = strlen(charBuffer); 
char *str; 
si (longueur <= 1) { 
str = (char *) malloc(1); 
str[0] = '\0'; 
} else { 
str = (char *) malloc(longueur); 
strcpy(str, &charBuffer[1]); 
} 
return str; 
} 
'; 
} else { 
str = (char *) malloc(longueur); 
strcpy(str, &charBuffer[1]); 
} 
return str; 
}

ou ceci:

char *newStr (char *charBuffer) { 
char *str; 
if (strlen(charBuffer) == 0) 
str = charBuffer; 
d'autre 
str = charBuffer + 1; 
return str; 
}

Selon que vous souhaitez allouer une nouvelle chaîne ou pas. Vous devrez aussi ajouter le code de gestion des cas qui ne commence pas par 'Q' ou 'Un'. Je ne comprend pas, parce que je ne suis pas sûr exactement ce que vous essayez de faire ici.

Assurez-vous de faire quelques recherches sur l'allocation et la désallocation de la mémoire avec malloc et free. Ce sont des fonctions fondamentales pour être en mesure d'utiliser si vous allez faire la programmation en C.

OriginalL'auteur Erick Robertson

2

Bien, votre description dit que vous voulez traiter avec des "cordes", mais vous code traite char tampons/pointeurs. L'approche la plus simple pour supprimer le premier caractère de chaînes serait
```
const char *newStr(const char *string)
{
    return string+1;
}
```
mais qui ne regarde pas du tout comme ce que votre code est fait, vous probabaly voulez quelque chose de différent. Par exemple, si vous voulez seulement de supprimer l'un des principaux 'A' ou 'Q' et puis copie la chaîne de caractères dans un tampon, vous voulez quelque chose comme
```
char *newStr(const char *string)
{
    if (string[0] == 'A' || string[0] == 'Q')
        string++;
    return strdup(string);
}
```
OriginalL'auteur Chris Dodd
-1

Vous pouvez simplement déplacer votre pointeur de char d'un caractère dans:
```
char* newstring = oldstring + 1;
```
comme ceci?: charBuffer = charBuffer + 1; return charBuffer;
Je suppose que l'utilisateur erreur de vérifier la nullité des chaînes, etc et de les utiliser à la fois des chaînes de caractères en lecture seule. Si une modification a été effectuée en string, les deux chaînes commencent à devenir instable. Oui Dacto, vous pouvez le faire aussi.

OriginalL'auteur Ian Wetherbee
-1

Votre fonction est déclarée pour retourner un char * et que vous voulez retourner un char.

En outre, pourquoi ne pas simplement retourner un pointeur vers le second caractère?
```
char * newStr (char * charBuffer)
{
   if (charBuffer && (*charBuffer == 'A' || *charBuffer == 'Q')) return charBuffer + 1;
   return charBuffer;
}
```
C'est une mauvaise pratique. Que faire si la chaîne est allouée dynamiquement? Peut-être éventuellement le stockage sera libérée (à partir de la deuxième personnage). La chaîne doit être copié dans un nouveau stockage en premier.
Il peut retourner strdup(charBuffer + 1) si c'est un problème, la solution est la même.
Ceux qui ont été mes pensées exactement. Je suis content que nous avons tous les deux ont commenté sur les différentes réponses, donc ils sont tous corrigés.
C'est exactement la façon dont la chaîne C standard des bibliothèques de travail, strchr, strstr, etc.

OriginalL'auteur Brandon Horsley
-1

Plusieurs des autres réponses recommandé de retourner charBuffer + 1. Comme je l'ai indiqué dans mon commentaire précédent:

C'est une mauvaise pratique. Que faire si la chaîne est allouée dynamiquement? Peut-être éventuellement le stockage sera libérée (à partir de la deuxième personnage). La chaîne doit être copié dans un nouveau stockage en premier.

La libération d'un élément de stockage à partir du milieu va entraîner un comportement indéfini.

Au lieu de cela, essayez de le strdup fonction qui permet de renvoyer une copie de la chaîne.
```
#include <string.h>
#include <stdio.h>

char *newStr(char* charBuffer) {
    if (charBuffer && (charBuffer[0] == 'A' || charBuffer[0] == 'Q'))
        return strdup(charBuffer + 1);
    else 
        return strdup(charBuffer);
}

void main() {
    char a[7] = "Advait";
    char b[5] = "John";
    printf("%s\n",newStr(a));   //Prints "dvait"
    printf("%s\n",newStr(b));   //Prints "John"
}
```
Ne sais pas pourquoi je suis en bas-voté. Les gens ont écrit des fonctions de bibliothèque pour aider simplement les tâches courantes comme les manipulations de chaînes et de copie. En outre, 90% du temps, ces fonctions de la bibliothèque sont plus efficaces et plus robustes que manuel tentatives.
Je suppose que c'est la mem fuite dans votre deux appels à newStr, mais ce serait bien si l'annotation de bas de vote ont été nécessaires - je ne suis pas un fan de la voiture en bas de vote, les feuilles que vous vous demandez si vous avez fait une erreur, ou précisément ce qui est mal.

OriginalL'auteur advait

Vous devez vous connecter pour publier un commentaire.