copiando una cadena a otra cadena en C

char *stringcopywithpointer( const char *source) { int ii = 0; int len = strlen(source) +1; char *dest = (char*)malloc(sizeof(char)*len); while(*source != '\0') { // dest[ii++] = *source++; *dest++ = *source++; } // dest[ii] = '\0'; *dest = '\0'; printf("\n copied string = %s", dest1); return dest; } 

Quiero copiar la cadena de origen a la cadena de destino. El api anterior está volviendo nulo. Si uso una matriz de caracteres (esto lo he comentado), entonces esta API me funciona.

Por favor ayúdame a entender la diferencia entre

 dest[ii++] = *source++ 

y

 *dest++ = *source++; 

Estás incrementando dest durante el ciclo while. Debe mantener presionado un puntero al inicio del búfer para regresar de la función.

 char *stringcopywithpointer( const char *source) { int ii = 0; int len = strlen(source); char *copy = malloc(len+1); char* dest = copy; while(*source != '\0') { *dest++ = *source++; } *dest = '\0'; printf("\n copied string = %s", copy); return copy; } 

Tenga en cuenta que puede guardar algo de código usando strcpy

 char *stringcopywithpointer( const char *source) { int len = strlen(source); char *copy = malloc(len+1); strcpy(copy, source); return copy; } 

y podría reducir esto a una sola línea si tiene acceso al strdup no estándar

 char *stringcopywithpointer( const char *source) { return strdup(source); } 

Mi opinión:

Evite asignar memoria en la función llamada, mejor asigne memoria antes de llamar a una función

 char *dest = ( char* ) malloc( sizeof( char ) * len ); // doesn't looks great 

Independientemente de la máquina, sizeof( char ) siempre es 1 byte. Menos redundante es sizeof( char ) * len . Lo óptimo sería malloc( sizeof( source ) ) .

Los punteros y las matrices están relacionados Puedes usar

 dest[i] = src[i]; *dst++ = *src++; 

o

 // assuming dst memory allocate by caller while ( *dst++ = *src++); 

1)

 printf("\n copied string = %s", dest1); 

debiera ser

 printf("\n copied string = %s", dest); 

Esto podría ser un error tipográfico

2)

Tu puedes cambiar:

 while(*source != '\0') { *dest++ = *source++; } 

por

 while(*dest++ = *source++); 

3)

Con respecto a la diferencia entre dest[ii++] = *source++ y *dest++ = *source++;

No hay diferencia y debería funcionar si dest se define de esta manera

 char *dest = (char*)malloc(sizeof(char)*len); 

Si su matriz se define de esta manera:

 char dest[len]; 

Entonces hay diferencia

No debe devolver una cadena asignada. Esto puede conducir fácilmente a una pérdida de memoria.

En su lugar, debe considerar pasar la memoria asignada a su función para copiarla. Puede utilizar su valor de retorno para devolver un error si algo salió mal.

Esto cambiaría tu firma a.

 int stringcopywithpointer( char * dest, const char *source) 

para hacer que su código sea un poco más versátil, podría implementar vargs y su firma sería:

 int stringcopywithpointerf( char * dest, const * format, ... ); 

Esta es en realidad la función ya existente sprintf.

 int sprintf( char * dest, const * format, ... ); 

También hay variantes seguras de la función disponible y prefabricada. Es posible que desee considerar el uso de uno de esos.

Si esto está relacionado con la tarea, mira esta función:

 char * myscpy(const char * SRC){ size_t size = strlen( SRC ) + 1 ; char * START; char * DST = ( char * ) malloc( size ); START = DST; do { *DST = *SRC; DST++; SRC++; }while( *SRC != 0 ); *DST = *SRC; return START; } 

Es probable que desee agregar controles de errores como si los hubiera colocado (malloc, etc.) en su publicación original.


“Por favor, ayúdame a entender la diferencia entre dest [i ++] y * dest ++”

dest [i ++] no incrementa el puntero sino el índice al puntero. * dest ++ incrementa el puntero después de acceder a su contendt original.

Añadir char *dest1 = dest; Justo después de malloc y luego retornar dest1 y eso funcionará.

Otro cambio posible: reemplace el bucle while con el bucle de condición posterior (es decir, copie el byte cero primero, luego verifique si fue el final).

Puede ser que necesites añadir esta línea.

 char *stringcopywithpointer( const char *source) { int ii = 0; int len = strlen(source) +1; char *ptr = NULL; char *dest = (char*)malloc(sizeof(char)*len); /** No Error Checking for malloc is a strict no no **/ if(dest == NULL) return NULL; /** hold the dest adress in ptr as we are incrementing dest **/ ptr = dest; while(*source != '\0') { // dest[ii++] = *source++; *dest++ = *source++; } // dest[ii] = '\0'; *dest = '\0'; //printf("\n copied string = %s", dest1); ?? printf("\n copied string = %s", ptr); // ptr will have our copied String /** so return ptr not dest **/ return ptr; }