Volgens mij is dit heel erg geweldig onderwerp voor beschrijving. Vroeger was het interessant om voor meer zaken een soort server op je computer op te zetten handige uitwisseling bestanden. Nadat ik verschillende en zelfs het protocol had geprobeerd, realiseerde ik me dat ik ze helemaal niet leuk vind, de eerste zien er, op zijn zachtst gezegd, slecht uit in de browser, de tweede, hoewel ze hun duidelijke voordelen hebben, maar verbinding maken netwerk schijf Ik wil het niet op de computers van anderen. Maar op een (mooie en zonnige) dag kwam ik een programma tegen genaamd HTTP Bestandsserver(kortweg HFS), installeerde het, configureerde het (sinds ik met de schoonste versie begon te werken, waren er wat problemen mee) en werd ik bijna verliefd op dit programma. Om toegang te krijgen tot mijn bestanden is het nu voldoende om elke browser te hebben, aangezien alle toegang plaatsvindt via een gewone webpagina. Ik heb ook een map gemaakt waarin de persoon kent het wachtwoord, kan een bestand rechtstreeks via de browser toevoegen. Bestanden van de server kunnen één voor één of in mappen tegelijk worden gedownload. Het programma zelf plaatst de map in een .tar-archief zonder compressie en verzendt deze om te downloaden. Tegelijkertijd ziet de site er vrij netjes uit, al kun je als je dat wenst (en voldoende kennis hebt) zelf een sitesjabloon schrijven. Herken wat het is geweldige manier voor gemakkelijke en handige bestandsoverdracht?

En hier is een voorbeeld van de pagina die je in het browservenster zult zien, zoals je kunt zien is alles mooi en netjes, je kunt veel mooie sjablonen vinden op het programmaforum:

Hoewel haar menu volledig aan staat Engels, voor mij is dit geen belemmering. En voor degenen die het Engels niet goed kennen, zal ik aan het einde van het artikel proberen zo volledig mogelijk uit te leggen waar alle secties van het menu voor verantwoordelijk zijn en hoe ze te gebruiken.

Dus laten we verder gaan met de installatie en HTTP-configuratie Bestandsserver:

1) Om u wat tijd te besparen, heb ik een HFS-assembly met een Russisch-talige websitesjabloon voorbereid en geproduceerd initiële installatie het programma zelf. Je kunt de assembly downloaden van mijn Yandex.Disk via de link. Als u zeker bent van uw capaciteiten, kunt u downloaden schone versie programma op de officiële website http://www.rejetto.com/hfs/

Dat is alles. Ik hoop dat je dit artikel nuttig vond. Klik op een van de onderstaande knoppen om je vrienden erover te vertellen. Abonneer u ook op site-updates door uw e-mailadres in het veld aan de rechterkant in te voeren.

Bedankt voor uw aandacht :)

Tags: Functies in C, prototype, beschrijving, definitie, oproep. Formele parameters en feitelijke parameters. Functieargumenten, passeren op waarde, passeren op aanwijzer. Retourwaarde.

Invoering

Hoe meer we C bestuderen, hoe groter de programma's worden. Wij verzamelen alle acties in één belangrijkste functie en we kopiëren dezelfde acties verschillende keren, waardoor tientallen variabelen met unieke namen ontstaan. Onze programma's zwellen aan en worden steeds minder begrijpelijk, de branches worden langer en vertakt.

Maar er is een uitweg uit deze situatie! Nu zullen we leren hoe we functies in C kunnen maken. Functies zullen ten eerste helpen dubbele code in afzonderlijke subprogramma's te scheiden, ten tweede zullen ze helpen het programma logisch in delen op te splitsen, en ten derde zullen functies in C veel kenmerken hebben die ermee verbonden zijn die het gebruik van nieuwe benaderingen voor het structureren van applicaties mogelijk maken.

Een functie is een benoemd onderdeel van een programma dat herhaaldelijk kan worden aangeroepen vanuit een ander deel van het programma (waarin de functie zichtbaar is). De functie kan een vaste of variabel getal argumenten, of kan geen argumenten hebben. Een functie kan een waarde retourneren of leeg (ongeldig) zijn en niets retourneren.

We zijn al bekend met veel functies en weten hoe we ze moeten aanroepen - dit zijn functies van de bibliotheken stdio, stdlib, string, conio, enz. Bovendien is main ook een functie. Het verschilt alleen van de andere doordat het het startpunt is bij het starten van de applicatie.
De C-functie is gedefinieerd in mondiale context. Functiesyntaxis: (, ...) ( )

Het eenvoudigste voorbeeld is een functie waaraan een getal moet doorgegeven worden soort vlotter en geeft het kwadraat van dit getal terug

#erbij betrekken #erbij betrekken float sqr(float x) ( float tmp = x*x; return tmp; ) void main() ( printf("%.3f", sqr(9.3f)); getch(); )

Binnen de sqr-functie hebben we een lokale variabele gemaakt waaraan de waarde van het argument is toegewezen. Het getal 9.3 werd als argument aan de functie doorgegeven. Het servicewoord return retourneert de waarde van de tmp-variabele. U kunt de functie als volgt herschrijven:

Zweven sqr(zweven x) ( return x*x; )

IN in dit geval De vermenigvuldiging wordt eerst uitgevoerd en vervolgens wordt de waarde geretourneerd. Als de functie niets retourneert, is het retourtype ongeldig. Een functie die bijvoorbeeld het kwadraat van een getal afdrukt:

Ongeldig printSqr(float x) ( printf("%d", x*x); return; )

in dit geval betekent return het verlaten van de functie. Als de functie niets retourneert, hoeft return niet te worden geschreven. Vervolgens voltooit de functie zijn voltooiing en keert de besturing terug naar de aanroepende functie.

Ongeldig printSqr(float x) ( printf("%d", x*x); )

Als de functie geen argumenten heeft, blijven de haakjes leeg. Je kunt ook het woord leegte schrijven:

Ongeldig printHelloWorld() ( printf("Hallo Wereld"); )

equivalent

Ongeldig printHelloWorld(void) ( printf("Hallo wereld"); )

Formele en feitelijke parameters

Bij het declareren van een functie worden formele parameters opgegeven, die vervolgens binnen de functie zelf worden gebruikt. Wanneer we een functie aanroepen, gebruiken we de feitelijke parameters. De werkelijke parameters kunnen elke variabele zijn geschikt type of constanten.

Laten we bijvoorbeeld zeggen dat er een functie is die het kwadraat van een getal retourneert en een functie die twee getallen optelt.

#erbij betrekken #erbij betrekken //De formele parameters hebben de namen a en b //door ze te gebruiken hebben we toegang tot de doorgegeven argumenten binnen de functie int sum(int a, int b) ( return a+b; ) float square(float x) ( return x*x; ) void main() ( // Werkelijke parameters kunnen elke naam hebben, inclusief geen naam int one = 1; float two = 2.0; // Pass variabelen, de tweede variabele wordt gecast het juiste type printf("%d\n", som(één, twee));

//Geef numerieke constanten door printf("%d\n", sum(10, 20)); //We geven numerieke constanten van het verkeerde type door, ze worden automatisch geconverteerd naar de gewenste printf("%d\n", sum(10, 20.f));//Een variabele van het type integer wordt geconverteerd naar een drijvende-kommatype printf("%.3f\n", square(one));
//Het argument kan ook een functieaanroep zijn die de gewenste waarde retourneert printf("%.3f\n", square(sum(2 + 4, 3)));

#erbij betrekken #erbij betrekken haal(); )

Houd er rekening mee dat typecasting impliciet en alleen indien mogelijk plaatsvindt. Als een functie een getal als argument ontvangt, kunt u dit niet doorgeven

variabele tekenreeks

#erbij betrekken #erbij betrekken void change(int a) ( a = 100; printf("%d\n", a); ) void main() ( int d = 200; printf("%d\n", d); change(d) ;printf("%d", d);

De programma's worden weergegeven
200
100
200
Het is duidelijk waarom. Binnen de functie werken we met de variabele x, die een kopie is van de variabele d. We veranderen de lokale kopie, maar de variabele d zelf verandert niet. Nadat de functie is afgesloten, wordt de lokale variabele vernietigd. De variabele d zal op geen enkele manier veranderen.
Hoe kun je dan de variabele veranderen? Om dit te doen, moet u het adres van deze variabele doorgeven. Laten we de functie herschrijven zodat deze een pointer accepteert typ int

#erbij betrekken #erbij betrekken void change(int *a) ( *a = 100; printf("%d\n", *a); ) void main() ( int d = 200; printf("%d\n", d); change (&d); printf("%d", d);

Nu wordt het programma uitgevoerd
200
100
100
Hier werd ook een lokale variabele aangemaakt, maar omdat het adres was doorgegeven, hebben we de waarde van de variabele d gewijzigd met behulp van zijn adres in RAM.

Bij het programmeren wordt de eerste methode voor het doorgeven van parameters passeren op waarde genoemd, de tweede - passeren op aanwijzer. Onthoud een eenvoudige regel: als u een variabele wilt wijzigen, moet u een verwijzing naar die variabele doorgeven aan de functie. Als u een aanwijzer wilt wijzigen, moet u daarom een ​​aanwijzer doorgeven aan een aanwijzer, enz. Laten we bijvoorbeeld een functie schrijven die de grootte heeft van een array van het type int en deze maken. Op het eerste gezicht zou de functie er ongeveer zo uit moeten zien:

#erbij betrekken #erbij betrekken #erbij betrekken void init(int *a, niet-ondertekende grootte) ( a = (int*) malloc(size * sizeof(int)); ) void main() ( int *a = NULL; init(a, 100); if (a = = NULL) ( printf("ERROR"); ) else ( printf("Oké..."); free(a); ) getch();

Maar deze functie geeft ERROR weer. We hebben het adres van de variabele doorgegeven. Binnen de init-functie is een lokale variabele gemaakt die het adres van de array opslaat. Nadat de functie was verlaten, werd deze lokale variabele vernietigd. Naast wat we niet konden bereiken gewenst resultaat, ontdekten we een geheugenlek: geheugen werd toegewezen aan de heap, maar er is niet langer een variabele die het adres van dit gebied zou opslaan.

Om een ​​object te wijzigen, moet u er een pointer naar doorgeven, in dit geval een pointer naar een pointer.

#erbij betrekken #erbij betrekken #erbij betrekken void init(int **a, niet-ondertekende grootte) ( *a = (int*) malloc(size * sizeof(int)); ) void main() ( int *a = NULL; init(&a, 100); if ( a == NULL) ( printf("ERROR"); ) else ( printf("Oké..."); free(a); ) getch();

Nu werkt alles zoals het hoort.
Nog een soortgelijk voorbeeld. Laten we een functie schrijven die een string als argument neemt en een verwijzing retourneert naar het geheugengebied waarnaar deze string is gekopieerd.

#erbij betrekken #erbij betrekken #erbij betrekken #erbij betrekken char* initByString(const char *str) ( char *p = (char*) malloc(strlen(str) + 1); strcpy(p, str); return p; ) void main() ( char *test = initByString( "Hallo wereld!"); printf("%s", test);

In dit voorbeeld is er geen sprake van een geheugenlek. We hebben geheugen toegewezen met behulp van malloc-functies, kopieerde de string daarheen en retourneerde vervolgens de pointer. De lokale variabelen zijn verwijderd, maar de testvariabele slaat het adres van een stukje geheugen op de heap op, zodat dit kan worden verwijderd met behulp van de gratis functie.

Functiedeclaratie en functiedefinitie. Creëer uw eigen bibliotheek

In C kun je een functie declareren voordat je deze definieert. Een functiedeclaratie, het prototype ervan, bestaat uit een retourwaarde, een functienaam en het type argumenten. De namen van de argumenten kunnen worden weggelaten. Bijvoorbeeld

#erbij betrekken #erbij betrekken //Functieprototypes. De namen van de argumenten hoeven niet in odd(int) geschreven te worden; int zelfs(int); void main() ( printf("if %d oneven? %d\n", 11, oneven(11)); printf("if %d oneven? %d\n", 10, oneven(10)); getch (); ) //Definitie van functies int even(int a) ( if (a) ( odd(--a); ) else ( return 1; ) ) int odd(int a) ( if (a) ( even( - -a); anders (retourneert 0; ) )

Dit is een gemengde recursie: de oneven functie retourneert 1 als het getal oneven is en 0 als het even is.

Meestal wordt de functiedeclaratie afzonderlijk in het .h-bestand geplaatst, en de functiedefinities in het .c-bestand. Het headerbestand vertegenwoordigt dus de interface van de bibliotheek en laat zien hoe u ermee kunt werken zonder op de inhoud van de code in te gaan.

Laten we een eenvoudige bibliotheek maken. Om dit te doen, moet u twee bestanden maken: één met de extensie .h en daar de functieprototypes plaatsen, en de andere met de extensie .c en daar de definities van deze functies plaatsen. Als u met een IDE werkt, moet het .h-bestand in de map Header-bestanden worden gemaakt en de codebestanden in de map Bestanden broncode. Laat de bestanden File1.h en File1.c heten
Laten we de vorige code herschrijven. Dit is hoe het headerbestand File1.h eruit zal zien

#ifndef _FILE1_H_ #define _FILE1_H_ int oneven(int); int zelfs(int); #endif

Inhoud van het broncodebestand File1.c

#include "Bestand1.h" int even(int a) ( if (a) ( oneven(--a); ) else ( return 1; ) ) in oneven(int a) ( if (a) ( even(-- a); ) anders ( retourneert 0; ) )

Onze belangrijkste functie

#erbij betrekken #erbij betrekken #include "File1.h" void main() ( printf("if %d oneven? %d\n", 11, oneven(11)); printf("if %d oneven? %d\n", 10, oneven(10));

Laten we eens kijken naar de kenmerken van elk bestand. Ons bestand, dat de hoofdfunctie bevat, bevat de bibliotheken die het nodig heeft, evenals het headerbestand File1.h. De compiler kent nu de functieprototypen, dat wil zeggen dat hij het retourtype, het aantal en type argumenten en de functienamen kent.

Het headerbestand bevat, zoals eerder vermeld, het functieprototype. Ook de gebruikte bibliotheken kunnen hier worden opgenomen. Macrobescherming #define _FILE1_H_ enz. gebruikt om te voorkomen dat bibliotheekcode tijdens het compileren opnieuw wordt gekopieerd. Deze lijnen kunnen worden vervangen door één

#pragma eenmaal int oneven(int); int zelfs(int);

Het broncodebestand File1.c bevat het headerbestand. Alles is zoals gewoonlijk logisch en eenvoudig. In headerbestanden is het gebruikelijk om, naast functieprototypes, constanten en macrovervangingen op te nemen en nieuwe gegevenstypen te definiëren. Bovendien kunt u in de headerbestanden uitgebreid commentaar geven op de code en voorbeelden van het gebruik ervan schrijven.

Een array als argument doorgeven

Zoals eerder vermeld, wordt de arraynaam vervangen door een pointer, dus het doorgeven van een eendimensionale array is gelijk aan het doorgeven van een pointer. Voorbeeld: de functie ontvangt een array en de grootte ervan en drukt af:

#erbij betrekken #erbij betrekken void printArray(int *arr, unsigned size) ( unsigned i; for (i = 0; i< size; i++) { printf("%d ", arr[i]); } } void main() { int x = {1, 2, 3, 4, 5}; printArray(x, 10); getch(); }

In dit voorbeeld zou de functie er als volgt uit kunnen zien

Void printArray(int arr, unsigned size) ( unsigned i; for (i = 0; i< size; i++) { printf("%d ", arr[i]); } }

Ik wil u er ook aan herinneren dat de regel voor het vervangen van een array door een pointer niet recursief is. Dit betekent dat het noodzakelijk is om tijdens het verzenden de afmetingen van de tweedimensionale array te specificeren

#erbij betrekken #erbij betrekken void printArray(int arr, unsigned size) ( unsigned i, j; for (i = 0; i< size; i++) { for (j = 0; j < 5; j++) { printf("%d ", arr[i][j]); } printf("\n"); } } void main() { int x = { { 1, 2, 3, 4, 5}, { 6, 7, 8, 9, 10}}; printArray(x, 2); getch(); }

Of je kunt schrijven

#erbij betrekken #erbij betrekken void printArray(int (*arr), niet-ondertekende grootte) ( niet-ondertekende i, j; for (i = 0; i< size; i++) { for (j = 0; j < 5; j++) { printf("%d ", arr[i][j]); } printf("\n"); } } void main() { int x = { { 1, 2, 3, 4, 5}, { 6, 7, 8, 9, 10}}; printArray(x, 2); getch(); }

Als tweedimensionale array dynamisch gemaakt, kunt u een pointer doorgeven aan een pointer. Een functie die bijvoorbeeld een array van woorden neemt en een array van gehele getallen retourneert die gelijk zijn aan de lengte van elk woord:

#erbij betrekken #erbij betrekken #erbij betrekken #erbij betrekken #define SIZE 10 unsigned* getLengths(const char **words, unsigned size) ( unsigned *lengths = NULL; unsigned i; lengtes = (unsigned*) malloc(size * sizeof(unsigned)); for (i = 0; i< size; i++) { lengths[i] = strlen(words[i]); } return lengths; } void main() { char **words = NULL; char buffer; unsigned i; unsigned *len = NULL; words = (char**) malloc(SIZE * sizeof(char*)); for (i = 0; i < SIZE; i++) { printf("%d. ", i); scanf("%127s", buffer); words[i] = (char*) malloc(128); strcpy(words[i], buffer); } len = getLengths(words, SIZE); for (i = 0; i < SIZE; i++) { printf("%d ", len[i]); free(words[i]); } free(words); free(len); getch(); }

In plaats van een pointer naar een array terug te sturen, kunt u een array doorgeven die moet worden gevuld

#erbij betrekken #erbij betrekken #erbij betrekken #erbij betrekken #define SIZE 10 void getLengths(const char **words, unsigned size, unsigned *out) ( unsigned i; for (i = 0; i< size; i++) { out[i] = strlen(words[i]); } } void main() { char **words = NULL; char buffer; unsigned i; unsigned *len = NULL; words = (char**) malloc(SIZE * sizeof(char*)); for (i = 0; i < SIZE; i++) { printf("%d. ", i); scanf("%127s", buffer); words[i] = (char*) malloc(128); strcpy(words[i], buffer); } len = (unsigned*) malloc(SIZE * sizeof(unsigned)); getLengths(words, SIZE, len); for (i = 0; i < SIZE; i++) { printf("%d ", len[i]); free(words[i]); } free(words); free(len); getch(); }

Hier eindigt de eerste kennismaking met de functies: het onderwerp is erg groot en is verdeeld in verschillende artikelen.

Verhaal

Te midden van moderne talen Bij het programmeren verscheen het trefwoord void voor het eerst in C++ om het concept van generieke verwijzingen te ondersteunen. Dankzij het snelle lenen van C++ echter de eerste normatief document, dat dit trefwoord bevatte, werd de C-taalstandaard, gepubliceerd door ANSI in 1989. Binnen de C++-taal werd void in 1998 gestandaardiseerd.

Vervolgens werden het void-trefwoord en de gerelateerde taalconstructies geërfd Java-talen en C#, D.

Syntaxis

Syntactisch gezien is void een van de typespecificaties die in more algemene groep advertentiespecificaties.

Semantiek

De semantiek van het trefwoord void is niet onderworpen aan de algemene semantiek van typespecificaties en is afhankelijk van de gebruiksmethode:

• Als de naam van het waardetype dat door een functie wordt geretourneerd: geeft aan dat de functie geen waarde retourneert en dat de aanroep van een dergelijke functie een lege expressie is. De hoofdtekst van een dergelijke functie mag geen return-instructies met expressies bevatten. Bijvoorbeeld:

  Leegte f() ;

• Als onderdeel van een functiedeclarator: geeft aan dat de functie een prototype heeft en geen parameters heeft. Bijvoorbeeld:

  Int f(nietig) ;

• Zoals de naam van het doeltype van een cast-bewerking: zo'n void cast betekent afstand doen van de waarde van de expressie die wordt gecast. Bijvoorbeeld:

  #define promote_ptr() ((void) (ptr++))

• Als onderdeel van de typenaam van een void pointer: zo'n pointer kan de waarden weergeven van alle pointers naar object en niet-object volledige soorten, d.w.z. adressen van eventuele objecten. Een lege aanwijzer is dus een gegeneraliseerde objectaanwijzer. void pointers zijn niet in staat de waarden van functiepointers weer te geven. Behalve in het geval van het casten van een const nul-pointer naar een functie-pointer in C, zijn er geen expliciete of impliciete conversies tussen lege pointers en functie-pointers.

Het leegtetype wordt gedefinieerd als een onvolledig type dat niet kan worden uitgebreid. Als gevolg hiervan mag dit type niet worden gebruikt als alleen volledige typen zijn toegestaan, zoals een parametertype in een functiedefinitie.

De C-taal vóór de introductie van void

Vóór de publicatie van de eerste C-standaard in 1989, die het trefwoord void in de taal introduceerde, was het gebruikelijk om functies te declareren die geen waarde retourneerden zonder typespecificaties te gebruiken. Hoewel deze declaratie semantisch gelijkwaardig was aan het declareren van een functie die een waarde van het type int retourneerde, benadrukte het opzettelijk weglaten van typespecificaties dat de functie geen specifieke waarde retourneerde. Bijvoorbeeld:

F(lange l) ( /* ... */ )

Op dezelfde manier werden functiedefinities zonder parameters geschreven met lege haakjes:

Int hoofd() ( /* ... */ )

Een pointer naar char werd gebruikt als algemene pointer. Bovendien, moderne normen vereisen dat de representatie- en uitlijningsvereisten voor void pointers dezelfde zijn als voor char pointers, wat betekent dat de typen uitwisselbaar zijn.

Het eerste standaarddialect van C (C89), hoewel er al mee geschreven kon worden trefwoord void stond dit gebruik van een impliciete int nog steeds toe om de compatibiliteit met bestaande code te behouden. Het moderne dialect C (C99) staat de afwezigheid van typespecificaties in typenamen en -declaraties niet toe.

Voorbeelden

C++