Jak działa metoda main () w C?

Wiem, że istnieją dwa różne podpisy do napisania głównej metody -

int main()
{
   //Code
}

lub do obsługi argumentu wiersza poleceń, piszemy go jako-

int main(int argc, char * argv[])
{
   //code
}

W C++Wiem, że możemy przeciążyć metodę, ale w Cjaki sposób kompilator obsługiwać te dwa różne podpisy mainfunkcji?

Niektóre cechy języka C zaczęły się od hacków, które po prostu zadziałały.

Wiele podpisów dla głównych list argumentów oraz list argumentów o zmiennej długości jest jedną z tych funkcji.

Programiści zauważyli, że mogą przekazywać dodatkowe argumenty do funkcji i nic złego się nie dzieje z ich kompilatorem.

Dzieje się tak, jeśli konwencje wywoływania są takie, że:

1. Funkcja wywołująca czyści argumenty.
2. Najbardziej lewe argumenty znajdują się bliżej wierzchołka stosu lub podstawy ramki stosu, tak więc fałszywe argumenty nie unieważniają adresowania.

Jednym z zestawów konwencji wywoływania, które są zgodne z tymi regułami, jest przekazywanie parametrów na podstawie stosu, w którym wywołujący pobiera argumenty i są one przesuwane od prawej do lewej:

 ;; pseudo-assembly-language
 ;; main(argc, argv, envp); call

 push envp  ;; rightmost argument
 push argv  ;; 
 push argc  ;; leftmost argument ends up on top of stack

 call main

 pop        ;; caller cleans up   
 pop
 pop

W kompilatorach, w których występuje taka konwencja wywoływania, nie trzeba nic robić, aby wspierać te dwa rodzaje main, a nawet dodatkowe. mainmoże być funkcją bez argumentów, w którym to przypadku jest nieświadoma elementów, które zostały odłożone na stos. Jeśli jest to funkcja dwóch argumentów, to znajduje argci argvjako dwa najwyższe elementy stosu. Jeśli jest to wariant trójargumentowy specyficzny dla platformy ze wskaźnikiem środowiskowym (typowe rozszerzenie), to również zadziała: ten trzeci argument znajdzie jako trzeci element od góry stosu.

Tak więc stałe wywołanie działa we wszystkich przypadkach, umożliwiając połączenie jednego, stałego modułu startowego z programem. Ten moduł można zapisać w C, jako funkcję podobną do tej:

/* I'm adding envp to show that even a popular platform-specific variant
   can be handled. */
extern int main(int argc, char **argv, char **envp);

void __start(void)
{
  /* This is the real startup function for the executable.
     It performs a bunch of library initialization. */

  /* ... */

  /* And then: */
  exit(main(argc_from_somewhere, argv_from_somewhere, envp_from_somewhere));
}

Innymi słowy, ten moduł startowy zawsze wywołuje trzyargumentowy main. Jeśli main nie przyjmuje argumentów lub tylko int, char **, zdarza się, że działa dobrze, a także jeśli nie przyjmuje żadnych argumentów, ze względu na konwencje wywoływania.

Gdybyś miał zrobić tego rodzaju rzecz w swoim programie, byłoby to nieprzenoszalne i uważane za niezdefiniowane zachowanie przez ISO C: deklarowanie i wywoływanie funkcji w jeden sposób i definiowanie jej w inny. Ale sztuczka startowa kompilatora nie musi być przenośna; nie kierują się zasadami programów przenośnych.

Ale przypuśćmy, że konwencje wywoływania są takie, że nie może działać w ten sposób. W takim przypadku kompilator musi traktować mainspecjalnie. Kiedy zauważy, że kompiluje mainfunkcję, może wygenerować kod, który jest zgodny, powiedzmy, z wywołaniem z trzema argumentami.

To znaczy, piszesz to:

int main(void)
{
   /* ... */
}

Ale kiedy kompilator to zobaczy, zasadniczo przeprowadza transformację kodu, aby funkcja, którą kompiluje, wyglądała bardziej tak:

int main(int __argc_ignore, char **__argv_ignore, char **__envp_ignore)
{
   /* ... */
}

poza tym, że nazwy __argc_ignorenie istnieją dosłownie. Żadne takie nazwy nie są wprowadzane do twojego zakresu i nie będzie żadnego ostrzeżenia o nieużywanych argumentach. Transformacja kodu powoduje, że kompilator emituje kod z poprawnym powiązaniem, który wie, że musi wyczyścić trzy argumenty.

Inna strategia implementacji polega na tym, że kompilator lub konsolidator generuje niestandardowo __startfunkcję (lub jakkolwiek to się nazywa) lub przynajmniej wybiera jedną z kilku wstępnie skompilowanych alternatyw. W pliku obiektowym mogą być przechowywane informacje o tym, która z obsługiwanych form mainjest używana. Konsolidator może przejrzeć te informacje i wybrać poprawną wersję modułu startowego, który zawiera wywołanie mainzgodne z definicją programu. Implementacje C mają zwykle tylko niewielką liczbę obsługiwanych form, mainwięc takie podejście jest wykonalne.

Kompilatory języka C99 zawsze muszą main, do pewnego stopnia, specjalnie traktować , aby wspierać hack, że jeśli funkcja kończy się bez returninstrukcji, zachowanie jest tak, jakby return 0zostało wykonane. To znowu może być potraktowane przez transformację kodu. Kompilator zauważa, że mainkompilowana jest wywołana funkcja . Następnie sprawdza, czy koniec treści jest potencjalnie osiągalny. Jeśli tak, wstawiareturn 0;

Nie ma żadnego przeciążenia mainnawet w C ++. Funkcja główna to punkt wejścia do programu i powinna istnieć tylko jedna definicja.

W przypadku standardu C

W przypadku środowiska hostowanego (to normalne) standard C99 mówi:

5.1.2.2.1 Uruchomienie programu

Nazwa funkcji wywoływana podczas uruchamiania programu main. Implementacja nie deklaruje żadnego prototypu dla tej funkcji. Powinien być określony z typem zwracanym inti bez parametrów:

int main(void) { /* ... */ }

lub z dwoma parametrami (określanymi tutaj jako argci argv, chociaż można używać dowolnych nazw, ponieważ są one lokalne dla funkcji, w której zostały zadeklarowane):

int main(int argc, char *argv[]) { /* ... */ }

lub odpowiednik; ⁹⁾ lub w inny sposób określony w implementacji.

⁹⁾ W ten sposób intmożna go zastąpić nazwą typu zdefiniowanego jako int, lub typ argvmożna zapisać jako char **argvi tak dalej.

Dla standardowego C ++:

3.6.1 Główna funkcja [basic.start.main]

1 Program powinien zawierać globalną funkcję zwaną main, która jest wyznaczonym początkiem programu. […]

2 Implementacja nie określa z góry głównej funkcji. Ta funkcja nie powinna być przeciążona . Powinien mieć zwracany typ typu int, ale poza tym jego typ jest zdefiniowany w implementacji. Wszystkie implementacje pozwalają na obie z następujących definicji main:

int main() { /* ... */ }

i

int main(int argc, char* argv[]) { /* ... */ }

Standard C ++ wyraźnie mówi, że „To [główna funkcja] powinna mieć zwracany typ typu int, ale poza tym jego typ jest zdefiniowany w implementacji” i wymaga tych samych dwóch podpisów, co standard C.

W środowisku hostowanym ( środowisko AC, które obsługuje również biblioteki C) - wywołuje system operacyjny main.

W środowisku niehostowanym (przeznaczonym dla aplikacji wbudowanych) zawsze możesz zmienić punkt wejścia (lub wyjścia) programu za pomocą dyrektyw preprocesora, takich jak

#pragma startup [priority]
#pragma exit [priority]

Gdzie priorytet jest opcjonalną liczbą całkowitą.

Pragma startup wykonuje funkcję przed main (priorytetowo), a pragma exit wykonuje funkcję po funkcji main. Jeśli jest więcej niż jedna dyrektywa startowa, priorytet decyduje, która zostanie wykonana jako pierwsza.

Nie ma potrzeby przeciążania. Tak, istnieją 2 wersje, ale w danym momencie można używać tylko jednej.

Jest to jedna z dziwnych asymetrii i specjalnych reguł języka C i C ++.

Moim zdaniem istnieje tylko ze względów historycznych i nie kryje się za tym żadna poważna logika. Zauważ, że mainjest to szczególne również z innych powodów (na przykład mainw C ++ nie może być rekurencyjne i nie możesz wziąć jego adresu, aw C99 / C ++ możesz pominąć końcowe returnstwierdzenie).

Zauważ też, że nawet w C ++ nie jest to przeciążenie ... albo program ma pierwszą formę, albo ma drugą postać; nie może mieć obu.

Niezwykłe mainnie jest to, że można go zdefiniować na więcej niż jeden sposób, ale to, że można go zdefiniować tylko na jeden z dwóch różnych sposobów.

mainjest funkcją zdefiniowaną przez użytkownika; implementacja nie deklaruje jej prototypu.

To samo dotyczy foolub bar, ale możesz definiować funkcje o tych nazwach w dowolny sposób.

Różnica polega na tym, że mainjest wywoływana przez implementację (środowisko wykonawcze), a nie tylko przez Twój własny kod. Implementacja nie ogranicza się do zwykłej semantyki wywołań funkcji C, więc może (i musi) radzić sobie z kilkoma odmianami - ale nie jest wymagana do obsługi nieskończenie wielu możliwości. int main(int argc, char *argv[])Forma pozwala na argumenty wiersza polecenia, a int main(void)w C lub int main()C ++ jest tylko wygoda dla prostych programów, które nie muszą przetwarzać argumenty wiersza polecenia.

Jeśli chodzi o to, jak kompilator to obsługuje, zależy to od implementacji. Większość systemów prawdopodobnie ma konwencje wywoływania, które sprawiają, że te dwie formy są efektywnie kompatybilne, a wszelkie argumenty przekazywane do mainzdefiniowanego bez parametrów są po cichu ignorowane. Jeśli nie, nie byłoby trudno kompilatorowi lub linkerowi traktować w mainspecjalny sposób. Jeśli jesteś ciekawy, jak to działa w twoim systemie , możesz spojrzeć na niektóre zestawienia.

I podobnie jak wiele rzeczy w C i C ++, szczegóły są w dużej mierze wynikiem historii i arbitralnych decyzji podjętych przez projektantów języków i ich poprzedników.

Zauważ, że zarówno C, jak i C ++ zezwalają na inne definicje zdefiniowane przez implementację main- ale rzadko istnieje dobry powód, aby ich używać. W przypadku wdrożeń wolnostojących (takich jak systemy wbudowane bez systemu operacyjnego) punkt wejścia programu jest zdefiniowany w ramach implementacji i niekoniecznie jest nawet wywoływany main.

To maintylko nazwa adresu początkowego ustalona przez konsolidatora, gdzie mainjest nazwą domyślną. Wszystkie nazwy funkcji w programie są adresami początkowymi, od których zaczyna się funkcja.

Argumenty funkcji są wypychane / zdejmowane na / ze stosu, więc jeśli nie ma żadnych argumentów określonych dla funkcji, nie ma żadnych argumentów umieszczanych / zdejmowanych ze stosu. W ten sposób main może działać zarówno z argumentami, jak i bez nich.

Cóż, dwa różne sygnatury tej samej funkcji main () pojawiają się na obrazie tylko wtedy, gdy ich potrzebujesz, więc mam na myśli, że jeśli twój program potrzebuje danych przed jakimkolwiek faktycznym przetwarzaniem twojego kodu, możesz je przekazać za pomocą -

    int main(int argc, char * argv[])
    {
       //code
    }

gdzie zmienna argc przechowuje liczbę przekazanych danych, a argv jest tablicą wskaźników do znaku char, która wskazuje na przekazane wartości z konsoli. W przeciwnym razie zawsze dobrze jest iść

    int main()
    {
       //Code
    }

Jednak w każdym przypadku może istnieć jedna i tylko jedna funkcja main () w programie, ponieważ jest to jedyny punkt, w którym program rozpoczyna wykonywanie, a zatem nie może być więcej niż jeden. (mam nadzieję, że to jest warte)

Podobne pytanie zostało zadane wcześniej: dlaczego funkcja bez parametrów (w porównaniu z rzeczywistą definicją funkcji) jest kompilowana?

Jedną z najwyżej ocenianych odpowiedzi była:

W C func()oznacza, że ​​możesz przekazać dowolną liczbę argumentów. Jeśli nie chcesz żadnych argumentów, musisz zadeklarować jakofunc(void)

Więc myślę, że tak mainjest deklarowane (jeśli można zastosować termin „zadeklarowany” do main). Właściwie możesz napisać coś takiego:

int main(int only_one_argument) {
    // code
}

i nadal będzie się kompilować i działać.

Nie musisz tego nadpisywać. Ponieważ tylko jeden będzie używany na raz. Tak, są 2 różne wersje funkcji głównej