Essayez la programmation Linux normale, partie 7

Cela semble être un livre célèbre alors je l'ai acheté <a target = "_ blank" href = "https://www.amazon.co.jp/gp/product/4797328355/ref=as_li_tl?ie=UTF8&camp=247&creative=1211&creativeASIN=4797328355&linkCode=as2&tag=lespacetranb7397f2902f2397f3b3b > Programmation Linux ordinaire La voie royale de la programmation gcc qui peut être apprise du mécanisme de Linux <img src = "// ir-jp.amazon-adsystem.com/e/ir?t=lespacetranqu-22&l=am2&o=9&a=4797328355" "width =" 1 "height =" 1 "border =" 0 "alt =" "style =" border: none! Important; margin: 0px! Important; "/> <a target = "_ blank" href = "https://www.amazon.co.jp/gp/product/B075ST51Y5/ref=as_li_tl?ie=UTF8&camp=247&creative=1211&creativeASIN=B075ST51Y5&linkCode=as2&tag=aaa55pacetran15 > Programmation Linux ordinaire 2ème édition: La voie royale de la programmation gcc qui peut être apprise du mécanisme de Linux <img src = "// ir-jp.amazon-adsystem.com/e/ir?t=lespacetranqu-22&l=am2&o=" 9 & a = B075ST51Y5 "width =" 1 "height =" 1 "border =" 0 "alt =" "style =" border: none! Important; margin: 0px! Important; "/>

Essayez la programmation Linux normale Partie 1 https://qiita.com/uturned0/items/b9ae846f2aff5865c074 Essayez la programmation Linux normale, partie 2 https://qiita.com/uturned0/items/56beac990cdd6f1059ed Essayez la programmation Linux normale, partie 3 https://qiita.com/uturned0/items/675092da8aa89c4b1ff0 Partie 4 https://qiita.com/uturned0/items/8f5765cfc0f0be8a1981 Partie 5 https://qiita.com/uturned0/items/ab97deb489c994a836da Partie 6 https://qiita.com/uturned0/items/b7df48e87ae9170f3698 Partie 7 https://qiita.com/uturned0/items/263151cf7c83bff7fac1

chapter 7

Faire une commande principale

#include <stdio.h>
#include <stdlib.h>

static void do_head(FILE *f, long nlines);

int
main(int argc, char *argv[])
{
	if (argc != 2) {
	    fprintf(stderr, "Usage: %s n\n", argv[0]);
		exit(1);
	}
	do_head(stdin, atol(argv[1]));
	exit(0);
}

static void
do_head(FILE *f, long nlines)
{
	int c;

	if (nlines <= 0) return;
	while ((c=getc(f)) != EOF) {
		if (putchar(c) < 0) exit(1);
		if (c == '\n') {
		    nlines--;
    		if (nlines == 0) return;
		}
	}
}

execute

$ gcc -Wall head.c && cat head.c | ./a.out 2
#include <stdio.h>
#include <stdlib.h>

déplacé!

atol()

atol, atoll, atol_l, atoll_l -- convert ASCII string to long or long long integer long atol(const char *str);

Faites de la chaîne un nombre long. Qu'est-ce qu'un casting? J'ai essayé

#include <stdio.h>
#include <stdlib.h>

int
main(int argc, char *argv[])
{
    char *str = "123";
    printf("%s \n",str);

    // printf("%d",str);    //Cela entraînera une erreur

    //Parce que la valeur de retour est longue%Si ce n'est pas ld, une erreur se produira.
    printf("%ld \n", atol(str));

    //Essayez de le mettre dans une longue variable
    unsigned long n = atol(str);
    printf("%ld \n", n);

    //printf%d était une erreur, mais vous pouvez le mettre dans une variable int ...
    unsigned int i = atol(str);
    printf("%d \n", i);

}

execute

$ gcc -Wall atol.c && ./a.out 
123 
123 
123 
123 

C'était du casting. Dans le cas de long, printf ne peut être exécuté que s'il est défini sur % ld. Erreur si% d. Mais int n = peut être fait. Y a-t-il une scène où le compilateur le permet?

Je n'ai jamais entendu parler de % ld, mais l'erreur du compilateur est bien.

Vous connaissez% ld sans même en faire le tour. c'est fantastique.

atoi() strtoll() strtol() strtod()

Un système qui convertit les caractères en nombres

Pourquoi ne pas utiliser fgets ()

gets () est meilleur car il n'a pas de tampon. Ne t'inquiète pas fgets () ne convient pas en raison des restrictions de longueur de ligne

omettre le nombre comme n

nlines = number of lines

Il semble imiter le langage Eiffel. Peut-être que c'est C

Eiffel est un langage orienté objet (naturel) fortement typé conçu par Bertrand Meyer. http://guppy.eng.kagawa-u.ac.jp/~kagawa/publication/eiffel.pdf

passer le fichier comme argument

Je l'ai oublié parce que j'avais un peu de temps, mais je m'en suis souvenu. fopen ().

#include <stdio.h>
#include <stdlib.h>

static void do_head(FILE *f, long nlines);

int
main(int argc, char *argv[])
{
    long nlines;
    int i ;
	if (argc < 2) {
	    fprintf(stderr, "Usage: %s n\n", argv[0]);
		exit(1);
	}

    nlines = atol(argv[1]);

    if (argc == 2) {
		do_head(stdin, nlines);
    } else {
    	for (i=2; i<argc; i++) {
    	    FILE *f;
    	    f = fopen(argv[i], "r");
    	    if (!f) {
    	        perror(argv[i]);
    	        exit(1);
            }
            do_head(f, nlines);
            fclose(f);
    	}
    }
	exit(0);
}

static void
do_head(FILE *f, long nlines)
{
	int c;

	if (nlines <= 0) return;
	while ((c=getc(f)) != EOF) {
		if (putchar(c) < 0) exit(1);
		if (c == '\n') {
		    nlines--;
    		if (nlines == 0) return;
		}
	}
}

reulst

$ gcc -Wall head2.c && ./a.out 3 txt .git/config
abc
xyz

[core]
        repositoryformatversion = 0
        filemode = true

les guillemets simples / doubles deviennent confus

C'est une erreur si vous définissez ceci sur `` r '' avec un guillemet simple.

    	    f = fopen(argv[i], "r");

Je pensais que c'était simple parce que c'était un caractère, mais ... je peux taper "rb", donc ça doit être du type char. peut être.

Quelles sont les options de commande Linux?

Avec ou sans paramètres ls -a head -n 10

long option / short option head --line head -n

Je n'ai jamais dit «faisons-en une option longue», alors souvenez-vous. Option longue je l'aime.

Le fait de savoir si = est requis après une longue option dépend de la commande. Endroit ennuyeux. La tête n'a pas d'importance.

head --line 5 head --line=5

- seul est" Enter from stdin " -- Une seule unité est utilisée lorsque vous voulez passer une chaîne de caractères commençant par un moins comme argument, comme" Arrêter l'analyse des options ici. "

Comment.

Je ne comprends pas vraiment «-» parce que je ne l'utilise pas beaucoup. Celui que j'utilise le plus est git checkout --index.html (retourne l'index.html modifié). Cela peut être dû au fait qu'il peut y avoir «-» dans le nom de fichier qui est l'argument après «-». Est-ce vrai. Je me demande si j'aurais dû faire une règle pour analyser comme ça. Alors c'est tout

getopt() Fonction d'analyse des options courtes. Tamis. Depuis UNIX. C'est incroyable.

Ah. J'ai vu cela dans le script bash. Après tout. l'homme a getopt (1) et getopt (3).

GETOPT (1) BSD General Commands Manual GETOPT(1) getopt -- parse command options GETOPT (3) BSD Library Functions Manual GETOPT(3) getopt -- get option character from command line argument list

Vous pouvez décider du traitement de chaque option avec while + switch case. Je pense que je devrais m'en souvenir parce que ça a l'air bien, mais je ne l'ai lu qu'en gros.

Le mouvement est différent avec et sans paramètres Par exemple, avec head -n 5, les variables globales de getopt sont les suivantes.

optopt = n //Notez que le trait d'union est parti
optarg = 5 //C'est le paramètre
optind = 2 //index argv

Eh bien, c'est juste maintenant, mais est-ce une définition de mot comme option = paramètre au lieu de clé = valeur? La valeur est un paramètre. Est-ce vrai.

Arrêtez l'analyse avec - et-, mais soyez prudent car l'emplacement de l'optind change pour chacun de ces deux. - reste. -- Passe à l'argument suivant.

getopt_long(3)

 int

 getopt_long(int argc, char * const *argv, const char *optstring, const struct option *longopts, int *longindex);

Vous pouvez également analyser les options longues! Oh ~~ celui que je voulais savoir. Il n'y a pas de commande pour cela. Il semble que ce soit uniquement dans la libc GNU.

Muu. Distrait et pas bon aujourd'hui. Dormir YO

Se réveille. Je vais faire un peu.

Je n'ai pas compris le mot "membre" pour en savoir plus, alors j'ai appris

Comme pour les structures, les composants d'une classe sont appelés membres. Il existe des variables membres et des fonctions membres, mais cela revient à écrire des déclarations de variables ordinaires et des prototypes de fonctions. Comme il est déclaré ici, il n'est pas nécessaire d'écrire une déclaration de prototype à l'extérieur. https://cpp-lang.sevendays-study.com/day2.html#:~:text=%E3%83%A1%E3%83%B3%E3%83%90%E5%A4%89%E6%95%B0%E3%83%BB%E3%83%A1%E3%83%B3%E3%83%90%E9%96%A2%E6%95%B0,%E3%82%92%E6%9B%B8%E3%81%8F%E5%BF%85%E8%A6%81%E3%81%AF%E3%81%82%E3%82%8A%E3%81%BE%E3%81%9B%E3%82%93%E3%80%82

Faisons-le avec le sentiment des variables de classe et des méthodes de classe.

Si vous voulez associer --help & -h avec flags = NULL, val = 'h', il semble que d'appeler h de getopt (3) quand --help arrive. c'est fantastique

L'option qui prend une valeur booléenne (1 ou 0) peut être reflétée dans la variable telle quelle.

int opt_all = 0;

struct option[] = {
{"--all", no_argument, &opt_all, 1},

opt_all vaut zéro par défaut, et quand --all arrive, opt_all doit être mis à 1. Qu'est-ce que «&»?

Afficher l'adresse de la variable & var elle-même https://qiita.com/pen2000/items/fc5b06795dce3e0f679c

C'était un indicateur. Peut-être que je l'ai déclaré avec * et utilisé avec &. C'est comme mettre 1 à l'endroit où se trouve opt_all. C-lang est difficile ...

Commande Head avec --lines et -n

#include <stdio.h>
#include <stdlib.h>
#define _GNU_SOURCE
#include <getopt.h>    //Lire la déclaration du prototype de GNU SOURCE

static void do_head(FILE *f, long nlines);

#define DEFAULT_N_LINES 10

static struct option longopts[] = {
    {"lines", required_argument, NULL, 'n'},
    {"help", no_argument, NULL, 'h'},
    {0, 0, 0, 0}   // <--------Marquant que c'est le dernier arrangement. Routine
};

int
main(int argc, char *argv[])
{
    int opt;
    long nlines = DEFAULT_N_LINES;

    while ((opt = getopt_long(argc, argv, "n:", longopts, NULL)) != -1) {
        switch (opt) {
            case 'n':
                nlines = atoi(optarg); //Le nombre de lignes est en optarg
                break;
            case 'h':
                fprintf(stdout, "Usage: %s [-n LINES] [FILE ...]\n", argv[0]);
                exit(0);
            case '?':
                //Puisqu'il s'agit de la gestion des erreurs, il est similaire à stderr. Le contenu est getopt_longtemps vous le donnera!
                fprintf(stderr, "Usage: %s [-n LINES] [FILE ...]\n", argv[0]);
                exit(1);
        }
    }

    if (optind == argc) {
		do_head(stdin, nlines);
    } else {
        int i;

    	for (i=optind; i < argc; i++) {
    	    FILE *f;

    	    f = fopen(argv[i], "r");
    	    if (!f) {
    	        perror(argv[i]);
    	        exit(1);
            }
            do_head(f, nlines);
            fclose(f);
    	}
    }
	exit(0);
}

static void
do_head(FILE *f, long nlines)
{
	int c;

	if (nlines <= 0) return;
	while ((c=getc(f)) != EOF) {
		if (putchar(c) < 0) exit(1);
		if (c == '\n') {
		    nlines--;
    		if (nlines == 0) return;
		}
	}
}

result

@local:~/repos/futu$  gcc -Wall head3.c && ./a.out -n 3 txt
0a
1b
2c
@local:~/repos/futu$  gcc -Wall head3.c && ./a.out --lines 3 txt
0a
1b
2c
@local:~/repos/futu$ 

Ça bouge.

Qu'est-ce qu'un tableau {} au lieu de []?

Qu'est-ce que c'est «n:»?

getopt_long(argc, argv, "n:", longopts, NULL)

const char * optdecl Est-ce une déclinaison d'option? Listez les options à analyser. Si -a, -t, -x, vous pouvez utiliser tax. Pour les arguments qui acceptent des paramètres, ajoutez : à la fin. Si x requiert une valeur, alors x:. Lorsque vous mélangez avec d'autres, peu importe l'ordre, laissez simplement x et: coller ensemble pour former un morceau. tax: ou x: ta.

L'option à utiliser cette fois est ↓

• -n
• --lines
• -h
• --help

Seuls les raccourcis sont spécifiés ici. Alors h et n: au lieu de n, car n prend un paramètre. -n 10 pour 10 lignes. Mais le troisième argument est simplement «n:», pas «hn:». Je ne pouvais pas comprendre la raison de cela. Il dit "N'écrivez que les options courtes que vous souhaitez analyser", mais qu'est-ce que l'analyse? Le switch case n'est-il pas une analyse? Inconnue.

    if (optind == argc) {

À ce stade, optind (index du tableau int argv) a toutes les options définies traitées. Les arguments qui entrent individuellement sont des arguments ordinaires autres que des options. Les parties a.txt et b.txt de head --lines 10 a.txt b.txt. Le reste est traité en tournant cet argument.

Remarques sur l'utilisation de la libc GPU

Vous utilisez probablement getopt () dans getopt_long et il extrait de la libc GNC. Le langage C fonctionne sur n'importe quel OS, mais celui utilisant la libc GNC ne fonctionne que sous Linux. Il n'y a pas de fenêtres GNU Si vous utilisez la libc GNU, sachez qu'elle ne peut être utilisée que sous Linux.

Utilisez gdb! !! !! !! !!

Kita! !! !! Je voulais savoir! !! !!

Je lis ce livre

<a target = "_ blank" href = "https://www.amazon.co.jp/gp/product/4797328355/ref=as_li_tl?ie=UTF8&camp=247&creative=1211&creativeASIN=4797328355&linkCode=as2&tag=lespacetranb7397102f2397f2397f3b3b > Programmation Linux ordinaire La voie royale de la programmation gcc qui peut être apprise du mécanisme de Linux <a target = "_ blank" href = "https://www.amazon.co.jp/gp/product/B075ST51Y5/ref=as_li_tl?ie=UTF8&camp=247&creative=1211&creativeASIN=B075ST51Y5&linkCode=as2&tag=aaa55pacetran15 > Programmation Linux ordinaire 2ème édition: La voie royale de la programmation gcc qui peut être apprise du mécanisme de Linux