C Array pour Char pointeur

Question

J'ai besoin guidence sur les pointeurs et de tableau

char *ptr; 
char Array1[20]; 

ptr = malloc(sizeof(Array1)); 

maintenant comment puis-je obtenir l'ensemble Array1 dans le PTR ??

J'ai essayé strcat, strncat, strcpy. Aussi j'ai essayé une boucle puis en utilisant les fonctions mentionnées et en ajoutant chaque élément de tableau et e rien

int a = 0 
while (a <= sizeof(Array1)) 
{ 
    strcpy(ptr, Array1[a]); 
    a++; 
} 

je vraiment besoin de savoir comment obtenir le tableau dans un pointeur.

Answer 1

utilisation memcpy():

ptr = malloc(sizeof(Array1)); 
if (ptr) 
{ 
    memcpy(ptr, Array1, sizeof(Array1)); 
} 

La famille str* des fonctions dépendent de la présence de caractères de terminaison nulle.

Si Array1 contient une chaîne, terminée par un caractère nul, alors strcpy() et strncpy() fonctionneront correctement. strcat() nécessite la présence d'un terminateur null dans le tampon de destination ainsi que le tampon source pour fonctionner correctement.

Si Array1 ne contient pas de chaîne terminée par un caractère NULL, n'utilisez pas les fonctions str*, utilisez plutôt memcpy().

Answer 2

maintenant comment puis-je obtenir l'ensemble Array1 dans le ptr ??

Utilisation memcpy:

memcpy(ptr, Array1, sizeof(Array1)); 

Aussi j'ai essayé une boucle puis en utilisant les fonctions mentionnées et en ajoutant chaque élément du tableau e

Cette boucle est incorrecte, parce que vous traitez un tableau de char s sous la forme d'un tableau de char*. J'ai vraiment besoin de savoir comment placer le tableau dans un pointeur. Le nom de la matrice convertit librement en pointeur vers l'élément de tableau initial. C'est pourquoi vous pouvez passer Array1 à memcpy, qui prend un pointeur. En général, l'expression Array1 est la même que &Array1[0], qui est la manière explicite de prendre l'adresse de l'élément de tableau initial.

Answer 3

Pour ajouter à l'hilarité, vous pouvez le faire tout à fait sans mettre la main ou les mains de la bibliothèque standard sale avec des boucles embêtants et laisser le compilateur faire le dur travail:

#include <stdio.h> 
#include <stdlib.h> 
int main() { 
    char a[20] = "Hello World today!!"; 
    char* const p = malloc(sizeof a); 
    union { 
    char* volatile p; 
    struct { 
     char a[20]; 
    }* s; 
    } destination = {.p = p}, source = {.p = a}; 
    *destination.s = *source.s; 
    printf("%s\n",p); 
    return 0; 
} 
// tested with CFLAGS:='-Wall -Wextra -pedantic -std=c11' 

Bien que il faut mentionend que ce n'est pas techniquement conforme à la spécification standard C, parce que nous cachons une distribution en utilisant un syndicat et la norme ne nous permet pas d'utiliser les syndicats de cette façon (vous devez promettre de n'utiliser que le membre syndical que vous avez écrit à, que nous cassons en utilisant le membre s).

Mais c'est plus amusant que d'utiliser la bibliothèque ou ces choses en boucle, n'est-ce pas? :)
(non-responsabilité:.. Est d'utiliser des boucles aussi (ou plutôt des boucles implicitement déroulées) Nous ne les voit pas)

---

Modifier J'étais curieux et avait un regard à quel clang (3.2, plutôt daté, accordé) génère de cela et il semble effectivement traduire cela en un appel de memcpy (dernière ligne).

%1 = alloca i32, align 4 
    %a = alloca [20 x i8], align 16 
    %p = alloca i8*, align 8 
    %destination = alloca %union.anon, align 8 
    %source = alloca %union.anon, align 8 
    store i32 0, i32* %1 
    %2 = bitcast [20 x i8]* %a to i8* 
    call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* getelementptr inbounds ([20 x i8]* @main.a, i32 0, i32 0), i64 20, i32 16, i1 false) 
    %3 = call noalias i8* @malloc(i64 20) nounwind 
    store i8* %3, i8** %p, align 8 
    %4 = bitcast %union.anon* %destination to i8** 
    %5 = load i8** %p, align 8 
    store volatile i8* %5, i8** %4, align 8 
    %6 = bitcast %union.anon* %source to i8** 
    %7 = getelementptr inbounds [20 x i8]* %a, i32 0, i32 0 
    store volatile i8* %7, i8** %6, align 8 
    %8 = bitcast %union.anon* %destination to %struct.anon** 
    %9 = load %struct.anon** %8, align 8 
    %10 = bitcast %union.anon* %source to %struct.anon** 
    %11 = load %struct.anon** %10, align 8 
    %12 = bitcast %struct.anon* %9 to i8* 
    %13 = bitcast %struct.anon* %11 to i8* 
    call void @llvm.memcpy.p0i8.p0i8.i64(i8* %12, i8* %13, i64 20, i32 1, i1 false)