Το Borland C++ υποστηρίζει τρία ορίσματα main(). Τα δύο πρώτα είναι τα παραδοσιακά argc και argv. Αυτά είναι τα μόνα επιχειρήματα κύριες λειτουργίες(), που ορίζεται από το πρότυπο ANSI C. Επιτρέπουν τη μετάδοση ορισμάτων γραμμής εντολών στο πρόγραμμα. Τα ορίσματα της γραμμής εντολών είναι οι πληροφορίες που ακολουθούν το όνομα του προγράμματος γραμμή εντολών λειτουργικό σύστημα. Για παράδειγμα, όταν ένα πρόγραμμα μεταγλωττίζεται με τον ενσωματωμένο μεταγλωττιστή Borland, συνήθως πληκτρολογείται το bcc όνομα_προγράμματος

Οπου όνομα_προγράμματοςείναι το πρόγραμμα που θα μεταγλωττιστεί. Το όνομα του προγράμματος μεταβιβάζεται στον μεταγλωττιστή ως όρισμα.

Η παράμετρος argc περιέχει τον αριθμό των ορισμάτων της γραμμής εντολών και είναι ακέραιος. Είναι πάντα τουλάχιστον 1 επειδή το όνομα του προγράμματος χαρακτηρίζεται ως το πρώτο όρισμα. Η παράμετρος argv είναι ένας δείκτης σε έναν πίνακα δεικτών χαρακτήρων. Κάθε στοιχείο αυτού του πίνακα δείχνει ένα όρισμα γραμμής εντολών. Όλα τα ορίσματα της γραμμής εντολών είναι συμβολοσειρές. Όλοι οι αριθμοί μετατρέπονται από το πρόγραμμα σε εσωτερική μορφή. Το παρακάτω πρόγραμμα εκτυπώνει "Hello" ακολουθούμενο από το όνομα χρήστη, εάν πληκτρολογηθεί αμέσως μετά το όνομα του προγράμματος:

#περιλαμβάνω

{
if(argc!=2)
{
printf("Ξεχάσατε να πληκτρολογήσετε το όνομά σας\n");
επιστροφή 1;
}
printf("Γεια %s", argv);
επιστροφή 0;
}

Αν κληθεί αυτό το πρόγραμμαόνομα και το όνομα χρήστη είναι Sergey, τότε για να εκτελέσετε το πρόγραμμα θα πρέπει να πληκτρολογήσετε:
όνομα Σεργκέι.
Ως αποτέλεσμα του προγράμματος θα εμφανιστεί:
Γεια σου Σεργκέι.

Τα ορίσματα γραμμής εντολών πρέπει να διαχωρίζονται με κενά ή καρτέλες. Τα κόμματα, τα ερωτηματικά και οι παρόμοιοι χαρακτήρες δεν θεωρούνται διαχωριστικά. Για παράδειγμα:

Αποτελείται από τρεις γραμμές, ενώ

Χερμπ, Ρικ, Φρεντ

Αυτή είναι μία γραμμή - τα κόμματα δεν είναι οριοθέτες.

Εάν θέλετε να περάσετε μια συμβολοσειρά που περιέχει κενά ή καρτέλες ως ένα όρισμα, περικλείστε την διπλά εισαγωγικά. Για παράδειγμα, αυτό είναι ένα επιχείρημα:

"αυτό είναι ένα τεστ"

Είναι σημαντικό να δηλώσετε σωστά το argv. Η πιο χαρακτηριστική μέθοδος είναι:

Οι κενές παρενθέσεις δείχνουν ότι ο πίνακας δεν έχει σταθερό μήκος. Μπορείτε να αποκτήσετε πρόσβαση σε μεμονωμένα στοιχεία χρησιμοποιώντας την ευρετηρίαση argv. Για παράδειγμα, το argv δείχνει στην πρώτη γραμμή, η οποία περιέχει πάντα το όνομα του προγράμματος. Το argv δείχνει στην επόμενη γραμμή και ούτω καθεξής.

Παρακάτω είναι ένα μικρό παράδειγμα χρήσης ορισμάτων γραμμής εντολών. Μετρά αντίστροφα από την τιμή που καθορίζεται στη γραμμή εντολών και εκπέμπει ένα σήμα όταν φτάσει το μηδέν. Σημειώστε ότι το πρώτο όρισμα περιέχει έναν αριθμό που μετατρέπεται σε ακέραιο χρησιμοποιώντας την τυπική συνάρτηση atoi(). Εάν η συμβολοσειρά "display" υπάρχει ως το δεύτερο όρισμα, τότε ο ίδιος ο μετρητής θα εμφανιστεί στην οθόνη.

/* πρόγραμμα μέτρησης */

#περιλαμβάνω
#περιλαμβάνω
#περιλαμβάνω
int main(int argc, char *argv)
{
int disp, count?
εάν (argc<2)
{
printf("Πρέπει να εισαγάγετε το μήκος της μέτρησης\n");
printf("στη γραμμή εντολών. Δοκιμάστε ξανά.\n");
επιστροφή 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
else disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d", count);
printf("%c", "\a"); /* στους περισσότερους υπολογιστές αυτή είναι μια κλήση */
επιστροφή 0;
}

Σημειώστε ότι εάν δεν έχουν καθοριστεί ορίσματα, εμφανίζεται ένα μήνυμα σφάλματος. Αυτό είναι πιο τυπικό για προγράμματα που χρησιμοποιούν ορίσματα γραμμής εντολών για την έκδοση εντολών, εάν έγινε προσπάθεια εκτέλεσης του προγράμματος χωρίς τις σωστές πληροφορίες.

Για να αποκτήσετε πρόσβαση σε μεμονωμένους χαρακτήρες της γραμμής εντολών, προσθέστε ένα δεύτερο ευρετήριο στο argv. Για παράδειγμα, το παρακάτω πρόγραμμα εκτυπώνει όλα τα ορίσματα με τα οποία κλήθηκε, έναν χαρακτήρα κάθε φορά:

#περιλαμβάνω
int main(int argc, char *argv)
{
int t, i;
για(t=0; t {
i = 0;
ενώ(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(");
}
επιστροφή 0;
}

Πρέπει να θυμόμαστε ότι το πρώτο ευρετήριο είναι για την πρόσβαση στη συμβολοσειρά και το δεύτερο για την πρόσβαση στον χαρακτήρα της συμβολοσειράς.

Συνήθως τα argc και argv χρησιμοποιούνται για τη λήψη εντολών πηγής. Θεωρητικά, μπορείτε να έχετε έως και 32767 ορίσματα, αλλά τα περισσότερα λειτουργικά συστήματα δεν σας επιτρέπουν καν να το πλησιάσετε. Συνήθως, αυτά τα ορίσματα χρησιμοποιούνται για τον καθορισμό ενός ονόματος αρχείου ή επιλογών. Η χρήση ορισμάτων γραμμής εντολών δίνει στο πρόγραμμα μια επαγγελματική εμφάνιση και επιτρέπει στο πρόγραμμα να χρησιμοποιηθεί σε αρχεία δέσμης.

Εάν συμπεριλάβετε το αρχείο WILDARGS.OBJ που παρέχεται με το Borland C++, μπορείτε να χρησιμοποιήσετε χαρακτήρες μπαλαντέρ σε ορίσματα τύπου *.EXE. (Το Borland C++ χειρίζεται αυτόματα μοτίβα και αυξάνει το argc ανάλογα.) Για παράδειγμα, εάν συνδέσετε το WILDARGS.OBJ στο ακόλουθο πρόγραμμα, θα εκτυπώσει πόσα αρχεία ταιριάζουν με το όνομα του αρχείου που καθορίζεται στη γραμμή εντολών:

/* Συνδέστε αυτό το πρόγραμμα με το WILDARGS.OBJ */

#περιλαμβάνω
int main(int argc, char *argv)
{
εγγραφή int i;
printf("%d αρχεία ταιριάζουν με το καθορισμένο όνομα\n", argc-1);
printf("Είναι: ");
για(i=1; i printf("%s", argv[i]);
επιστροφή 0;
}

Εάν ονομάσουμε αυτό το πρόγραμμα WA και στη συνέχεια το εκτελέσουμε ως εξής, παίρνουμε τον αριθμό των αρχείων που έχουν την επέκταση EXE και μια λίστα με τα ονόματα αυτών των αρχείων:

Εκτός από το argc και το argv, το Borland C++ παρέχει επίσης ένα τρίτο όρισμα γραμμής εντολών -env. Η παράμετρος env επιτρέπει στο πρόγραμμα να έχει πρόσβαση σε πληροφορίες σχετικά με το περιβάλλον του λειτουργικού συστήματος. Η παράμετρος env πρέπει να ακολουθεί το argc και το argv και δηλώνεται ως εξής:

Όπως μπορείτε να δείτε, το env δηλώνεται με τον ίδιο τρόπο όπως το argv. Ακριβώς όπως το argv, αυτό είναι ένας δείκτης σε μια σειρά από συμβολοσειρές. Κάθε γραμμή είναι μια συμβολοσειρά περιβάλλοντος όπως ορίζεται από το λειτουργικό σύστημα. Η παράμετρος env δεν έχει αντίστοιχο με την παράμετρο argc, η οποία λέει πόσες γραμμές περιβάλλοντος υπάρχουν. Αντίθετα, η τελευταία γραμμή του περιβάλλοντος είναι μηδενική. Το παρακάτω πρόγραμμα εκτυπώνει όλες τις συμβολοσειρές περιβάλλοντος που ορίζονται αυτήν τη στιγμή στο λειτουργικό σύστημα:

/* αυτό το πρόγραμμα εκτυπώνει όλες τις γραμμές περιβάλλοντος */

#περιλαμβάνω
int main(int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]/ t++)
printf("%s\n", env[t]);
επιστροφή 0;
}

Σημειώστε ότι παρόλο που το argc και το argv δεν χρησιμοποιούνται από το πρόγραμμα, πρέπει να υπάρχουν στη λίστα παραμέτρων. Το C δεν γνωρίζει τα ονόματα των παραμέτρων. Αντίθετα, η χρήση τους καθορίζεται από τη σειρά με την οποία δηλώνονται οι παράμετροι. Στην πραγματικότητα, μπορείτε να καλέσετε την παράμετρο όπως θέλετε. Επειδή τα argc, argv και env είναι παραδοσιακά ονόματα, είναι καλύτερο να συνεχίσετε να τα χρησιμοποιείτε, έτσι ώστε όποιος διαβάζει το πρόγραμμα να μπορεί να αναγνωρίσει αμέσως ότι αυτά είναι ορίσματα στη συνάρτηση main().

Για τα προγράμματα, μια τυπική εργασία είναι η εύρεση της τιμής που ορίζεται στη συμβολοσειρά περιβάλλοντος. Για παράδειγμα, τα περιεχόμενα της συμβολοσειράς PATH επιτρέπουν στα προγράμματα να χρησιμοποιούν διαδρομές αναζήτησης. Το παρακάτω πρόγραμμα δείχνει πώς να βρείτε συμβολοσειρές που δηλώνουν τυπικές διαδρομές αναζήτησης. Χρησιμοποιεί την τυπική συνάρτηση βιβλιοθήκης strstr(), η οποία έχει το ακόλουθο πρωτότυπο:

Char *strstr(const char *str1, const char *str2);

Η συνάρτηση strstr() αναζητά τη συμβολοσειρά που δείχνει η str1 στη συμβολοσειρά που δείχνει η str2. Εάν βρεθεί μια τέτοια συμβολοσειρά, τότε επιστρέφεται ένας δείκτης στην πρώτη θέση. Εάν δεν βρεθεί αντιστοίχιση, η συνάρτηση επιστρέφει NULL.

/* το πρόγραμμα αναζητά τις συμβολοσειρές περιβάλλοντος για μια συμβολοσειρά που περιέχει PATH */

#περιλαμβάνω
#περιλαμβάνω
int main (int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]; t++)
{
if(strstr(env[t], "PATH"))
printf("%s\n", env[t]);
}
επιστροφή 0;
}

Κατά τη δημιουργία μιας εφαρμογής κονσόλας στη γλώσσα προγραμματισμού C++, δημιουργείται αυτόματα μια γραμμή πολύ παρόμοια με αυτήν:

int main(int argc, char* argv) // main() παράμετροι συνάρτησης

Αυτή η γραμμή είναι η κεφαλίδα της κύριας συνάρτησης main() , οι παράμετροι argс και argv δηλώνονται σε αγκύλες. Έτσι, εάν το πρόγραμμα εκτελείται μέσω της γραμμής εντολών, τότε είναι δυνατή η μεταφορά οποιασδήποτε πληροφορίας σε αυτό το πρόγραμμα, για αυτό υπάρχουν παράμετροι argc και argv. Η παράμετρος argc είναι τύπου δεδομένων int και περιέχει τον αριθμό των παραμέτρων που μεταβιβάζονται στην κύρια συνάρτηση. Επιπλέον, το argc είναι πάντα τουλάχιστον 1, ακόμη και όταν δεν περνάμε καμία πληροφορία, αφού το όνομα της συνάρτησης θεωρείται η πρώτη παράμετρος. Η παράμετρος argv είναι ένας πίνακας δεικτών σε συμβολοσειρές. Μόνο δεδομένα τύπου συμβολοσειράς μπορούν να περάσουν από τη γραμμή εντολών. Οι δείκτες και οι συμβολοσειρές είναι δύο μεγάλα θέματα για τα οποία έχουν δημιουργηθεί ξεχωριστές ενότητες. Έτσι, μέσω της παραμέτρου argv μεταδίδεται οποιαδήποτε πληροφορία. Ας αναπτύξουμε ένα πρόγραμμα που θα τρέξουμε μέσα από τη γραμμή εντολών των Windows και θα του περάσουμε κάποιες πληροφορίες.

// argc_argv.cpp: Καθορίζει το σημείο εισόδου για την εφαρμογή της κονσόλας. #include "stdafx.h" #include χρησιμοποιώντας namespace std? int main(int argc, char* argv) (αν (argc ><< argv<

// code Code::Blocks

// Κώδικας Dev-C++

// argc_argv.cpp: Καθορίζει το σημείο εισόδου για την εφαρμογή της κονσόλας. #περιλαμβάνω χρησιμοποιώντας namespace std? int main(int argc, char* argv) ( if (argc > 1)// αν περάσουμε ορίσματα, τότε το argc θα είναι μεγαλύτερο από 1 (ανάλογα με τον αριθμό των ορισμών) ( cout<< argv<

Μετά την αποσφαλμάτωση του προγράμματος, ανοίξτε τη γραμμή εντολών των Windows και σύρετε το εκτελέσιμο αρχείο του προγράμματός μας στο παράθυρο της γραμμής εντολών, η πλήρης διαδρομή προς το πρόγραμμα θα εμφανιστεί στη γραμμή εντολών (αλλά μπορείτε να γράψετε τη διαδρομή προς το πρόγραμμα χειροκίνητα), μετά που μπορείτε να πατήσετε ΕΙΣΑΓΩκαι το πρόγραμμα θα ξεκινήσει (βλ. Εικόνα 1).

Εικόνα 1 - Παράμετροι της κύριας συνάρτησης

Δεδομένου ότι μόλις εκτελέσαμε το πρόγραμμα και δεν του περάσαμε κανένα όρισμα, εμφανίστηκε το μήνυμα Όχι ορίσματα. Το σχήμα 2 δείχνει την εκκίνηση του ίδιου προγράμματος μέσω της γραμμής εντολών, αλλά με το όρισμα Open που έχει μεταβιβαστεί σε αυτό.

Εικόνα 2 - Παράμετροι της κύριας συνάρτησης

Το επιχείρημα είναι η λέξη Open , όπως μπορείτε να δείτε από το σχήμα, αυτή η λέξη εμφανίστηκε στην οθόνη. Μπορείτε να περάσετε πολλές παραμέτρους ταυτόχρονα, χωρίζοντάς τις με κόμμα. Εάν είναι απαραίτητο να μεταβιβαστεί μια παράμετρος που αποτελείται από πολλές λέξεις, τότε αυτές πρέπει να περικλείονται σε διπλά εισαγωγικά και στη συνέχεια αυτές οι λέξεις θα θεωρηθούν ως μία παράμετρος. Για παράδειγμα, το σχήμα δείχνει την έναρξη του προγράμματος, μεταβιβάζοντάς του ένα όρισμα που αποτελείται από δύο λέξεις - Λειτουργεί .

Εικόνα 3 - Παράμετροι της κύριας συνάρτησης

Και αν αφαιρέσετε τα εισαγωγικά. Τότε θα δούμε μόνο τη λέξη It. Εάν δεν σκοπεύετε να διαβιβάσετε καμία πληροφορία κατά την εκκίνηση του προγράμματος, τότε μπορείτε να αφαιρέσετε τα ορίσματα στη συνάρτηση main(), μπορείτε επίσης να αλλάξετε τα ονόματα αυτών των ορισμάτων. Μερικές φορές υπάρχουν τροποποιήσεις των παραμέτρων argc και argv, αλλά όλα εξαρτώνται από τον τύπο της εφαρμογής που δημιουργείται ή από το περιβάλλον ανάπτυξης.

Όταν δημιουργείτε αυτόματα μια εφαρμογή κονσόλας στη γλώσσα προγραμματισμού C++, δημιουργείται αυτόματα μια κύρια συνάρτηση που μοιάζει πολύ με αυτήν:

int main(int argc, char * argv)
{…}

Η κεφαλίδα συνάρτησης περιέχει την υπογραφή της κύριας συνάρτησης main() με ορίσματα argc και argv .
Εάν το πρόγραμμα εκτελείται μέσω της γραμμής εντολών, τότε είναι δυνατή η μεταφορά οποιασδήποτε πληροφορίας σε αυτό το πρόγραμμα. Υπάρχουν ορίσματα γραμμής εντολών argc και argv για αυτό.
Η παράμετρος argc είναι τύπου int και περιέχει τον αριθμό των παραμέτρων που μεταβιβάζονται στην κύρια συνάρτηση. Επιπλέον, το argc είναι πάντα τουλάχιστον 1, ακόμη και όταν δεν μεταβιβάζεται καμία πληροφορία στην κύρια συνάρτηση, αφού το όνομα της εφαρμογής θεωρείται η πρώτη παράμετρος.
Η παράμετρος argv είναι ένας πίνακας δεικτών σε συμβολοσειρές. Μόνο δεδομένα τύπου συμβολοσειράς μπορούν να περάσουν από τη γραμμή εντολών.

Όταν εκτελείτε ένα πρόγραμμα μέσω της γραμμής εντολών των Windows, μπορείτε να του μεταβιβάσετε κάποιες πληροφορίες. Σε αυτήν την περίπτωση, η γραμμή εντολών θα μοιάζει με αυτό:
Μονάδα δίσκου:\path\name.exe όρισμα1 επιχείρημα2 ...

Τα ορίσματα γραμμής εντολών διαχωρίζονται από ένα ή περισσότερα κενά.

Το όρισμα argv περιέχει το πλήρως αναγνωρισμένο όνομα εφαρμογής:

#περιλαμβάνω
χρησιμοποιώντας namespace std?

cout<< argv << endl;

επιστροφή 0;
}

Αποτέλεσμα εκτέλεσης

Παράδειγμα: Υπολογισμός του γινομένου δύο ακεραίων
Το πρόγραμμα χρησιμοποιεί τη συνάρτηση μετατροπής συμβολοσειράς σε ακέραιο αριθμό StrToInt() από εδώ .

#περιλαμβάνω
χρησιμοποιώντας namespace std?
int StrToInt(char*s) (…)
int main(int argc, char * argv) (

Int a = 0, b=0;

Εάν (argc > 1)

a = StrToInt(argv);

Εάν (argc > 2)

b = StrToInt(argv);

cout<< a <<«*» << b << «= « << a*b << endl;

επιστροφή 0;
}

Το πρόγραμμα ξεκινά ως

Αποτέλεσμα εκτέλεσης

Εντοπισμός σφαλμάτων ενός προγράμματος με ορίσματα γραμμής εντολών

Για να μεταβιβάσετε ορίσματα γραμμής εντολών κατά τον εντοπισμό σφαλμάτων ενός προγράμματος, πρέπει να έχετε πρόσβαση στο μενού Ιδιότητεςέργο.


Στην καρτέλα Ιδιότητες διαμόρφωσης ->Εντοπισμός σφαλμάτωνεπιλέγω Ορίσματα εντολώνκαι ορίστε τις αξίες τους.

Όταν εκτελείτε το πρόγραμμα σε λειτουργία εντοπισμού σφαλμάτων, τα ορίσματα που εισάγετε θα αντιμετωπίζονται από το πρόγραμμα ως ορίσματα γραμμής εντολών.

Μπορείτε να μεταβιβάσετε ορισμένα ορίσματα σε προγράμματα C. Όταν καλείται main() στην αρχή του υπολογισμού, μεταβιβάζονται σε αυτήν τρεις παράμετροι. Το πρώτο από αυτά καθορίζει τον αριθμό των ορισμάτων εντολής κατά την πρόσβαση στο πρόγραμμα. Το δεύτερο είναι ένας πίνακας δεικτών σε συμβολοσειρές χαρακτήρων που περιέχουν αυτά τα ορίσματα (ένα όρισμα ανά συμβολοσειρά). Το τρίτο είναι επίσης μια συστοιχία δεικτών σε συμβολοσειρές χαρακτήρων, χρησιμοποιείται για πρόσβαση στις παραμέτρους του λειτουργικού συστήματος (μεταβλητές περιβάλλοντος).

Οποιαδήποτε τέτοια γραμμή αντιπροσωπεύεται ως:

μεταβλητή = τιμή\0

Η τελευταία γραμμή μπορεί να βρεθεί από δύο μηδενικά.

Ας ονομάσουμε τα ορίσματα της συνάρτησης main() αντίστοιχα: argc, argv και env (οποιαδήποτε άλλα ονόματα είναι πιθανά). Στη συνέχεια επιτρέπονται οι ακόλουθες περιγραφές:

κύρια (int argc, char *argv)

κύρια (int argc, char *argv, char *env)

Ας υποθέσουμε ότι υπάρχει κάποιο πρόγραμμα prog.exe στη μονάδα δίσκου A:. Ας το αντιμετωπίσουμε ως εξής:

A:\>αρχείο prog.exe1 αρχείο2 αρχείο3

Στη συνέχεια, το argv είναι ένας δείκτης στη συμβολοσειρά A:\prog.exe, ο argv είναι ένας δείκτης στο αρχείο συμβολοσειράς1 και ούτω καθεξής. Το πρώτο πραγματικό επιχείρημα επισημαίνεται από το argv και το τελευταίο από το argv. Εάν argc=1, τότε δεν υπάρχουν παράμετροι μετά το όνομα του προγράμματος στη γραμμή εντολών. Στο παράδειγμά μας, argc=4.

αναδρομή

Η αναδρομή είναι μια μέθοδος κλήσης στην οποία μια συνάρτηση καλεί τον εαυτό της.

Σημαντικό σημείο στη σύνταξη ενός αναδρομικού προγράμματος είναι η οργάνωση της εξόδου. Είναι εύκολο να κάνουμε το λάθος εδώ ότι η συνάρτηση θα καλείται συνεχώς επ' αόριστον. Επομένως, η αναδρομική διαδικασία πρέπει, βήμα προς βήμα, να απλοποιήσει το πρόβλημα έτσι ώστε στο τέλος να εμφανιστεί μια μη αναδρομική λύση για αυτό. Η χρήση αναδρομής δεν είναι πάντα επιθυμητή, καθώς μπορεί να οδηγήσει σε υπερχείλιση στοίβας.

Λειτουργίες βιβλιοθήκης

Στα συστήματα προγραμματισμού, οι υπορουτίνες για την επίλυση κοινών προβλημάτων συνδυάζονται σε βιβλιοθήκες. Αυτές οι εργασίες περιλαμβάνουν: υπολογισμό μαθηματικών συναρτήσεων, εισαγωγή/εξαγωγή δεδομένων, επεξεργασία συμβολοσειρών, αλληλεπίδραση με εργαλεία λειτουργικού συστήματος κ.λπ. Η χρήση ρουτίνες βιβλιοθήκης σώζει τον χρήστη από την ανάγκη ανάπτυξης κατάλληλων εργαλείων και του παρέχει μια πρόσθετη υπηρεσία. Οι λειτουργίες που περιλαμβάνονται στις βιβλιοθήκες παρέχονται με το σύστημα προγραμματισμού. Οι δηλώσεις τους δίνονται σε αρχεία *.h (αυτά είναι τα λεγόμενα αρχεία include ή header). Επομένως, όπως αναφέρθηκε παραπάνω, στην αρχή του προγράμματος με τις λειτουργίες βιβλιοθήκης, θα πρέπει να υπάρχουν γραμμές όπως:

#περιλαμβάνω<включаемый_файл_типа_h>

Για παράδειγμα:

#περιλαμβάνω

Υπάρχουν επίσης δυνατότητες επέκτασης και δημιουργίας νέων βιβλιοθηκών με προγράμματα χρηστών.

Στις καθολικές μεταβλητές εκχωρείται μια σταθερή θέση στη μνήμη για τη διάρκεια του προγράμματος. Οι τοπικές μεταβλητές αποθηκεύονται στη στοίβα. Ανάμεσά τους υπάρχει μια περιοχή μνήμης για δυναμική κατανομή.

Οι συναρτήσεις malloc() και free() χρησιμοποιούνται για τη δυναμική κατανομή της ελεύθερης μνήμης. Η συνάρτηση malloc() εκχωρεί μνήμη, η συνάρτηση free() την ελευθερώνει. Τα πρωτότυπα αυτών των συναρτήσεων αποθηκεύονται στο αρχείο κεφαλίδας stdlib.h και μοιάζουν με αυτό:

void *malloc(size_t size);

void *free(void *p);

Η συνάρτηση malloc() επιστρέφει έναν δείκτη τύπου void. για σωστή χρήση, η τιμή της συνάρτησης πρέπει να μετατραπεί σε δείκτη στον κατάλληλο τύπο. Με επιτυχία, η συνάρτηση επιστρέφει έναν δείκτη στο πρώτο byte ελεύθερης μνήμης μεγέθους. Εάν δεν υπάρχει αρκετή μνήμη, επιστρέφεται η τιμή 0. Η λειτουργία sizeof() χρησιμοποιείται για τον προσδιορισμό του αριθμού των byte που απαιτούνται για μια μεταβλητή.

Ένα παράδειγμα χρήσης αυτών των συναρτήσεων:

#περιλαμβάνω

#περιλαμβάνω

p = (int *) malloc(100 * sizeof(int)); /* Εκχώρηση μνήμης για 100

ακέραιοι */

printf("Εκτός μνήμης\n");

για (i = 0; i< 100; ++i) *(p+i) = i; /* Использование памяти */

για (i = 0; i< 100; ++i) printf("%d", *(p++));

δωρεάν (p); /* Ελεύθερη μνήμη */

Πριν χρησιμοποιήσετε τον δείκτη που επιστράφηκε από το malloc(), πρέπει να βεβαιωθείτε ότι υπάρχει αρκετή μνήμη (ο δείκτης δεν είναι μηδενικός).

Προεπεξεργαστής

Ένας προεπεξεργαστής C είναι ένα πρόγραμμα που επεξεργάζεται την είσοδο σε έναν μεταγλωττιστή. Ο προεπεξεργαστής εξετάζει το πρόγραμμα πηγής και εκτελεί τις ακόλουθες ενέργειες: συνδέει τα δεδομένα αρχεία σε αυτό, εκτελεί αντικαταστάσεις και επίσης διαχειρίζεται τις συνθήκες μεταγλώττισης. Ο προεπεξεργαστής προορίζεται για γραμμές προγράμματος που ξεκινούν με το σύμβολο #. Μόνο μία εντολή (οδηγία προεπεξεργαστή) επιτρέπεται ανά γραμμή.

Διευθυντικός

#define αντικατάσταση αναγνωριστικού

προκαλεί το ακόλουθο κείμενο προγράμματος να αντικαταστήσει το αναγνωριστικό με το όνομα με το κείμενο αντικατάστασης (σημειώστε την έλλειψη ερωτηματικού στο τέλος αυτής της εντολής). Ουσιαστικά, αυτή η οδηγία εισάγει έναν ορισμό μακροεντολής (μακροεντολή), όπου "αναγνωριστικό" είναι το όνομα του ορισμού μακροεντολής και "υποκατάσταση" είναι η ακολουθία χαρακτήρων με τους οποίους ο προεπεξεργαστής αντικαθιστά το καθορισμένο όνομα όταν το βρίσκει στο κείμενο του προγράμματος. Το όνομα μιας μακροεντολής γράφεται συνήθως με κεφαλαία.

Εξετάστε παραδείγματα:

Η πρώτη γραμμή αναγκάζει το πρόγραμμα να αντικαταστήσει το αναγνωριστικό MAX με τη σταθερά 25. Η δεύτερη σάς επιτρέπει να χρησιμοποιείτε στο κείμενο αντί για το αρχικό σγουρό άγκιστρο (() τη λέξη BEGIN.

Σημειώστε ότι επειδή ο προεπεξεργαστής δεν ελέγχει τη συμβατότητα μεταξύ των συμβολικών ονομάτων των ορισμών μακροεντολών και του περιβάλλοντος στο οποίο χρησιμοποιούνται, συνιστάται να ορίζονται αυτά τα αναγνωριστικά όχι με την οδηγία #define, αλλά με τη λέξη-κλειδί const με ρητό τύπο ένδειξη (αυτό ισχύει περισσότερο για C + +):

const int MAX = 25;

(ο τύπος int μπορεί να παραλειφθεί, όπως έχει οριστεί από προεπιλογή).

Εάν η οδηγία #define μοιάζει με:

#define identifier(identifier, ..., identifier) ​​αντικατάσταση

και δεν υπάρχει κενό μεταξύ του πρώτου αναγνωριστικού και της αρχικής παρένθεσης, τότε αυτός είναι ένας ορισμός αντικατάστασης μακροεντολής με ορίσματα. Για παράδειγμα, μετά την εμφάνιση μιας γραμμής όπως:

#define READ(val) scanf("%d", &val)

δήλωση READ(y); αντιμετωπίζεται το ίδιο με το scanf("%d",&y);. Εδώ το val είναι ένα όρισμα και η μακροεντολή πραγματοποιείται με το όρισμα.

Εάν υπάρχουν μεγάλοι ορισμοί στην αντικατάσταση που συνεχίζονται στην επόμενη γραμμή, ένας χαρακτήρας \ τοποθετείται στο τέλος της επόμενης συνεχόμενης γραμμής.

Μπορείτε να τοποθετήσετε αντικείμενα διαχωρισμένα με ## χαρακτήρες σε έναν ορισμό μακροεντολής, για παράδειγμα:

#define PR(x, y) x##y

Μετά από αυτό, ο PR(a, 3) θα καλέσει την αντικατάσταση a3. Ή, για παράδειγμα, ένας μακροορισμός

#define z(a, b, c, d) a(b##c##d)

θα αλλάξει το z(sin, x, +, y) σε sin(x+y).

Ο χαρακτήρας # που τοποθετείται πριν από ένα όρισμα μακροεντολής υποδεικνύει ότι έχει μετατραπεί σε συμβολοσειρά. Για παράδειγμα, μετά την οδηγία

#define PRIM(var) printf(#var"= %d", var)

το ακόλουθο τμήμα του κειμένου του προγράμματος

μετατρέπεται ως εξής:

printf("year""= %d", έτος);

Ας περιγράψουμε άλλες οδηγίες προεπεξεργαστή. Η οδηγία #include έχει προηγηθεί. Μπορεί να χρησιμοποιηθεί σε δύο μορφές:

#include "όνομα αρχείου"

#περιλαμβάνω<имя файла>

Το αποτέλεσμα και των δύο εντολών είναι η συμπερίληψη αρχείων με το καθορισμένο όνομα στο πρόγραμμα. Το πρώτο φορτώνει ένα αρχείο από τον τρέχοντα κατάλογο ή τον κατάλογο που έχει καθοριστεί ως πρόθεμα. Η δεύτερη εντολή αναζητά το αρχείο σε τυπικές θέσεις που ορίζονται στο σύστημα προγραμματισμού. Εάν το αρχείο του οποίου το όνομα είναι γραμμένο σε διπλά εισαγωγικά δεν βρεθεί στον καθορισμένο κατάλογο, τότε η αναζήτηση θα συνεχιστεί στους υποκαταλόγους που καθορίζονται για την εντολή #include<...>. Οι οδηγίες #include μπορούν να είναι ένθετες μεταξύ τους.

Η επόμενη ομάδα οδηγιών σάς επιτρέπει να συγκεντρώνετε επιλεκτικά μέρη του προγράμματος. Αυτή η διαδικασία ονομάζεται μεταγλώττιση υπό όρους. Αυτή η ομάδα περιλαμβάνει τις οδηγίες #if, #else, #elif, #endif, #ifdef, #ifndef. Η βασική μορφή της οδηγίας #if είναι:

#αν σταθερή_έκφραση statement_sequence

Εδώ ελέγχεται η τιμή της σταθερής έκφρασης. Εάν είναι αληθές, τότε εκτελείται η δεδομένη ακολουθία εντολών και εάν είναι ψευδής, τότε αυτή η ακολουθία εντολών παραλείπεται.

Η ενέργεια της οδηγίας #else είναι παρόμοια με την ενέργεια της εντολής else στη γλώσσα C, για παράδειγμα:

#αν σταθερή_έκφραση

δήλωση_ακολουθία_2

Εδώ, αν η σταθερά έκφραση είναι αληθής, τότε εκτελείται η ακολουθία_των_τελεστών_1 και εάν είναι ψευδής, η ακολουθία_των_τελεστών_2.

Η οδηγία #elif σημαίνει μια ενέργεια τύπου "άλλο εάν". Η κύρια μορφή χρήσης του είναι η εξής:

#αν σταθερή_έκφραση

δήλωση_ακολουθία

#elif σταθερά_έκφραση_1

δήλωση_ακολουθία_1

#elif σταθερά_έκφραση_n

ακολουθία_δηλώσεων_n

Αυτή η φόρμα είναι παρόμοια με το κατασκεύασμα της γλώσσας C της φόρμας: αν...άλλο αν...άλλο αν...

Διευθυντικός

Αναγνωριστικό #ifdef

ορίζει εάν το καθορισμένο αναγνωριστικό έχει οριστεί επί του παρόντος, π.χ. αν περιλαμβανόταν σε οδηγίες της μορφής #define. Προβολή γραμμής

Αναγνωριστικό #ifndef

ελέγχει εάν το καθορισμένο αναγνωριστικό δεν έχει καθοριστεί αυτήν τη στιγμή. Οποιαδήποτε από αυτές τις οδηγίες μπορεί να ακολουθηθεί από έναν αυθαίρετο αριθμό γραμμών κειμένου, που ενδεχομένως περιέχουν μια δήλωση #else (δεν μπορεί να χρησιμοποιηθεί το #elif) και τελειώνει με τη γραμμή #endif. Εάν η συνθήκη που ελέγχεται είναι αληθής, τότε όλες οι γραμμές μεταξύ #else και #endif αγνοούνται και εάν είναι false, τότε οι γραμμές μεταξύ του check και #else (αν δεν υπάρχει λέξη #else, τότε #endif). Οι οδηγίες #if και #ifndef μπορούν να τοποθετηθούν η μία μέσα στην άλλη.

Δείτε την οδηγία

Αναγνωριστικό #undef

κάνει το καθορισμένο αναγνωριστικό να θεωρείται απροσδιόριστο, π.χ. δεν αντικαθίσταται.

Εξετάστε παραδείγματα. Οι τρεις οδηγίες είναι:

ελέγξτε αν έχει οριστεί το αναγνωριστικό WRITE (δηλαδή ήταν μια εντολή της μορφής #define WRITE...), και αν ναι, τότε το όνομα WRITE θεωρείται απροσδιόριστο, δηλ. δεν αντικαθίσταται.

οδηγίες

#define WRITE fprintf

ελέγξτε αν το αναγνωριστικό WRITE δεν έχει οριστεί και αν ναι, τότε προσδιορίζεται το αναγνωριστικό WRITE αντί για το όνομα fprintf.

Η οδηγία #error είναι γραμμένη με την ακόλουθη μορφή:

#error error_message

Εάν εμφανίζεται στο κείμενο του προγράμματος, τότε η μεταγλώττιση σταματά και εμφανίζεται ένα μήνυμα σφάλματος στην οθόνη εμφάνισης. Αυτή η εντολή χρησιμοποιείται κυρίως κατά τη φάση εντοπισμού σφαλμάτων. Σημειώστε ότι το μήνυμα σφάλματος δεν χρειάζεται να περικλείεται σε διπλά εισαγωγικά.

Η οδηγία #line προορίζεται να αλλάξει τις τιμές των μεταβλητών _LINE_ και _FILE_ που ορίζονται στο σύστημα προγραμματισμού C. Η μεταβλητή _LINE_ περιέχει τον αριθμό γραμμής του προγράμματος που εκτελείται αυτήν τη στιγμή. Το αναγνωριστικό _FILE_ είναι ένας δείκτης σε μια συμβολοσειρά με το όνομα του προγράμματος που μεταγλωττίζεται. Η οδηγία #line είναι γραμμένη ως εξής:

#line αριθμός "όνομα αρχείου"

Εδώ ο αριθμός είναι οποιοσδήποτε θετικός ακέραιος που θα εκχωρηθεί στη μεταβλητή _LINE_, το όνομα αρχείου είναι μια προαιρετική παράμετρος που υπερισχύει της τιμής του _FILE_.

Η οδηγία #pragma σάς επιτρέπει να μεταβιβάσετε ορισμένες οδηγίες στον μεταγλωττιστή. Για παράδειγμα, η γραμμή

υποδεικνύει ότι υπάρχουν συμβολοσειρές γλώσσας συναρμολόγησης σε ένα πρόγραμμα C. Για παράδειγμα:

Εξετάστε ορισμένα καθολικά αναγνωριστικά ή ονόματα μακροεντολών (ονόματα ορισμών μακροεντολών). Ορίζονται πέντε τέτοια ονόματα: _LINE_, _FILE_, _DATE_, _TIME_, _STDC_. Δύο από αυτά (_LINE_ και _FILE_) έχουν ήδη περιγραφεί παραπάνω. Το αναγνωριστικό _DATE_ καθορίζει μια συμβολοσειρά που αποθηκεύει την ημερομηνία μετάφρασης του αρχείου προέλευσης σε κώδικα αντικειμένου. Το αναγνωριστικό _TIME_ καθορίζει μια συμβολοσειρά που αποθηκεύει το χρόνο που το αρχείο προέλευσης μεταφράστηκε σε κώδικα αντικειμένου. Η μακροεντολή _STDC_ έχει τιμή 1 εάν χρησιμοποιούνται τυπικά καθορισμένα ονόματα μακροεντολών. Διαφορετικά, αυτή η μεταβλητή δεν θα οριστεί.

Συμβαίνει ότι τα δεδομένα μεταφέρονται στο πρόγραμμα από τη γραμμή εντολών όταν καλείται. Τέτοια δεδομένα ονομάζονται ορίσματα γραμμής εντολών. Μοιάζει με αυτό, για παράδειγμα:

./a.out test.txt ls -lt /home/peter/

Αυτό καλεί τα προγράμματα a.out (από τον τρέχοντα κατάλογο) και ls (από τον ίδιο κατάλογο που καθορίζεται στη μεταβλητή περιβάλλοντος PATH). Το πρώτο πρόγραμμα από τη γραμμή εντολών λαμβάνει μία λέξη - test.txt, το δεύτερο - δύο: -lt και /home/peter/.

Εάν το πρόγραμμα είναι γραμμένο σε C, τότε όταν ξεκινά, ο έλεγχος μεταφέρεται αμέσως στη συνάρτηση main(), επομένως είναι αυτή που λαμβάνει τα ορίσματα της γραμμής εντολών που εκχωρούνται στις παραμέτρους της μεταβλητής της.

Μέχρι στιγμής, έχουμε ορίσει τη συνάρτηση main() σαν να μην παίρνει καμία παράμετρο και να μην επιστρέφει τίποτα. Στην πραγματικότητα, στο C, οποιαδήποτε συνάρτηση από προεπιλογή (αν δεν έχει οριστεί κάτι άλλο) επιστρέφει έναν ακέραιο. Αυτό μπορεί να επαληθευτεί. Αν γράψετε τον κώδικα ως εξής:

main() ( printf("Γεια \n") ; επιστροφή 0 ; )

Τότε δεν θα προκύψει καμία προειδοποίηση ή σφάλμα κατά τη μεταγλώττιση. Το ίδιο θα συμβεί αν γράψουμε int main() . Αυτό αποδεικνύει ότι η προεπιλεγμένη συνάρτηση επιστρέφει έναν ακέραιο και όχι τίποτα (κενό). Αν και αυτό που επιστρέφει η συνάρτηση μπορεί πάντα να "παρακάμπτεται", για παράδειγμα, voidmain() ή float main() .

Όταν ένα πρόγραμμα καλείται από τη γραμμή εντολών, ένα ζεύγος δεδομένων μεταβιβάζεται πάντα σε αυτό:

1. ακέραιος αριθμός, δηλώνοντας τον αριθμό των λέξεων (στοιχεία που χωρίζονται με κενά) στη γραμμή εντολών όταν καλείται,
2. δείκτη σε πίνακα συμβολοσειρών, όπου κάθε γραμμή είναι μια λέξη από τη γραμμή εντολών.

Σημειώστε ότι λαμβάνεται υπόψη και το ίδιο το όνομα του προγράμματος. Για παράδειγμα, εάν η κλήση μοιάζει με αυτό:

./a.out 12 θέμα 2

Τότε το πρώτο όρισμα του προγράμματος είναι 4 και ο πίνακας συμβολοσειρών ορίζεται ως (./a.out", "12", "theme", "2").

Δώστε προσοχή στην ορολογία, υπάρχουν μόνο δύο ορίσματα προγράμματος (ένας αριθμός και ένας πίνακας), αλλά όσα ορίσματα γραμμής εντολών θέλετε. Τα ορίσματα της γραμμής εντολών "μεταφράζονται" σε ορίσματα προγράμματος (σε ορίσματα στη συνάρτηση main()).
Αυτά τα δεδομένα (αριθμός και δείκτης) μεταβιβάζονται στο πρόγραμμα ακόμα και όταν καλείται απλώς ονομαστικά χωρίς να του μεταβιβαστεί τίποτα: ./a.out. Σε αυτήν την περίπτωση, το πρώτο όρισμα είναι 1 και το δεύτερο όρισμα δείχνει έναν πίνακα με μία μόνο συμβολοσειρά (""./a.out").

Το γεγονός ότι τα δεδομένα διαβιβάζονται στο πρόγραμμα δεν σημαίνει ότι η συνάρτηση main() πρέπει να τα λάβει. Εάν η συνάρτηση main() ορίζεται χωρίς παραμέτρους, τότε δεν είναι δυνατή η πρόσβαση στα ορίσματα της γραμμής εντολών. Αν και τίποτα δεν σας εμποδίζει να τα στείλετε. Δεν θα προκύψει σφάλμα.

Για να αποκτήσετε πρόσβαση στα δεδομένα που διαβιβάζονται στο πρόγραμμα, πρέπει να αντιστοιχιστούν σε μεταβλητές. Δεδομένου ότι τα ορίσματα μεταβιβάζονται αμέσως στην main() , η κεφαλίδα της θα πρέπει να μοιάζει με αυτό:
κύρια (int n, char *arr)

Η πρώτη μεταβλητή (n) περιέχει τον αριθμό των λέξεων και η δεύτερη μεταβλητή περιέχει έναν δείκτη σε μια σειρά από συμβολοσειρές. Συχνά η δεύτερη παράμετρος γράφεται ως **arr . Ωστόσο, είναι το ίδιο. Θυμηθείτε ότι ο ίδιος ο πίνακας συμβολοσειρών περιέχει δείκτες σε συμβολοσειρές ως στοιχεία του. Και στη συνάρτηση περνάμε δείκτη στο πρώτο στοιχείο του πίνακα. Αποδεικνύεται ότι περνάμε δείκτη σε δείκτη, δηλ. **αρ.

Ασκηση
Γράψτε ένα πρόγραμμα όπως αυτό:

#περιλαμβάνω int main(int argc, char ** argv) ( int i; printf ("%d \n", argc) ; για (i= 0; i< argc; i++ ) puts (argv[ i] ) ; }

Εκτυπώνει τον αριθμό των λέξεων στη γραμμή εντολών όταν καλείται και κάθε λέξη σε μια νέα γραμμή. Ονομάστε το χωρίς ορίσματα γραμμής εντολών και με ορίσματα.

Στο πρόγραμμα χρησιμοποιήσαμε τις μεταβλητές παραμέτρους argc και argv. Είναι συνηθισμένο να χρησιμοποιούνται ακριβώς τέτοια ονόματα, αλλά στην πραγματικότητα μπορούν να είναι οτιδήποτε. Είναι καλύτερα να τηρείτε αυτό το πρότυπο, ώστε τα προγράμματά σας να είναι πιο κατανοητά όχι μόνο σε εσάς, αλλά και σε άλλους προγραμματιστές.

Η Πρακτική Σημασία της Μεταβίβασης Δεδομένων σε ένα Πρόγραμμα

Εάν έχετε εμπειρία με τη γραμμή εντολών GNU/Linux, γνωρίζετε ότι οι περισσότερες εντολές έχουν διακόπτες και ορίσματα. Για παράδειγμα, κατά την προβολή των περιεχομένων των καταλόγων, την αντιγραφή, τη μετακίνηση, τα αντικείμενα του συστήματος αρχείων στα οποία εκτελείται η εντολή καθορίζονται ως ορίσματα. Τα χαρακτηριστικά της εφαρμογής του καθορίζονται χρησιμοποιώντας κλειδιά. Για παράδειγμα, στην εντολή

Cp -r ../les_1 ../les_101

cp είναι το όνομα της εντολής, -r είναι ο διακόπτης και ../les_1 και ../les_101 είναι τα ορίσματα της εντολής.

Γενικά, τις περισσότερες φορές, κατά την εκκίνηση προγραμμάτων, μεταφέρονται διευθύνσεις αρχείων και "τροποποιητές" (αυτοί είναι κλειδιά) της διαδικασίας εκτέλεσης του προγράμματος.

Ας γράψουμε ένα πρόγραμμα που ανοίγει τα αρχεία που έχει ορίσει ο χρήστης στη γραμμή εντολών για εγγραφή ή προσθήκη και γράφει (προσθέτει) εκεί τις ίδιες πληροφορίες που εισάγει ο χρήστης από το πληκτρολόγιο κατά την εκτέλεση του προγράμματος:

#περιλαμβάνω #περιλαμβάνω κύρια (int argc, char ** argv) ( int i, ch; FILE * f[ 5 ] ; if (argc< 3 || argc >7 ) ( βάζει ( "Μη έγκυρος αριθμός παραμέτρων") ; επιστροφή 1 ; ) if (strcmp (argv[ 1 ] , "-w" ) != 0 && strcmp (argv[ 1 ] , "-a" ) != 0 ) ( βάζει ( "Η πρώτη παράμετρος μπορεί να είναι -w ή -a") ; επιστροφή 2 ; ) για (i= 0 ; i< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf ("Το αρχείο %s δεν μπορεί να ανοίξει\n", argv[ i+ 2 ] ) ; επιστροφή 3 ; ) ) ενώ ((ch = getchar () ) != EOF) για (i= 0 ; i< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

Επεξηγήσεις για τον κώδικα:

1. Δημιουργείται ένας πίνακας πέντε δεικτών αρχείων. Επομένως, δεν μπορούν να ανοίξουν περισσότερα από πέντε αρχεία ταυτόχρονα. Ο δείκτης αρχείου του πρώτου αρχείου θα αποθηκευτεί στο στοιχείο f του πίνακα, το δεύτερο - στο f και ούτω καθεξής.
2. Ο αριθμός των ορισμάτων της γραμμής εντολών ελέγχεται. Πρέπει να είναι τουλάχιστον τρεις από αυτούς, γιατί. το πρώτο είναι το όνομα του προγράμματος, το δεύτερο είναι η λειτουργία ανοιχτού αρχείου, το τρίτο είναι το πρώτο ή το μοναδικό αρχείο στο οποίο πρέπει να εγγραφεί. Δεδομένου ότι το πρόγραμμα σάς επιτρέπει να ανοίγετε μόνο πέντε αρχεία, ο συνολικός αριθμός των ορισμάτων της γραμμής εντολών δεν μπορεί να υπερβαίνει τα επτά. Επομένως, εάν ο αριθμός των ορισμάτων είναι μικρότερος από 3 ή μεγαλύτερος από 7, τότε το πρόγραμμα τελειώνει, επειδή Η δήλωση επιστροφής προκαλεί την έξοδο της συνάρτησης, ακόμα κι αν υπάρχει περισσότερος κώδικας μετά από αυτήν. Μια συνάρτηση που επιστρέφει τιμή που δεν είναι ίση με 0 μπορεί να ερμηνευτεί από τη γονική διαδικασία ως μήνυμα ότι το πρόγραμμα τερματίστηκε με σφάλμα.
3. Ελέγχεται η ορθότητα του δεύτερου ορίσματος της γραμμής εντολών. Αν δεν είναι ούτε "-w" ούτε "-a", τότε η υπό όρους έκφραση στο δεύτερο if επιστρέφει 1 (true). Η συνάρτηση strcmp() σάς επιτρέπει να συγκρίνετε συμβολοσειρές και επιστρέφει 0 εάν είναι ίσες.
4. Ο βρόχος for ανοίγει αρχεία στις καθορισμένες διευθύνσεις που ξεκινούν από το τρίτο στοιχείο του πίνακα argv. Γι' αυτό προστίθεται 2 στο i για να ληφθούν τα στοιχεία του πίνακα argv, ξεκινώντας από το τρίτο. Η έκφραση argc-2 υποδεικνύει τον αριθμό των ονομάτων αρχείων που έχουν περάσει. επειδή Το argc αποθηκεύει τον συνολικό αριθμό ορισμάτων της γραμμής εντολών, τα δύο πρώτα από τα οποία δεν είναι ονόματα αρχείων.
5. Η έκφραση argv+1 σάς επιτρέπει να "κόψετε" την υποσυμβολοσειρά "w" (ή "a") από τη συμβολοσειρά "-w" (ή "-a"), επειδή Το argv είναι ουσιαστικά ένας δείκτης στο πρώτο στοιχείο της συμβολοσειράς. Προσθέτοντας ένα στον δείκτη, τον μετατοπίζουμε στο επόμενο στοιχείο του πίνακα.
6. Εάν το αρχείο δεν μπορεί να ανοίξει, η συνάρτηση fopen() επιστρέφει NULL. Σε αυτήν την περίπτωση, το πρόγραμμα τελειώνει.
7. Κάθε χαρακτήρας που εισάγει ο χρήστης από το πληκτρολόγιο εγγράφεται σε όλα τα ανοιχτά αρχεία.
8. Στο τέλος, τα αρχεία κλείνουν.