Utiliser des pointeurs avec des fonctions et des structures

Question

Bonjour, je suis autodidacte C et je suis un peu confus au sujet du code suivant car je ne sais pas si je comprends bien le code. Je serais très reconnaissant si quelqu'un pouvait lire mon explication et me corriger si je me trompe.

Le code provient d'un fichier d'en-tête. La fonction du programme devrait être inintéressante à ce stade, puisque mon problème de compréhension concerne les pointeurs et les valeurs que les fonctions rendent en retour. Donc tout d'abord je déclare 3 tableaux de char et un nombre entier dans ma structure d'employé.

struct employee 
{ 
    char firstname[11]; 
    char lastname[11]; 
    char number[11]; 
    int salary; 
} 

5 fonctions sont déclarées dans le fichier d'en-tête. La première fonction prend 4 valeurs (3 pointeurs et un int) et renvoie un pointeur vers une structure. La deuxième fonction obtient un pointeur sur le "struct struct" et renvoie un pointeur à un élément du tableau "char firstname" dans l'employé struct. Les fonctions 3 et 4 font la même chose pour les deux autres tableaux.
La fonction 5 obtient un pointeur sur l'opérateur struct mais renvoie un int et non un pointeur. Donc, il utilise simplement la variable déclarée dans la structure.

struct employee* createEmployee(char*, char*, char*, int); //1 
char* firstname (struct Employee*);      //2 
char* lastname (struct Employee*);       //3 
char* number (struct Employee*);       //4 
int salary (struct Employee*);        //5 

Answer 1

Votre compréhension est à peu près correcte. Pour être un peu plus précis et/ou moins abusif de la langue anglaise, les fonctions 2-4 renvoient un pointeur à un élément du tableau correspondant. L'idée est que le contenu de chaque tableau représente une sorte de texte, chaque élément correspondant à un caractère de texte, jusqu'à la première apparition d'une valeur nulle (utilisée pour marquer la fin de la "chaîne"). Gardez à l'esprit qu'il n'y a pas de disposition pour Unicode ici, ou même pour spécifier un encodage: nous supposons ASCII, et pour tous les octets non compris dans la plage 0..127, tous les paris sont désactivés. Un meilleur nom pour le type char serait byte; mais nous ne savions pas vraiment mieux à l'époque.(Vous devez également savoir que char est un type distinct du signed char et unsigned char, et que char peuvent ou non être signé.)

De cette façon, les noms et numéro peut être une longueur jusqu'à dix (un onzième octet est réservé pour avoir de la place pour le "terminateur nul" avec la valeur zéro), et le pointeur retourné peut être utilisé pour inspecter - et modifier; mais cela pourrait ne pas être une bonne idée - les données dans les tableaux qui font partie de la structure Employee.

Le int retourné comme salary du Employee est une copie de l'une dans le struct. Donc, bien que nous puissions voir la valeur entière, cela ne pas laissez-nous modifier la valeur dans la structure. Bien sûr, tant que nous avons la définition struct et une instance Employee, il n'y a pas de protection; nous pouvons accéder au membre directement au lieu de passer par la fonction.

En C, nous obtenons "encapsulation" et "dissimulation de données" par pas fournissant ces définitions. Au lieu de cela, nous allons simplement mettre struct Employee; et les déclarations de fonctions dans l'en-tête, et la définition de struct dans le fichier d'implémentation. Maintenant, le code appelant ne sait rien sur ce que Employeeest; seulement sur ce que peut faire.

Answer 2

Ce que vous ne pouvez pas être sûr en lisant simplement la signature de fonction si les valeurs/pointeurs retournés sont référence aux mêmes valeurs/pointeurs de la sturct, ou la fonction (s) crée une copie et revenir pointeur vers la nouvelle valeur. C'est pourquoi c'est une bonne idée d'écrire aussi la documentation en tant que commentaires avec la signature de la fonction dans le fichier d'en-tête.

Answer 3

Vos explications de sens, sauf # 2-4: depuis leur retour char*, ils ne peuvent pas retourner un élément d'un tableau de caractères (le type correct pour celui-ci serait tout simplement char). Chacune des trois fonctions renvoie un pointeur sur char. On suppose qu'ils retournent le pointeur sur le premier élément du tableau correspondant, qui est essentiellement comment les tableaux sont passés en C.

Answer 4

Presque à droite, sauf quand vous lisez les fonctions, l'entrée "char *" doit être lue En tant que la chaîne est transmise bien que techniquement c'est un pointeur. pour les entiers, la valeur réelle est transmise, vous êtes donc là.

donc,

struct employee* createEmployee(char*, char*, char*, int); 

signifierait que la procédure crée un employé avec les quatre valeurs entrées (les trois premiers sont des chaînes (char *) qui sont probablement le prénom, le nom et le numéro/id dans ce l'ordre et le dernier est le salaire.)

Answer 5

Il y a un problème dans 1. Qu'est-ce que vous faites, je suppose est:

struct employee* createEmployee(const char* f, const char* l, const char* n, 
const int sal) 
{ 
    struct employee* e; 
    strcpy(e->firstname, f); 
    strcpy(e->lastname, l); 
    /* ... */ 
    return e; 
} 

Le problème ici est les tableaux à venir dans Il est parfaitement possible pour un tableau de caractères de toute taille à passer. dans; quoi que ce soit sur la longueur de 11 vous obligerait à commencer à écraser les données à &(e->firstname[0])+11;. Au-dessus de quoi? Exactement. Vous n'avez aucune idée (et je ne l'ai pas non plus, cela serait déterminé à l'exécution). Cela pourrait causer de sérieux problèmes.

Une façon de contourner est d'utiliser les fonctions de stdlib.h et string.h dire strlen() pour tester la longueur des données transmises pour vous assurer qu'il correspond à la taille de votre terrain.

Une meilleure méthode pourrait consister à écrire:

int createEmployee(struct employee* e, const char* f, const char* l, const char* n, 
const int sal) 
{ 
    int error = 0; 
    if (strlen(f) < 11) 
    {  
     strncpy(e->firstname, f); 
    } 
    else 
    { 
     error++; 
    } 
    /* ... */ 

    return error; 
} 

Voyez ce que je l'ai fait? Oui, cela fonctionnera - tout ce qui est passé en tant que pointeur peut être modifié. Ce n'est pas passer par référence, tout à fait. Edit: comme le dit aix, les pointeurs sont "comment les tableaux sont transmis en C".

Une autre méthode potentielle est strncpy() qui tronquera la chaîne source en fonction du dernier argument, donc strncpy(e->firstname, f, 11); serait sûr.

Vous pouvez également essayer l'allocation de mémoire dynamique pour les tailles de champ en fonction des besoins. Je suppose que vous apprendrez cela plus tard/comme un autre défi.

En outre, une autre suggestion, alors que nous y sommes, est de définir le pointeur vers une structure en utilisant typedef. Cela rend les choses un peu plus lisibles bien que la façon dont vous l'avez fait est nettement plus claire pour quelqu'un qui apprend.