Co oznacza int main w c. Różnica między int main() i int main(void)? Parametry formalne i faktyczne

Funkcja główna.

Każdy program w C i C++ musi mieć funkcję główną; i od Ciebie zależy, gdzie go umieścisz. Niektórzy programiści umieszczają go na początku pliku, inni na końcu. Niezależnie jednak od jej położenia należy pamiętać o następujących kwestiach: Argumenty funkcji „głównej”. Procedura startowa Borland C++ wysyła do funkcji głównej trzy parametry (argumenty): argc, argv i env. - argc, liczba całkowita, to liczba argumentów linii poleceń wysłanych do funkcji głównej, - argv to tablica wskaźników do łańcuchów (char *). W systemie DOS 3.x i nowszych wersjach argv definiuje się jako pełną ścieżkę programu, który ma zostać uruchomiony. Podczas uruchamiania we wcześniejszych wersjach DOS-u argv wskazuje na ciąg zerowy („”). argv wskazuje pierwszą linię poleceń po nazwie programu. argv wskazuje na drugą linię poleceń po nazwie programu. argv wskazuje na ostatni argument wysłany do main. argv zawiera NULL. - env to także tablica wskaźników do ciągów znaków. Każdy element env zawiera ciąg znaków w postaci ENVVAR=wartość. ENVVAR to nazwa zmiennej środowiskowej, takiej jak PATH lub 87.<значение>jest to wartość danej zmiennej środowiskowej, na przykład C:\DOS;C:\TOOLS (dla PATH) lub YES (dla 87). Należy jednak pamiętać, że jeśli określisz niektóre z tych argumentów, musisz je podać w następującej kolejności: argc, argv, env. Na przykład poprawne są następujące deklaracje argumentów: main() main(int argc) /* poprawne, ale niezbyt dobre */ main(int argc, char *argv) main(int argc, char *argv, char *env) Main (int)deklaracja argc) nie jest zbyt wygodna, ponieważ znając liczbę parametrów, sam nie masz do nich dostępu. Argument env jest zawsze dostępny poprzez zmienną globalną environ. Zobacz zmienną environ (w rozdziale 3) oraz funkcje putenv i getenv (w rozdziale 2). Parametry argc i argv są również dostępne poprzez zmienne _argc i _argv. Przykładowy program wykorzystujący argc, argv i env. To jest przykładowy program ARGS.EXE, który demonstruje najprostszy sposób użycia argumentów przekazanych do funkcji głównej. /* Program ARGS.C */ #include #włączać void main(int argc, char *argv, char *env) ( int i; printf("Wartość argc to %d \n\n",argc); printf("Wiersz poleceń zawiera parametry %d \n\ n" ,argc); for (i=0; tj<=argc; i++) printf(" argv[%d]: %s\n",i,argv[i]); printf("Среда содержит следующие строки:\n"); for (i=0; env[i] != NULL; i++) printf(" env[%d]: %s\n",i,env[i]); return 0; } Предположим, что вы запускаете программу ARGS.EXE со следующей командной строкой: C:> args pierwszy_arg "arg ze spacjami" 3 4 "przedostatni" stop! Zauważ, że możesz wysłać argument ze spacjami, umieszczając go w podwójnym cudzysłowie, jak pokazano w przykładzie „argument ze spacjami” i „przedostatni” w wywołaniu programu. W wyniku uruchomienia programu otrzymasz coś takiego: Wartość argc wynosi 7. Linia poleceń zawiera 7 parametrów argv: c:\turboc\testargs.exe argv: pierwszy_arg argv: arg z pustym argv: 3 argv: 4 argv: przedostatni argv: przestań! Środowisko zawiera następujące wiersze: env: COMSPEC=C:\COMMAND.COM env: PROMPT=$p $g env: PATH=C:\SPRINT;C:\DOS;C:\BC Maksymalna całkowita długość polecenia linia wysyłana do funkcji głównej (ze spacjami i samą nazwą programu) nie może przekraczać 128 znaków; Są to ograniczenia DOS-u. Znaki ucieczki w wierszu poleceń Argumenty w wierszu poleceń mogą zawierać znaki ucieczki. Można je jednak rozwinąć dla wszystkich nazw plików pasujących do argumentu w taki sam sposób, jak ma to miejsce na przykład za pomocą polecenia kopiowania DOS. Aby użyć symboli ucieczki, łącząc program z linkerem, musisz dołączyć plik obiektowy WILDARGS.OBJ dostarczany z Borland C++. Jeśli do programu dołączony jest plik WILDARGS.OBJ, w wierszu poleceń można użyć argumentów takich jak „*.*”. W tym przypadku nazwy wszystkich plików pasujących do tej maski są wprowadzane do tablicy argv. Maksymalny rozmiar tablicy argv zależy tylko od rozmiaru obszaru pamięci dynamicznej. Jeżeli dla danej maski nie znaleziono odpowiednich plików, to argument przekazywany jest w takiej postaci, w jakiej został wpisany w linii poleceń. (Oznacza to, że do funkcji głównej przekazywany jest ciąg znaków zawierający znaki ucieczki). Argumenty ujęte w cudzysłów („…”) nie są rozwijane. Przykład. Następujące polecenia kompilują plik ARGS.C i łączą go z modułem WILDARGS.OBJ, a następnie uruchamiają powstały program ARGS.EXE: bcc args wildarg.obj args C:\BORLANDC\INCLUDE\*.H "*.C" Podczas uruchamiania ARGS.EXE pierwszy argument rozwija się do nazw wszystkich plików z rozszerzeniem H w katalogu Borland C++ INCLUDE. Należy pamiętać, że wszystkie linie zawierają pełną trasę (na przykład C:\TC\INCLUDE\ALLOC.H). Argument *.C nie jest rozwijany, ponieważ jest on ujęty w cudzysłów. Jeśli pracujesz w zintegrowanym środowisku (BC.EXE), wystarczy podać w menu projektu nazwę pliku projektu, która powinna zawierać następujące wiersze: ARGS WILDARGS.OBJ Następnie za pomocą opcji „Uruchom/Argumenty ", należy ustawić parametry wiersza poleceń. Komentarz. Jeśli chcesz, aby przetwarzanie znaków ucieczki zawsze miało miejsce, tj. Aby plik WILDARGS.OBJ był automatycznie łączony przez edytor linków, musisz zmodyfikować swoją standardową bibliotekę C?.LIB tak, aby zawierała plik WILDARGS.OBJ. Aby to zrobić, usuń SETARGV z biblioteki i dodaj WILDARGS. Można to zrobić za pomocą następujących poleceń (zakładamy, że biblioteki standardowe i WILDARGS.OBJ znajdują się w bieżącym katalogu): TLIB opisano w rozdziale 7, Narzędzia, Podręcznika użytkownika. tlib cs -setargv +wildargs tlib cc - setargv +wildargs tlib cm -setargv +wildargs tlib cl -setargv +wildargs tlib ch -setargv +wildargs Kompilacja przy użyciu przełącznika -p (konwencja wywoływania Pascala) Jeśli kompilujesz program przy użyciu konwencji wywoływania Pascala (opisanej szczegółowo w Rozdziale 9 „ Interfejs z językiem asemblera”, „Poradnik programisty”), należy pamiętać, że funkcja główna musi być jawnie zadeklarowana jako funkcja C. Można to zrobić za pomocą słowo kluczowe cdecl wygląda mniej więcej tak: cdecl main(int argc, char *argv, char *env) Wartość zwracana przez funkcję main. Funkcja main zwraca wartość będącą kodem wyjścia programu: jest to liczba całkowita. Jeśli jednak Twój program użyje funkcji exit (lub _exit) do wyjścia, wówczas zwracana wartość będzie argumentem tej funkcji. Na przykład, jeśli Twój program zawiera wywołanie: exit(1), wówczas kodem wyjścia będzie 1. Jeśli do uruchomienia programu używasz zintegrowanego środowiska Borland C++ (BC.EXE), możesz zobaczyć wartość zwracaną przez funkcję główną funkcję, wybierając „Plik | Uzyskaj informacje”.

Strona 53 z 85

1.5.3. Przekazywanie parametrów do funkcji main

Funkcję główną rozpoczynającą wykonanie programu w języku C można zdefiniować za pomocą parametrów przekazywanych ze środowiska zewnętrznego, na przykład z wiersza poleceń. Środowisko zewnętrzne ma swoje własne zasady reprezentacji danych, a raczej wszystkie dane są prezentowane w postaci ciągów znaków. Aby przekazać te ciągi do funkcji głównej, używane są dwa parametry, pierwszy parametr służy do przesyłania liczby ciągów do przesłania, drugi służy do przesyłania samych ciągów. Typowe (ale nie wymagane) nazwy tych parametrów to argc i argv. Parametr argc jest typu int, jego wartość powstaje na podstawie analizy linii poleceń i jest równa liczbie słów w linii poleceń, łącznie z nazwą wywoływanego programu (słowo to dowolny tekst nie zawierający spacji postać). Parametr argv jest tablicą wskaźników do ciągów znaków, z których każdy zawiera jedno słowo z wiersza poleceń. Jeśli słowo musi zawierać znak spacji, podczas zapisywania go w wierszu poleceń musi być ujęte w cudzysłów.

Funkcja główna może posiadać także trzeci parametr, który zwykle nazywany jest argp i który służy do przekazania do funkcji głównej parametrów systemu operacyjnego (środowiska), w którym wykonywany jest program w języku programowania C.

Główny nagłówek funkcji wygląda następująco:

Jeżeli np. linia poleceń programu w języku programowania C wygląda następująco:

Odp.:\>cprog działający „program C” 1

wówczas argumenty argc, argv, argp są reprezentowane w pamięci, jak pokazano na schemacie na ryc. 1.

Argc[4]
argv --> -->
-->
-->
-->
argp --> -->
-->
-->
-->
Ryc.1. Układ opcji wiersza poleceń

System operacyjny obsługuje przekazywanie wartości parametrów argc, argv, argp i obowiązkiem użytkownika jest przekazanie i wykorzystanie rzeczywistych argumentów do funkcji głównej.

Poniższy przykład to program, który wypisuje rzeczywiste argumenty przekazane do funkcji głównej z systemu operacyjnego i parametrów systemu operacyjnego.

Przykład:
int main (int argc, char *argv, char *argp)
( int i=0;
printf("\nNazwa programu %s", argv);
dla (i=1; i>=argc; i++)
printf("\n argument %d to %s", argv[i]);
printf("\nUstawienia systemu operacyjnego:");
podczas gdy (*argp)
( printf („\n %s”,*argp);
argp++;
}
powrót(0);
}

Dostęp do parametrów systemu operacyjnego można również uzyskać za pomocą funkcji biblioteki geteuv; jej prototyp wygląda następująco:

char *geteuv (stała char *nazwa_zmiennej);

Argument tej funkcji określa nazwę parametru środowiskowego, wskaźnik do którego wartości zostanie zwrócony przez funkcję geteuv. Jeśli określony parametr nie jest aktualnie zdefiniowany w środowisku, zwracaną wartością będzie NULL.

Za pomocą wskaźnika uzyskanego funkcją geteuv można jedynie odczytać wartość parametru systemu operacyjnego, ale nie można jej zmienić. Funkcja puteuv służy do zmiany wartości parametru systemowego.

Kompilator języka programowania C konstruuje program w języku C w taki sposób, że na początku programu wykonywana jest pewna inicjalizacja, obejmująca między innymi przetwarzanie argumentów przekazanych do funkcji głównej i przekazanie jej wartości parametrów środowiskowych. Akcje te są wykonywane przez funkcje biblioteczne _setargv i _seteuv, które kompilator zawsze umieszcza przed funkcją główną.

Jeżeli program w języku programowania C nie wykorzystuje przekazywania argumentów i wartości parametrów systemu operacyjnego, wówczas wskazane jest zakazanie korzystania z funkcji bibliotecznych _setargv i _seteuv poprzez umieszczenie w programie C w języku programowania, przed funkcją główną funkcje o tych samych nazwach, ale które nie wykonują żadnych akcji (odgałęzień). Początek programu w tym przypadku będzie wyglądał następująco:

setargv()
}
-seteuv()
( return ; /* pusta funkcja */
}
int główny()
( /* funkcja główna bez argumentów */
...
...
renur (0);
}

W powyższym programie przy wywołaniu funkcji bibliotecznych _setargv i _seteuv funkcje umieszczone w programie przez użytkownika zostaną wykorzystane i nie wykonają żadnych akcji. Spowoduje to znaczne zmniejszenie rozmiaru wynikowego pliku exe.

Borland C++ obsługuje trzy argumenty funkcji main(). Pierwsze dwa to tradycyjne argc i argv. Są to jedyne argumenty funkcji main() zdefiniowane w standardzie ANSI C. Umożliwiają przekazywanie do programu argumentów wiersza poleceń. Argumenty wiersza poleceń to informacje występujące po nazwie programu w wierszu poleceń systemu operacyjnego. Na przykład, gdy program jest kompilowany przy użyciu kompilatora liniowego Borland, zwykle wpisuje się go jako bcc Nazwa programu

Gdzie Nazwa programu to program, który należy skompilować. Nazwa programu jest przekazywana do kompilatora jako argument.

Parametr argc zawiera liczbę argumentów wiersza poleceń i jest liczbą całkowitą. Jest zawsze równa co najmniej 1, ponieważ nazwa programu kwalifikuje się jako pierwszy argument. Parametr argv jest wskaźnikiem do tablicy wskaźników znakowych. Każdy element tej tablicy wskazuje na argument wiersza poleceń. Wszystkie argumenty wiersza poleceń są ciągami znaków. Wszystkie liczby są konwertowane przez program do formatu wewnętrznego. Poniższy program wypisuje słowo „Hello”, po którym następuje nazwa użytkownika, jeśli zostanie wpisana bezpośrednio po nazwie programu:

#włączać

{
jeśli(argc!=2)
{
printf("Zapomniałeś wpisać swoje imię\n");
zwróć 1;
}
printf("Witam %s", argv);
zwróć 0;
}

Jeśli wywołasz tę nazwę programu, a nazwa użytkownika to Sergey, to aby uruchomić program, powinieneś wpisać:
imię Siergiej.
W wyniku działania programu wyświetli się:
„Witam, Siergiej”.

Argumenty wiersza poleceń muszą być oddzielone spacjami lub tabulatorami. Przecinki, średniki i podobne znaki nie są uważane za ograniczniki. Na przykład:

Składa się z trzech linii, podczas gdy

Herb, Rick, Fred

To jest jedna linia – przecinki nie są ogranicznikami.

Jeśli chcesz przekazać ciąg zawierający spacje lub tabulatory jako pojedynczy argument, musisz ująć go w cudzysłów. Na przykład jest to jeden z argumentów:

"to jest test"

Ważne jest, aby poprawnie zadeklarować argv. Najbardziej typową metodą jest:

Puste nawiasy wskazują, że tablica nie ma stałej długości. Możesz uzyskać dostęp poszczególne elementy przy użyciu indeksowania argv. Na przykład argv wskazuje pierwszą linię, która zawsze zawiera nazwę programu. argv wskazuje następną linię i tak dalej.

Poniżej znajduje się mały przykład użycia argumentów wiersza poleceń. Odlicza od wartości określonej w wierszu poleceń i emituje sygnał, gdy osiągnie zero. Zauważ, że pierwszy argument zawiera liczbę przekonwertowaną na liczbę całkowitą przy użyciu standardowej funkcji atoi(). Jeżeli jako drugi argument występuje ciąg „display”, to na ekranie zostanie wyświetlony sam licznik.

/* program liczący */

#włączać
#włączać
#włączać
int main(int argc, char *argv)
{
int disp, liczba;
jeśli (argc<2)
{
printf("Musisz podać długość licznika\n");
printf("w wierszu poleceń. Spróbuj ponownie.\n");
zwróć 1;
}
if (argc==3 && !strcmp(argv,"wyświetlacz")) disp = 1;
w przeciwnym razie disp = 0;
for(count=atoi(argv); liczba; -liczba)
if (disp) printf("%d ", liczba);
printf("%c", "\a"); /* na większości komputerów jest to wywołanie */
zwróć 0;
}

Należy pamiętać, że jeśli nie zostaną określone żadne argumenty, pojawi się komunikat o błędzie. Jest to najbardziej typowe w przypadku programów, które używają argumentów wiersza poleceń do wydawania instrukcji, jeśli podjęto próbę uruchomienia programu bez poprawnych informacji.

Aby uzyskać dostęp do poszczególnych znaków wiersza poleceń, dodaj drugi indeks do argv. Na przykład następujący program wypisuje po jednym znaku wszystkie argumenty, z którymi został wywołany:

#włączać
int main(int argc, char *argv)
{
int t, i;
dla(t=0; t {
ja = 0;
podczas(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(" ");
}
zwróć 0;
}

Musimy pamiętać, że pierwszy indeks służy do dostępu do ciągu, a drugi do dostępu do znaku w ciągu.

Zazwyczaj do uzyskiwania poleceń źródłowych używa się argc i argv. Teoretycznie możliwe jest posiadanie do 32767 argumentów, ale większość systemów operacyjnych nie pozwala nawet się do tego zbliżyć. Zwykle te argumenty służą do określenia nazwy pliku lub opcji. Użycie argumentów wiersza poleceń nadaje programowi profesjonalny wygląd i umożliwia używanie programu w plikach wsadowych.

Jeśli dołączysz plik WILDARGS.OBJ dostarczony z Borland C++, możesz używać szablonów w argumentach typu *.EXE. (Borland C++ automatycznie obsługuje symbole wieloznaczne i odpowiednio zwiększa argc.) Na przykład, jeśli podłączysz plik WILDARGS.OBJ do następującego programu, wyświetli się informacja, ile plików odpowiada nazwie pliku określonej w wierszu poleceń:

/* Połącz ten program z WILDARGS.OBJ */

#włączać
int main(int argc, char *argv)
{
zarejestruj się w ja;
printf("%d plików pasuje do podanej nazwy\n", argc-1);
printf("Są to: ");
dla (i=1; tj printf("%s ", argv[i]);
zwróć 0;
}

Jeśli nazwiemy ten program WA, to uruchomimy go w następujący sposób, otrzymamy ilość plików z rozszerzeniem EXE oraz listę nazw tych plików:

Oprócz argc i argv, Borland C++ udostępnia także trzeci argument wiersza poleceń -env. Parametr env umożliwia programowi dostęp do informacji o środowisku systemu operacyjnego. Parametr env musi występować po argc i argv i jest zadeklarowany w następujący sposób:

Jak widać, env deklaruje się w taki sam sposób jak argv. Podobnie jak argv, jest to wskaźnik do tablicy ciągów. Każda linia jest ciągiem środowiskowym zdefiniowanym przez system operacyjny. Parametr env nie ma równoważnego parametru argc, który określa liczbę wierszy środowiska. Zamiast tego ostatnia linia środowiska ma wartość null. Poniższy program wypisuje wszystkie ciągi znaków środowiska aktualnie zdefiniowane w systemie operacyjnym:

/* ten program wyświetla wszystkie linie środowiska */

#włączać
int main(int argc, char *argv, char *env)
{
int t;
for(t=0; środowisko[t]/t++)
printf("%s\n", env[t]);
zwróć 0;
}

Należy pamiętać, że chociaż argc i argv nie są używane przez program, muszą znajdować się na liście parametrów. C nie zna nazw parametrów. Zamiast tego o ich użyciu decyduje kolejność deklarowania parametrów. W rzeczywistości możesz wywołać parametr, jak chcesz. Ponieważ argc, argv i env są nazwami tradycyjnymi, najlepiej jest ich nadal używać, aby każdy czytający program mógł od razu zrozumieć, że są to argumenty funkcji main().

Typowym zadaniem programów jest wyszukanie wartości zdefiniowanej w ciągu znaków środowiska. Na przykład zawartość linii PATH umożliwia programom korzystanie ze ścieżek wyszukiwania. Poniższy program demonstruje, jak znaleźć ciągi znaków deklarujące standardowe ścieżki wyszukiwania. Wykorzystuje standardową funkcję biblioteczną strstr(), która ma następujący prototyp:

Char *strstr(stała char *str1, stała char *str2);

Funkcja strstr() wyszukuje ciąg znaków wskazany przez str1 w ciągu znaków wskazanym przez str2. Jeżeli taki ciąg zostanie znaleziony, zwracany jest wskaźnik do pierwszej pozycji. Jeśli nie zostaną znalezione żadne dopasowania, funkcja zwraca wartość NULL.

/* program wyszukuje wśród ciągów środowiskowych linię zawierającą PATH */

#włączać
#włączać
int main (int argc, char *argv, char *env)
{
int t;
for(t=0; środowisko[t]; t++)
{
if(strstr(env[t], "ŚCIEŻKA"))
printf("%s\n", env[t]);
}
zwróć 0;
}

Każdy program w C zaczyna się od wywołania funkcji main(). Ta funkcja powinna być w każdym programie.

Jak każda inna funkcja, funkcja main() może mieć parametry. Czasami przy uruchamianiu programu warto przekazać mu pewne informacje. Informacje te są przekazywane do funkcji main() przy użyciu argumentów wiersza poleceń. Argumenty wiersza poleceń– jest to informacja wprowadzana w wierszu poleceń po nazwie programu, gdy program jest uruchamiany do wykonania poza środowiskiem programistycznym. Przykładowo, aby rozpocząć archiwizację pliku task.cpp należy w wierszu poleceń wpisać:

winrara archTaskzadanie.cpp // winrar.exe archTaskzadanie.cpp

gdzie winrar to nazwa programu archiwizującego, a linie „ A», « archTask" I " zadanie. cpp» reprezentuje argumenty wiersza poleceń, które nakazują programowi utworzenie archiwum („ A") Z imieniem archTask z jednego pliku zadanie. cpp.

Przekazując parametry do funkcji main(), należy ją zdefiniować w następujący sposób:

int main(int argc, char *argv) ( ) // lub void main(...)()

Parametr argc zawiera liczbę argumentów linii poleceń i jest liczbą całkowitą, przy czym zawsze wynosi co najmniej 1, ponieważ pierwszym argumentem jest zawsze nazwa programu (nazwa programu z pełną ścieżką do programu).

Parametr argv jest wskaźnikiem do tablicy wskaźników do ciągów. W tej tablicy każdy element wskazuje na następny argument wiersza poleceń. Puste nawiasy kwadratowe wskazują, że tablica ma nieokreśloną długość. Dostęp do poszczególnych argumentów można uzyskać poprzez indeksowanie tablicy argv. Na przykład argv wskazuje na pierwszy ciąg znaków, który zawsze jest nazwą programu; argv wskazuje na pierwszy argument i tak dalej. Lista argumentów jest ograniczona do NULL, tj. argv == NULL.

Aby uzyskać dostęp do pojedynczego znaku jednego z argumentów wiersza poleceń, należy użyć drugiego indeksu w argv. Oznacza to, że pierwszy indeks argv zapewnia dostęp do ciągu, a drugi indeks zapewnia dostęp do jego poszczególnych znaków.

Wszystkie argumenty wiersza poleceń są ciągami znaków, więc konwersja parametrów numerycznych do żądanego formatu musi być zapewniona w programie podczas jego tworzenia.

Przykład programu z różnymi sposobami konwersji liczb w formacie symbolicznym na liczby całkowite i liczby rzeczywiste:

#włączać

// przy starcie ustawiamy np. następujące argumenty: 100 2.7

void main(int a, char *b) (

k = strtol(b, &ptr, 10); // ptr = adres błędu w linii

f = strtod(b, &ptr);

sscanf(b, "%d", &k);

sscanf(b, "%lf", &f);

Nazwy argc i argv są tradycyjne, ale nie wymagane. Te dwa parametry w funkcji main() można nazwać dowolnie.

Prosty przykład użycia argumentów wiersza poleceń:

int main(int argc, char *argv) (

if (argc != 4) (

printf("Nieprawidłowe parametry uruchamiania programu!\n");

k = atoi(argv); // konwersja parametru liczbowego

printf("Witam, %s z grupy %s z %d roku",

Jeśli nazwa programu to zadanie, a ty masz na imię „Wasja”, grupa „PM-11” z pierwszego roku, to aby uruchomić program, należy wpisać w wierszu poleceń:

zadanie Wasia PM-11 1

W wyniku wykonania programu na ekranie pojawi się komunikat: „Witam, Wasio z grupy I roku PM-11”.

Należy pamiętać, że jeśli nie zostaną podane wszystkie argumenty wiersza poleceń, zostanie wyświetlony komunikat o błędzie. Programy pobierające argumenty wiersza poleceń często wykonują następujące czynności: Kiedy użytkownik uruchamia te programy bez wprowadzania wymaganych informacji, wyświetlają instrukcje dotyczące prawidłowego określenia argumentów.

Argumenty wiersza poleceń muszą być oddzielone spacją. Jeśli w samym argumencie znajdują się spacje, aby zapobiec tworzeniu wielu argumentów, argument ten należy ująć w cudzysłów. W rezultacie cały cytowany ciąg zostanie uznany za jeden argument. Na przykład program można uruchomić w następujący sposób: zadanie „Wasya i Petya” PM-21 2. W wyniku wykonania programu na ekranie pojawi się komunikat: „Witajcie, Vasya i Petya z 2. roku PM- 21 grupa.”

Co to jest char *argv? Ten tablica, której elementy są wskaźnikami, to jest tablica wskaźników. Oznacza to, że przekazując parametry do funkcji main(), można to zdefiniować w następujący sposób:

void main(int argc, char **argv) (

Zadanie. Wyświetl wszystkie argumenty wiersza poleceń (nie ma potrzeby wyświetlania nazwy programu).

#włączać

void main(int argc, char *argv)(

dla (i = 1; tj< argc; i++)

printf("%s\n", argv[i]);

Opcja druga ================

#włączać

void main(int argc, char **argv)(

póki((p=*argv) != NULL) (

printf("%s\n", p);

Zwykle argumenty wiersza poleceń służą do zapewnienia programowi danych początkowych, które będą potrzebne podczas uruchamiania (na przykład argumenty wiersza poleceń często przekazują dane, takie jak nazwa pliku lub parametry uruchamiania programu).

Gdy program nie wymaga parametrów wiersza poleceń, funkcja main() używa słowa kluczowego void na swojej liście parametrów (lub po prostu niczego nie określa).

Jak debugować w PNE. programy wymagające argumentów wiersza poleceń. W menu Uruchom → Argumenty... należy wprowadzić argumenty wiersza poleceń. Nie ma potrzeby podawania nazwy programu. Następnie możesz po prostu jak zwykle uruchomić i debugować program w środowisku programistycznym.

Proszę zawiesić AdBlock na tej stronie.

Dlaczego więc potrzebujemy funkcji niestandardowych? Aby ułatwić programistom pisanie programów, potrzebne są funkcje zdefiniowane przez użytkownika.

Pamiętaj, że rozmawialiśmy o paradygmatach programowania, a dokładniej o programowaniu strukturalnym. Główną ideą było to, że dowolny program można napisać przy użyciu tylko trzech podstawowych konstrukcji: podążania, warunku i pętli. Teraz dodamy do tych struktur jeszcze jeden - „podprogramy” - i otrzymamy nowy paradygmat programowanie proceduralne”.

Jedyna różnica polega na tym, że poszczególne fragmenty naszego programu głównego (w szczególności powtarzające się) będziemy pisać w postaci odrębnych funkcji (podprogramów, procedur) i wywoływać je w razie potrzeby. Zasadniczo program będzie teraz opisywał interakcję różnych funkcji.

W tym samouczku omówimy szczegółowo, w jaki sposób funkcje są budowane wewnętrznie. Dowiemy się również, jak tworzyć własne funkcje niestandardowe.

Jak działają funkcje

Zapamiętajmy informacje z pierwszej lekcji. Wszystkie funkcje, także te napisane przez użytkownika, są ułożone w podobny sposób. Składają się z dwóch głównych części: nagłówka funkcji i treści funkcji.

Lista 1.

Int main(void)( // nagłówek funkcji // treść funkcji zapisana w nawiasach klamrowych)

Jeśli chodzi o ciało funkcji, wszystko jest jasne: opisuje algorytm funkcji. Spójrzmy na tytuł. Składa się z trzech obowiązkowych części:

typ zwrotu;
nazwa funkcji;
argumenty funkcji.

Najpierw zapisywany jest typ zwracany, na przykład int, jak w funkcji main. Jeżeli funkcja nie powinna zwracać programowi żadnej wartości, to w tym miejscu zapisywane jest słowo kluczowe void. Wydawać by się mogło, że skoro funkcja nic nie zwraca, to nie trzeba nic pisać. Nawiasem mówiąc, wcześniej robiono to w języku C, ale potem dodano to dla ujednolicenia. Obecnie nowoczesne kompilatory będą wyświetlać ostrzeżenia/błędy, jeśli nie określisz typu powrotu.
W niektórych językach programowania funkcje, które nie zwracają żadnej wartości, nazywane są procedurami (na przykład Pascal). Ponadto istnieją różne składnie tworzenia funkcji i procedur. W języku C nie ma takiej dyskryminacji.

Nazwa funkcji jest zapisywana po typie zwracanym. Otóż po nazwie podane są typy i liczba argumentów przekazywanych do funkcji.

Przyjrzyjmy się nagłówkom funkcji, które już znamy.

Lista 2.

// funkcja o nazwie srand, która przyjmuje liczbę całkowitą, nic nie zwraca void srand(int) // funkcja o nazwie sqrt, która przyjmuje liczbę rzeczywistą, zwraca liczbę zmiennoprzecinkową sqrt(float) // funkcja o nazwie Rand, która nie przyjmuje argumentów, zwraca liczbę całkowitą int rand(void) //funkcja o nazwie pow, która przyjmuje dwa argumenty typu double, zwraca liczbę rzeczywistą typu double double pow(double, double)

Jak stworzyć własną funkcję

Aby stworzyć własną funkcję należy ją dokładnie opisać. Obowiązuje tu ogólna zasada: przed użyciem zadeklaruj i opisz, jak ma działać. Aby to zrobić, wróćmy do schematu struktury programu w języku C, który mieliśmy na pierwszej lekcji. Zaznaczmy na nim miejsca, w których można opisać funkcje.

Rys.1 Wyjaśnienie struktury programu. Deklaracja funkcji.

Jak widać, są dwa miejsca, w których można to zrobić.

Spójrzmy na przykład ilustrujący tworzenie niestandardowej funkcji obliczającej maksymalnie dwie liczby.

Lista 3.

#włączać // zadeklaruj funkcję niestandardową o nazwie max_num // wejście: dwa parametry całkowite o nazwach a i b // wyjście: maksimum z dwóch argumentów int max_num(int a, int b)( int max = b; if (a > b) max = a; return max; ) //program główny int main(void) ( int x = 0, y = 0; int m = 0; scanf("%d %d", &x, &y); m = max_num( x,y); printf("max(%d,%d) = %d\n",x,y,m); return 0; )

Opiszę szczegółowo jak ten program będzie działał. Wykonywane jest ciało funkcji głównej. Tworzone są zmienne całkowite x, y i m. Zmienne x i y są odczytywane z klawiatury. Powiedzmy, że wprowadziliśmy 3 5, następnie x = 3, y = 5. To wszystko powinno być dla Ciebie jasne. Teraz następna linijka

Lista 4.

M = max_num(x,y);

Zmienną m należy przypisać do tego, co znajduje się na prawo od znaku =. Tam mamy nazwę funkcji, którą sami stworzyliśmy. Komputer szuka deklaracji i opisu tej funkcji. Znajduje się powyżej. Zgodnie z tą deklaracją funkcja ta musi przyjmować dwie wartości całkowite. W naszym przypadku są to wartości zapisane w zmiennych x i y. Te. numery 3 i 5. Należy pamiętać, że do funkcji przekazywane są nie same zmienne x i y, a jedynie wartości (dwie liczby), które są w nich przechowywane. To, co faktycznie jest przekazywane do funkcji, gdy jest ona wywoływana w programie, nazywa się rzeczywistymi parametrami funkcji.

Teraz rozpoczyna się wykonywanie funkcji max_num. Pierwszym krokiem jest utworzenie osobnej zmiennej tymczasowej dla każdego parametru opisanego w nagłówku funkcji. W naszym przypadku tworzone są dwie zmienne całkowite o nazwach a i b. Zmiennym tym przypisane są wartości rzeczywistych parametrów. Same parametry, opisane w nagłówku funkcji, nazywane są parametrami formalnymi. Zatem parametrom formalnym a i b przypisuje się odpowiednio wartości parametrów rzeczywistych 3 i 5. Teraz a = 3, b = 5. W dalszej części funkcji możemy pracować z tymi zmiennymi, jakby były zwykłymi zmiennymi.

Tworzona jest zmienna całkowita o nazwie max, której przypisuje się wartość b. Następnie sprawdzany jest warunek a > b. Jeżeli jest to prawda, to wartość zmiennej max należy zastąpić znakiem .

Następnie następuje instrukcja return, która zwraca do programu wywołującego (funkcji main) wartość zapisaną w zmiennej max, czyli: 5. Po czym zmienne a, b i max są usuwane z pamięci. I wracamy do wiersza

Lista 5.

M = max_num(x,y);

Funkcja max_num zwróciła wartość 5, co oznacza, że teraz po prawej stronie znaku = znajduje się liczba 5. Wartość ta jest zapisywana do zmiennej m. Następnie na ekranie zostanie wyświetlona linia i program się zakończy.

Przeczytaj uważnie ostatnie 4 akapity ponownie, aby w pełni zrozumieć działanie programu.

W międzyczasie powiem Ci, dlaczego potrzebny jest dolny blok opisów funkcji. Wyobraź sobie, że napisałeś w swoim programie 20 małych funkcji. I wszystkie są opisane przed funkcją główną. Dotarcie do programu głównego na tak długi czas nie jest zbyt wygodne. Aby rozwiązać ten problem, funkcje można opisać w dolnym bloku.

Ale nie będzie można po prostu przenieść tam całego kodu funkcji, ponieważ wtedy złamana zostanie zasada: zanim czegoś użyjesz, musisz to zadeklarować. Aby uniknąć tego problemu, musisz użyć prototypu funkcji.

Prototyp funkcji całkowicie powtarza nagłówek funkcji, po którym następuje ; . Po określeniu prototypu w górnym bloku, w dolnym możemy już w pełni opisać funkcję. Dla powyższego przykładu może to wyglądać tak:

Lista 6.

#włączać int max_num(int, int); int main(void) ( int x =0, y = 0; int m = 0; scanf("%d %d", &x, &y); m = max_num(x,y); printf("max(%d ,%d) = %d\n",x,y,m); return 0; ) int max_num(int a, int b)( int max = b; if (a > b) max = a; return max; )

Wszystko jest bardzo proste. Należy pamiętać, że prototyp funkcji nie musi podawać nazw parametrów formalnych, wystarczy wskazać ich typy. W powyższym przykładzie dokładnie to zrobiłem.