Copier une chaîne dans un tableau malloc'd de chaînes

Question

Je pensais avoir compris la réponse à this question mais pas moi. Je comprends le premier résultat mais je ne sais toujours pas comment faire correctement la copie. J'ai essayé le code suivant:

// TstStrArr.cpp : Defines the entry point for the console application. 
// 

#include "stdafx.h" 

#include <string.h> 
#include <malloc.h> 


int main() 
{ 
    char ** StrPtrArr; 
    char InpBuf0[] = "TstFld0"; 
    char InpBuf1[] = "TstFld1"; 

    StrPtrArr = (char **)malloc(2 * sizeof(char *)); 

    StrPtrArr[0] = (char *)malloc(10 + 1); 
    printf("inpbuf=%s sizeof=%2d ", InpBuf0, sizeof(StrPtrArr[0])); 
    strncpy_s(StrPtrArr[0], sizeof(StrPtrArr[0]), InpBuf0, _TRUNCATE); 
    printf("strptrarr=%s\n", StrPtrArr[0]); 

    StrPtrArr[1] = (char *)malloc(10 + 1); 
    printf("inpbuf=%s sizeof=%2d ", InpBuf1, sizeof(*StrPtrArr[1])); 
    strncpy_s(*StrPtrArr[1], sizeof(*StrPtrArr[1]), InpBuf1, _TRUNCATE); // error here 
    printf("*strptrarr=%s\n", StrPtrArr[1]); 

    free(StrPtrArr[0]); 
    free(StrPtrArr[1]); 
    free(StrPtrArr); 


    return 0; 
} 

Le résultat je suis arrivé était:

inpbuf=TstFld0 sizeof= 4 strptrarr=Tst 
inpbuf=TstFld1 sizeof= 1 

et l'erreur suivante:

Exception thrown: write access violation. 
destination_it was 0xFFFFFFCD. 

Le résultat que je pensais que je me faisais était l'une des suivant:

inpbuf=TstFld1 sizeof=11 *strptrarr=TstFld1 
inpbuf=TstFld1 sizeof= 1 *strptrarr=T 

Je comprends le La première copie a copié le tampon d'entrée sur le pointeur de 4 octets qui était incorrect. Je pensais que la deuxième copie copierait le tampon d'entrée à la valeur du pointeur déréférencé d'une taille de 11 mais ce n'était pas le cas. Je devine que la copie était au premier caractère de la chaîne dans le tableau. Je ne comprends pas assez la mémoire pour connaître la signification de l'adresse 0xFFFFFFCD mais je suppose que c'est en mémoire morte causant ainsi l'erreur.

Quelle est la bonne façon de faire la copie?

(je ne pense pas que cela importe, mais je suis en utilisant VS 2015 Community Edition Update 3.)

Answer 1

Pourquoi

strncpy_s(*StrPtrArr[1], sizeof(*StrPtrArr[1]), InpBuf1, _TRUNCATE); 

?

*StrPtrArr[1] devrait être StrPtrArr[1] parce StrPtrArr est de type char** et vous avez besoin char* ici.

et sizeof (* StrPtrArr [1]) - est assez étrange .... effectivement sizeof(StrPtrArr[1]) ne peut pas non plus fournir une valeur correcte.

Vous devez vous rappeler la taille de la mémoire allouée, puis l'utiliser comme:

size_t arrSize = 10 + 1; 
StrPtrArr[1] = (char *)malloc(arrSize); 
. . . 
strncpy_s(StrPtrArr[1], arrSize, InpBuf1, _TRUNCATE); 

Answer 2

Le problème est que vous utilisez sizeof au moment de décider combien de caractères à copier. Cependant, vous avez alloué un nombre fixe de caractères qui n'est pas connu sizeof opérateur: sizeof StrPtrArr[0] est égal à la taille de char pointeur sur votre système (quatre octets, à en juger par la sortie), pas 10 + 1. Par conséquent, vous devez spécifier ce même numéro à nouveau dans l'appel pour sécuriser la copie de la chaîne.

Answer 3

Ce n'est pas aussi compliqué que les gens semblent le penser.

char* array = calloc(n, sizeof(array[0])); // allocate array of pointers 

// assign a dynamically allocated pointer: 
size_t size = strlen(str) + 1; 
array[i] = malloc(size); 
memcpy(array[i], str, size); 

J'ai utilisé intentionnellement calloc lors de l'attribution, car qui définit tous les pointeurs NULL. Cela donne l'avantage que vous pouvez appeler sans risque free() sur le pointeur, avant même qu'il soit assigné pour pointer sur une chaîne.

Cela signifie que vous pouvez facilement (re) assigner une nouvelle chaîne à un indice à tout moment, de la manière suivante:

void str_assign (char** dst, const char* src) 
{ 
    size_t size = strlen(src) + 1; 
    free(*dst); 
    *dst = malloc(size); 
    if(*dst != NULL) 
    { 
    memcpy(*dst, src, size); 
    } 
} 

... 
str_assign(&array[i], "something");