Comment copier une chaîne à l'aide d'un pointeur

Voici un programme que j'ai écrit pour copier une chaîne de caractères constante.

Lorsque le programme est exécuté, il se bloque. Pourquoi est-ce arrivé ?

#include <stdio.h>

char *alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char c;
char *l;

main(){
   while((c = *alpha++)!='
#include <stdio.h>
char *alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char c;
char *l;
main(){
while((c = *alpha++)!='\0')
*l++ = *alpha;
printf("%s\n",l);
}
')
       *l++ = *alpha;
   printf("%s\n",l);
}

source d'informationauteur Arabeka

  1. 16

    Pour effectuer de telles copie manuelle:

    #include <stdio.h>
#include <stdlib.h>

int main()
{
    char* orig_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    char* ptr = orig_str;

    //Memory layout for orig_str:
    //------------------------------------------------------------------------
    //|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
    //------------------------------------------------------------------------
    //|A|B|C|D|E|F|G|H|I|J|K |L |M |N |O |P |Q |R |S |T |U |V |W |X |Y |Z |
    #include <stdio.h>
#include <stdlib.h>
int main()
{
char* orig_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char* ptr = orig_str;
//Memory layout for orig_str:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//|A|B|C|D|E|F|G|H|I|J|K |L |M |N |O |P |Q |R |S |T |U |V |W |X |Y |Z |\0|  --> data
//------------------------------------------------------------------------
int orig_str_size = 0;
char* bkup_copy = NULL;
//Count the number of characters in the original string
while (*ptr++ != '\0')
orig_str_size++;        
printf("Size of the original string: %d\n", orig_str_size);
/* Dynamically allocate space for the backup copy */ 
//Why orig_str_size plus 1? We add +1 to account for the mandatory 
//'\0' at the end of the string.
bkup_copy = (char*) malloc((orig_str_size+1) * sizeof(char));
//Place the '\0' character at the end of the backup string.
bkup_copy[orig_str_size] = '\0'; 
//Current memory layout for bkup_copy:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//| | | | | | | | | | |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\0|  --> data
//------------------------------------------------------------------------
/* Finally, copy the characters from one string to the other */ 
//Remember to reset the helper pointer so it points to the beginning 
//of the original string!
ptr = &orig_str[0]; 
int idx = 0;
while (*ptr != '\0')
bkup_copy[idx++] = *ptr++;
printf("Original String: %s\n", orig_str);   
printf("Backup String: %s\n", bkup_copy);
return 0;
}
    |  --> data    
    //------------------------------------------------------------------------

    int orig_str_size = 0;
    char* bkup_copy = NULL;

    //Count the number of characters in the original string
    while (*ptr++ != '
    #include <stdio.h>
#include <stdlib.h>
int main()
{
char* orig_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char* ptr = orig_str;
//Memory layout for orig_str:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//|A|B|C|D|E|F|G|H|I|J|K |L |M |N |O |P |Q |R |S |T |U |V |W |X |Y |Z |\0|  --> data
//------------------------------------------------------------------------
int orig_str_size = 0;
char* bkup_copy = NULL;
//Count the number of characters in the original string
while (*ptr++ != '\0')
orig_str_size++;        
printf("Size of the original string: %d\n", orig_str_size);
/* Dynamically allocate space for the backup copy */ 
//Why orig_str_size plus 1? We add +1 to account for the mandatory 
//'\0' at the end of the string.
bkup_copy = (char*) malloc((orig_str_size+1) * sizeof(char));
//Place the '\0' character at the end of the backup string.
bkup_copy[orig_str_size] = '\0'; 
//Current memory layout for bkup_copy:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//| | | | | | | | | | |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\0|  --> data
//------------------------------------------------------------------------
/* Finally, copy the characters from one string to the other */ 
//Remember to reset the helper pointer so it points to the beginning 
//of the original string!
ptr = &orig_str[0]; 
int idx = 0;
while (*ptr != '\0')
bkup_copy[idx++] = *ptr++;
printf("Original String: %s\n", orig_str);   
printf("Backup String: %s\n", bkup_copy);
return 0;
}
    '    )
        orig_str_size++;        

    printf("Size of the original string: %d\n", orig_str_size);

    /* Dynamically allocate space for the backup copy */ 

    //Why orig_str_size plus 1? We add +1 to account for the mandatory 
    //'
    #include <stdio.h>
#include <stdlib.h>
int main()
{
char* orig_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char* ptr = orig_str;
//Memory layout for orig_str:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//|A|B|C|D|E|F|G|H|I|J|K |L |M |N |O |P |Q |R |S |T |U |V |W |X |Y |Z |\0|  --> data
//------------------------------------------------------------------------
int orig_str_size = 0;
char* bkup_copy = NULL;
//Count the number of characters in the original string
while (*ptr++ != '\0')
orig_str_size++;        
printf("Size of the original string: %d\n", orig_str_size);
/* Dynamically allocate space for the backup copy */ 
//Why orig_str_size plus 1? We add +1 to account for the mandatory 
//'\0' at the end of the string.
bkup_copy = (char*) malloc((orig_str_size+1) * sizeof(char));
//Place the '\0' character at the end of the backup string.
bkup_copy[orig_str_size] = '\0'; 
//Current memory layout for bkup_copy:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//| | | | | | | | | | |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\0|  --> data
//------------------------------------------------------------------------
/* Finally, copy the characters from one string to the other */ 
//Remember to reset the helper pointer so it points to the beginning 
//of the original string!
ptr = &orig_str[0]; 
int idx = 0;
while (*ptr != '\0')
bkup_copy[idx++] = *ptr++;
printf("Original String: %s\n", orig_str);   
printf("Backup String: %s\n", bkup_copy);
return 0;
}
    ' at the end of the string.    
    bkup_copy = (char*) malloc((orig_str_size+1) * sizeof(char));

    //Place the '
    #include <stdio.h>
#include <stdlib.h>
int main()
{
char* orig_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char* ptr = orig_str;
//Memory layout for orig_str:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//|A|B|C|D|E|F|G|H|I|J|K |L |M |N |O |P |Q |R |S |T |U |V |W |X |Y |Z |\0|  --> data
//------------------------------------------------------------------------
int orig_str_size = 0;
char* bkup_copy = NULL;
//Count the number of characters in the original string
while (*ptr++ != '\0')
orig_str_size++;        
printf("Size of the original string: %d\n", orig_str_size);
/* Dynamically allocate space for the backup copy */ 
//Why orig_str_size plus 1? We add +1 to account for the mandatory 
//'\0' at the end of the string.
bkup_copy = (char*) malloc((orig_str_size+1) * sizeof(char));
//Place the '\0' character at the end of the backup string.
bkup_copy[orig_str_size] = '\0'; 
//Current memory layout for bkup_copy:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//| | | | | | | | | | |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\0|  --> data
//------------------------------------------------------------------------
/* Finally, copy the characters from one string to the other */ 
//Remember to reset the helper pointer so it points to the beginning 
//of the original string!
ptr = &orig_str[0]; 
int idx = 0;
while (*ptr != '\0')
bkup_copy[idx++] = *ptr++;
printf("Original String: %s\n", orig_str);   
printf("Backup String: %s\n", bkup_copy);
return 0;
}
    ' character at the end of the backup string.    
    bkup_copy[orig_str_size] = '
    #include <stdio.h>
#include <stdlib.h>
int main()
{
char* orig_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char* ptr = orig_str;
//Memory layout for orig_str:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//|A|B|C|D|E|F|G|H|I|J|K |L |M |N |O |P |Q |R |S |T |U |V |W |X |Y |Z |\0|  --> data
//------------------------------------------------------------------------
int orig_str_size = 0;
char* bkup_copy = NULL;
//Count the number of characters in the original string
while (*ptr++ != '\0')
orig_str_size++;        
printf("Size of the original string: %d\n", orig_str_size);
/* Dynamically allocate space for the backup copy */ 
//Why orig_str_size plus 1? We add +1 to account for the mandatory 
//'\0' at the end of the string.
bkup_copy = (char*) malloc((orig_str_size+1) * sizeof(char));
//Place the '\0' character at the end of the backup string.
bkup_copy[orig_str_size] = '\0'; 
//Current memory layout for bkup_copy:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//| | | | | | | | | | |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\0|  --> data
//------------------------------------------------------------------------
/* Finally, copy the characters from one string to the other */ 
//Remember to reset the helper pointer so it points to the beginning 
//of the original string!
ptr = &orig_str[0]; 
int idx = 0;
while (*ptr != '\0')
bkup_copy[idx++] = *ptr++;
printf("Original String: %s\n", orig_str);   
printf("Backup String: %s\n", bkup_copy);
return 0;
}
    '    ; 

    //Current memory layout for bkup_copy:
    //------------------------------------------------------------------------
    //|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
    //------------------------------------------------------------------------
    //| | | | | | | | | | |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
    #include <stdio.h>
#include <stdlib.h>
int main()
{
char* orig_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char* ptr = orig_str;
//Memory layout for orig_str:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//|A|B|C|D|E|F|G|H|I|J|K |L |M |N |O |P |Q |R |S |T |U |V |W |X |Y |Z |\0|  --> data
//------------------------------------------------------------------------
int orig_str_size = 0;
char* bkup_copy = NULL;
//Count the number of characters in the original string
while (*ptr++ != '\0')
orig_str_size++;        
printf("Size of the original string: %d\n", orig_str_size);
/* Dynamically allocate space for the backup copy */ 
//Why orig_str_size plus 1? We add +1 to account for the mandatory 
//'\0' at the end of the string.
bkup_copy = (char*) malloc((orig_str_size+1) * sizeof(char));
//Place the '\0' character at the end of the backup string.
bkup_copy[orig_str_size] = '\0'; 
//Current memory layout for bkup_copy:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//| | | | | | | | | | |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\0|  --> data
//------------------------------------------------------------------------
/* Finally, copy the characters from one string to the other */ 
//Remember to reset the helper pointer so it points to the beginning 
//of the original string!
ptr = &orig_str[0]; 
int idx = 0;
while (*ptr != '\0')
bkup_copy[idx++] = *ptr++;
printf("Original String: %s\n", orig_str);   
printf("Backup String: %s\n", bkup_copy);
return 0;
}
    |  --> data    
    //------------------------------------------------------------------------

    /* Finally, copy the characters from one string to the other */ 

    //Remember to reset the helper pointer so it points to the beginning 
    //of the original string!
    ptr = &orig_str[0]; 
    int idx = 0;
    while (*ptr != '
    #include <stdio.h>
#include <stdlib.h>
int main()
{
char* orig_str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char* ptr = orig_str;
//Memory layout for orig_str:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//|A|B|C|D|E|F|G|H|I|J|K |L |M |N |O |P |Q |R |S |T |U |V |W |X |Y |Z |\0|  --> data
//------------------------------------------------------------------------
int orig_str_size = 0;
char* bkup_copy = NULL;
//Count the number of characters in the original string
while (*ptr++ != '\0')
orig_str_size++;        
printf("Size of the original string: %d\n", orig_str_size);
/* Dynamically allocate space for the backup copy */ 
//Why orig_str_size plus 1? We add +1 to account for the mandatory 
//'\0' at the end of the string.
bkup_copy = (char*) malloc((orig_str_size+1) * sizeof(char));
//Place the '\0' character at the end of the backup string.
bkup_copy[orig_str_size] = '\0'; 
//Current memory layout for bkup_copy:
//------------------------------------------------------------------------
//|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|  --> indices
//------------------------------------------------------------------------
//| | | | | | | | | | |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |\0|  --> data
//------------------------------------------------------------------------
/* Finally, copy the characters from one string to the other */ 
//Remember to reset the helper pointer so it points to the beginning 
//of the original string!
ptr = &orig_str[0]; 
int idx = 0;
while (*ptr != '\0')
bkup_copy[idx++] = *ptr++;
printf("Original String: %s\n", orig_str);   
printf("Backup String: %s\n", bkup_copy);
return 0;
}
    '    )
        bkup_copy[idx++] = *ptr++;

    printf("Original String: %s\n", orig_str);   
    printf("Backup String: %s\n", bkup_copy);

    return 0;
}
  2. 14

    Pour copier des chaînes de caractères en C, vous pouvez utiliser la fonction strcpy. Voici un exemple:

    #include <stdio.h>
#include <string.h>

const char * my_str = "Content";
char * my_copy;
my_copy = malloc(sizeof(char) * (strlen(my_str) + 1));
strcpy(my_copy,my_str);

    Si vous voulez éviter les dépassements de la mémoire tampon, utilisez strncpy au lieu de strcpy. Par exemple:

    const char * my_str = "Content";
const size_t len_my_str = strlen(my_str) + 1;
char * my_copy = malloc(len_my_str);
strncpy(my_copy, my_str, len_my_str);
  3. 3

    Vous avez besoin d'allouer de l'espace pour l. Actuellement, il est de pointage à un endroit aléatoire dans la mémoire, et si vous essayez d'écrire à cet endroit, le système d'exploitation est susceptible d'arrêter (AKA crash) de votre application. Si vous voulez que votre code du travail, puis attribuez-lui un peu d'espace pour l avec malloc() ou créer l comme un tableau de caractères avec suffisamment d'espace pour contenir "ABCDEFGHIJKLMNOPQRSTUVWXYZ" plus le terminateur NULL.

    Voir http://cslibrary.stanford.edu/106/ un apprêt sur les pointeurs.

  4. 0

    Copier une chaîne de caractères constante/literal/pointeur"

    char *str = "some string thats not malloc'd";
char *tmp = NULL; 
int i = 0; 
for (i = 0; i < 6; i++) {
    tmp = &str[i];
}
printf("%s\n", tmp);

    Inversé

    char *str = "some stupid string"; 
char *tmp, *ptr = NULL; 
ptr = str;
while (*str) { ++str; } 
int len = str - ptr;
int i = 0;
for (i = len; i > 11; i--) {
    tmp = &ptr[i];
} 
printf("%s\n", tmp);

    tmp = &blah[i] peut être échangé avec tmp = &(*(blah + i)).

  5. 0
    #include <stdio.h>
#include <string.h>
#define MAX_LENGTH 256
int main(void) {
    char *original, *copy, *start; //three character pointers
    original = malloc(sizeof(char) * MAX_LENGTH); //assigning memory for strings is good practice
    gets(original); //get original string from input
    copy = malloc(sizeof(char) * (strlen(original)+1)); //+1 for 
    #include <stdio.h>
#include <string.h>
#define MAX_LENGTH 256
int main(void) {
char *original, *copy, *start; //three character pointers
original = malloc(sizeof(char) * MAX_LENGTH); //assigning memory for strings is good practice
gets(original); //get original string from input
copy = malloc(sizeof(char) * (strlen(original)+1)); //+1 for \0
start = copy;
while((*original)!='\0')
*copy++ = *original++;
*copy = '\0';
copy = start;
printf("The copy of input string is \"%s\".",copy);
return 0;
}
    

    start = copy;
    while((*original)!='
    #include <stdio.h>
#include <string.h>
#define MAX_LENGTH 256
int main(void) {
char *original, *copy, *start; //three character pointers
original = malloc(sizeof(char) * MAX_LENGTH); //assigning memory for strings is good practice
gets(original); //get original string from input
copy = malloc(sizeof(char) * (strlen(original)+1)); //+1 for \0
start = copy;
while((*original)!='\0')
*copy++ = *original++;
*copy = '\0';
copy = start;
printf("The copy of input string is \"%s\".",copy);
return 0;
}
    '    )
       *copy++ = *original++;
    *copy = '
    #include <stdio.h>
#include <string.h>
#define MAX_LENGTH 256
int main(void) {
char *original, *copy, *start; //three character pointers
original = malloc(sizeof(char) * MAX_LENGTH); //assigning memory for strings is good practice
gets(original); //get original string from input
copy = malloc(sizeof(char) * (strlen(original)+1)); //+1 for \0
start = copy;
while((*original)!='\0')
*copy++ = *original++;
*copy = '\0';
copy = start;
printf("The copy of input string is \"%s\".",copy);
return 0;
}
    '    ;
    copy = start;

    printf("The copy of input string is \"%s\".",copy);
    return 0;
}
  6. 0

    Vous pouvez directement faire le code ci-dessous:

    char *alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char *l = alpha;

    Si votre code est ci-dessous:

    const char *alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char *l = alpha;

    🙂

  7. 0

    cpy fonction prend deux pointeurs de char src et le pointeur pointe vers le premier caractère de la src(char tableau) définie dans la fonction principale, et même comme des pointeur pointe vers l'emplacement initial de des(char tableau) définie dans la fonction principale et la boucle while de la valeur de la src pointeur d'affecter la valeur des pointeur et incrémenter le pointeur vers l'élément suivant, ce sera le cas jusqu'à ce que la boucle while rencontrés avec la valeur null et sort de la boucle et des pointeur simplement attribué null après la prise de toutes les valeurs. 

    #include<stdio.h>
void cpy(char *src,char *des)
{
     while(*(des++) = *(src++));
     *des = '
    #include<stdio.h>
void cpy(char *src,char *des)
{
while(*(des++) = *(src++));
*des = '\0';
}
int main()
{
char src[100];
char des[100];
gets(src);
cpy(src,des);
printf("%s",des);
}
    '    ;
}

int main()
{
     char src[100];
     char des[100];
     gets(src);
     cpy(src,des);
     printf("%s",des);
}

    De sortie: Image