Sens du codage

Avez-vous le sens du codage? Choisirez-vous la meilleure architecture? Allez-vous écrire du code hautement testable et facile à modifier? Est-ce juste pour écrire du code rapidement?

Je pense que cela varie d'une personne à l'autre, Qui a du sens pour Linus Tobals? Il semble que ce soit une personne qui peut comprendre intuitivement le bon code en regardant en grand.

Par exemple, quelqu'un qui peut voir qu'un cas particulier d'une instruction if peut être généralisé. L'exemple suivant est un fragment de code introduit dans la vidéo ci-dessus converti en code de travail.

 #include "common.h"

 typedef struct linked_list
 {
     int value;
     struct linked_list* nextp;
 } linkedlist;

 linkedlist* firstlistp = NULL;

 void initList(int value);
 void addList(int value);
 linkedlist* findList(int value);
 void deleteList(linkedlist* entry);
 void printList();

 int main()
 {
     initList(11);
     addList(12);
     addList(13);
     addList(14);
     addList(15);
     addList(16);
     addList(17);
     printList();

     puts("TEST A");

     linkedlist* lp = findList(14);
     deleteList(lp);
     printList();

     puts("TEST B");

     lp = findList(12);
     deleteList(lp);
     printList();

     puts("TEST C");

     lp = findList(16);
     deleteList(lp);
     printList();

     puts("TEST D");

     return 0;
 }

 void initList(int value)
 {
     linkedlist* newp;
     newp = malloc(sizeof(linkedlist));
     newp->value = value;
     newp->nextp = NULL;
     firstlistp = newp;
 }

 void addList(int value)
 {
     linkedlist* newp;
     newp = malloc(sizeof(linkedlist));
     newp->value = value;
     newp->nextp = firstlistp;

     firstlistp = newp;
 }

 linkedlist* findList(int value)
 {
     linkedlist* currentp;
     currentp = firstlistp;

     while((currentp != NULL) && (currentp->value != value))
     {
         currentp = currentp->nextp;
     }

     return currentp;
 }

 #define BAD

 void deleteList(linkedlist* entryp)
 {
 #ifdef BAD
     linkedlist* prevp = NULL;
     linkedlist* walkp = firstlistp;

     while(walkp != entryp)
     {
         prevp = walkp;
         walkp = walkp->nextp;
     }

     if(!prevp)
     {
         firstlistp = entryp->nextp;
     }
     else
     {
         prevp->nextp = entryp->nextp;
     }
 #else
     linkedlist** indirectpp = &firstlistp;

     while((*indirectpp) != entryp)
         indirectpp = &(*indirectpp)->nextp;
     *indirectpp = entryp->nextp;
 #endif

     free(entryp);
 }

 void printList()
 {
     linkedlist* currentp = firstlistp;
     while(currentp != NULL)
     {
         printf("%d\n", currentp->value);
         currentp = currentp->nextp;
     }
 }

La fonction deleteList a été introduite. La différence entre la route BAD et la route else est qu'il n'y a pas d'instruction if. L'itinéraire spécial a disparu et s'est généralisé.

lisibilité

Quand on parle de qualité du code, le sujet de la lisibilité revient. Le code BAD est-il facile à lire? Si vous voyez ce code dans votre avis, vous pouvez choisir le code MAUVAIS. Je le pense du moins sur mon lieu de travail.

Mauvais code

Je pense qu'il existe de nombreuses façons de réaliser une fonction. Les problèmes soulevés lors de la discussion sont la vitesse d'exécution, la lisibilité et l'extensibilité. Puisque la vitesse d'exécution peut être mesurée, on peut juger objectivement qu'elle est plus rapide ou plus lente, La lisibilité est différente d'une personne à l'autre, et l'extensibilité est limitée tant que nous ne savons pas où elle changera. Cela dépend également de combien cela dépend du fichier de configuration. Le bon ou le mauvais goût peut dépendre de la situation. Cependant, il existe un bon code pour chaque situation. Ce que Linus dit, c'est qu'il y a de bons et de mauvais codes, et qu'il y a des gens qui peuvent les comprendre intuitivement. difficile.

De côté

Quand j'ai commencé à écrire sans penser à ce que je voulais dire, je n'ai pas compris jusqu'à la fin et cela a fini par être un article peu concluant. Il semble que je n'ai ni sens du codage ni sens de l'écriture. J'ai écrit une liste de liens depuis l'introduction au langage C. Jusqu'à présent, je ne l'ai jamais écrit moi-même dans mon travail. Donc, je l'ai écrit après un long moment, mais je pense que la liste de liens est assez difficile. Il y a des choses qui sont plus difficiles en termes de traitement, mais je pensais que c'était un obstacle important pour les débutants à écrire. Le concept de l'ajout à l'avant lors de l'ajout, le traitement de la fonction de suppression Ces deux obstacles sont élevés. Vous pouvez le faire, et si vous faites une erreur, SEGV sera fait immédiatement, donc c'est facile à déboguer, et cela peut fonctionner comme un bon comportement.

Quand je suis revenu au début et que j'ai codé en dessinant une image, c'est devenu une image que personne ne pouvait comprendre. Est-ce que je n'ai aucun sens de la peinture? .. ..