C101 - cordes vs charbon:

Question

AFunc change ce qui a été envoyé à lui, et les sorties printf() les modifications:

void AFunc (char *myStr, int *myNum) 
{ 
    *myStr = 's'; 
    *myNum = 9; 
} 


int main (int argc, char *argv[]) 
{ 
    char someString = 'm'; 
    int n = 6; 

    AFunc(&someString, &n); 

    printf("%c" "%d", someString, n); 
} 

Mais si la chaîne était plus d'un omble chevalier? En quoi le code serait-il différent? Merci pour toute aide.

Answer 1

Si elle était une « chaîne » au lieu d'un char, vous feriez quelque chose comme ceci:

#include <stdio.h> 

void AFunc (char *myStr, int *myNum) { 
    myStr[0] = 'p'; // or replace the lot with strcpy(myStr, "pax"); 
    myStr[1] = 'a'; 
    myStr[2] = 'x'; 
    myStr[3] = '\0'; 
    *myNum = 9; 
} 

int main (void) { 
    char someString[4]; 
    int n = 6; 

    AFunc(someString, &n); 

    printf("%s %d", someString, n); 
    return 0; 
} 

qui sort:

pax 9 

Une « chaîne » en C est vraiment un tableau des caractères terminés par le caractère \0 (NUL).

Ce que le code ci-dessus fait est de passer l'adresse du premier caractère dans ce tableau et la fonction remplit les quatre caractères à partir de là.

Answer 2

Vous ne traitez que des caractères et des pointeurs de char. Aucun des pointeurs char ne sont des chaînes valides car ils ne sont pas terminés par null. Essayez de définir une chaîne et voyez à quoi elle ressemble.

Answer 3

But what if the string was more than one char? How would the code look 
differently? Thanks for any help 

Ofcourse, vous devez modifier les autres personnages aussi bien, mais exactement la même façon que vous avez fait la première fois.

1. Déclare un tableau de caractères et passer son adresse
2. Modifiez les valeurs à celles
adresse

Un tableau de caractères serait un terme plus clair pour une chaîne.

Answer 4

En C, un pointeur vers char n'est pas nécessairement une chaîne. En d'autres termes, juste parce que vous avez char *x;, cela ne signifie pas que x est une chaîne.

Pour être une chaîne, x doit pointer vers une région convenablement affectée qui a un 0 dans quelque part. Les données du premier caractère x pointent vers et jusqu'à 0 est une chaîne. Voici quelques exemples de chaînes en C:

char x[5] = {0}; /* string of length 0 */ 
char x[] = "hello"; /* string of length 5, the array length being 6 */ 
char *x = "hello"; /* string of length 5. x is a pointer to a read-only buffer of 6 chars */ 

char *x = malloc(10); 
if (x != NULL) { 
    strcpy(x, "hello"); /* x is now a string of length 5. x points 
          to 10 chars of useful memory */ 

} 

Ne sont pas des chaînes:

char x[5] = "hello"; /* no terminating 0 */ 
char y = 1; 
char *x = &y; /* no terminating 0 */ 

Alors maintenant dans votre code, premier paramètre de AFunc, même si est un char * est pas nécessairement un string. En fait, dans votre exemple, ce n'est pas le cas, car il pointe uniquement vers une mémoire qui a un élément utile, et ce n'est pas zéro.

Selon la manière dont vous souhaitez modifier la chaîne et la manière dont la chaîne a été créée, plusieurs options sont disponibles.

Par exemple, si les myStr pointe vers une mémoire inscriptible, vous pourriez faire quelque chose comme ceci:

/* modify the data pointed to by 'data' of length 'len' */ 
void modify_in_place(char *data, size_t len) 
{ 
    size_t i; 
    for (i=0; i < len; ++i) 
     data[i] = 42 + i; 
} 

Une autre façon légèrement différente serait pour la fonction de modifier data jusqu'à ce qu'il voit le terminer 0:

void modify_in_place2(char *data) 
{ 
    size_t i; 
    for (i=0; data[i]; ++i) 
     data[i] = 42 + i; 
}