Як працює метод main () в C?

Я знаю, що є два різних підписи для написання основного методу -

int main()
{
   //Code
}

або для обробки аргументу командного рядка ми пишемо його як-

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

В C++Я знаю , що ми можемо перевантажити метод, але Cяк компілятор обробляти ці дві різні сигнатури mainфункції?

Деякі особливості мови C починалися як хаки, які щойно спрацювали.

Кілька підписів для основних, а також списків аргументів змінної довжини, є однією з цих особливостей.

Програмісти помітили, що вони можуть передавати додаткові аргументи функції, і нічого поганого не відбувається з даним компілятором.

Це має місце, якщо умови виклику такі, що:

1. Виклична функція очищає аргументи.
2. Крайні ліві аргументи знаходяться ближче до верхньої частини стека або до основи кадру стека, так що помилкові аргументи не роблять адресацію недійсною.

Одним із наборів домовленостей виклику, який підпорядковується цим правилам, є передача параметрів на основі стеку, за допомогою якої виклик вискакує аргументи, і вони рухаються справа наліво:

 ;; 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

У компіляторах, де такий випадок є умовою виклику, не потрібно робити нічого особливого для підтримки двох типів mainабо навіть додаткових видів. mainможе бути функцією без аргументів, і в цьому випадку він не звертає уваги на елементи, які були висунуті на стек. Якщо це функція від двох аргументів, тоді вона знаходить argcі argvяк два найвищі елементи стека. Якщо це варіант із трьома аргументами для платформи з покажчиком середовища (загальне розширення), це теж буде працювати: він знайде цей третій аргумент як третій елемент у верхній частині стека.

І тому фіксований дзвінок працює у всіх випадках, дозволяючи одному, фіксованому пусковому модулю бути зв’язаний з програмою. Цей модуль можна записати на мові C як функцію, схожу на цю:

/* 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));
}

Іншими словами, цей стартовий модуль просто викликає три-аргумент main, завжди. Якщо main не приймає аргументів, або лише int, char **, це спрацьовує нормально, а також якщо не приймає аргументів, завдяки умовам виклику.

Якби ви робили подібні дії у своїй програмі, це було б не переносимим і вважалося б невизначеною поведінкою ISO C: декларування та виклик функції одним способом, а визначення іншим. Але трюк запуску компілятора не повинен бути портативним; він не керується правилами для портативних програм.

Але припустимо, що умови виклику такі, що це не може працювати таким чином. У такому випадку компілятор повинен обробляти mainспеціально. Коли він помічає, що він компілює mainфункцію, він може генерувати код, сумісний із, скажімо, викликом із трьох аргументів.

Тобто ви пишете це:

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

Але коли компілятор це бачить, він по суті виконує перетворення коду, так що функція, яку він компілює, виглядає приблизно так:

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

за винятком того, що імена __argc_ignoreбуквально не існують. Жодні такі імена не вводяться у ваш обсяг, і не буде жодного попередження про невикористані аргументи. Перетворення коду змушує компілятор видавати код із правильним зв'язком, який знає, що він повинен очистити три аргументи.

Інша стратегія реалізації полягає в тому, щоб компілятор або, можливо, компонувальник створював __startфункцію на замовлення (або як би це ще не називалося), або принаймні вибрати одну з кількох попередньо скомпільованих альтернатив. В об'єктному файлі може зберігатися інформація про те, яка з підтримуваних форм mainвикористовується. Лінкер може переглянути цю інформацію та вибрати правильну версію модуля запуску, який містить виклик main, сумісний із визначенням програми. Реалізації C зазвичай мають лише невелику кількість підтримуваних форм, mainтому такий підхід здійсненний.

Компілятори для мови C99 завжди повинні обробляти mainспеціально, певною мірою, щоб підтримати хак, що якщо функція завершується без returnоператора, поведінка ніби return 0виконується. Це, знову ж таки, можна трактувати шляхом перетворення коду. Компілятор помічає, що функція, що викликається main, складається. Потім він перевіряє, чи є кінець тіла потенційно доступним. Якщо так, він вставляє areturn 0;

НІ НЕ перевантажує mainнавіть у C ++. Основна функція є точкою входу для програми, і має існувати лише одне визначення.

Для стандарту С

Для розміщеного середовища (це звичайне середовище) стандарт C99 говорить:

5.1.2.2.1 Запуск програми

Названа функція, викликана при запуску програми main. Реалізація не оголошує прототипу для цієї функції. Він повинен визначатися з типом повернення intта без параметрів:

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

або з двома параметрами (тут згадується як argcі argv, хоча будь-які імена можуть використовуватися, оскільки вони локальні для функції, в якій вони оголошені):

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

або еквівалент; ⁹⁾ або в інший спосіб, визначений реалізацією.

⁹⁾ Таким чином, intможе бути замінено на ім'я typedef, визначене як int, або тип argvможе бути записаний як char **argvтощо.

Для стандартного C ++:

3.6.1 Основна функція [basic.start.main]

1.Програма повинна містити глобальну функцію, яка називається main, яка є призначеним початком програми. [...]

2 Реалізація не повинна визначати основну функцію. Ця функція не повинна бути перевантажена . Він повинен мати тип повернення типу int, але в іншому випадку його тип визначається реалізацією. Усі реалізації повинні дозволяти обидва наступних визначення основного:

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

і

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

Стандарт C ++ прямо говорить "Він [основна функція] повинен мати тип повернення типу int, але в іншому випадку його тип визначається реалізацією", і вимагає тих самих двох підписів, що і стандарт C.

У розміщеному середовищі ( середовищі змінного струму, яке також підтримує бібліотеки C) - виклики операційної системи main.

У не-розміщеному середовищі (призначеному для вбудованих програм) ви завжди можете змінити точку входу (або вихід) вашої програми, використовуючи директиви попереднього процесора, такі як

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

Де пріоритет - необов’язковий інтегральний номер.

Запуск Pragma виконує функцію перед основною (у пріоритеті), а pragma-вихід виконує функцію після основної функції. Якщо існує більше однієї директиви запуску, то пріоритет вирішує, який виконати першим.

Немає необхідності в перевантаженні. Так, існує 2 версії, але на той момент можна використовувати лише одну.

Це одна з дивних асиметрій та спеціальних правил мови С та С ++.

На мій погляд, він існує лише з історичних причин, і за цим не існує ніякої реальної серйозної логіки. Зверніть увагу, що mainце особливе також з інших причин (наприклад, mainв C ++ не може бути рекурсивним, і ви не можете взяти його адресу, а в C99 / C ++ ви можете пропустити остаточне returnтвердження).

Зауважте також, що навіть у C ++ це не перевантаження ... або програма має першу форму, або вона має другу форму; він не може мати і того, і іншого.

Що незвичного в mainтому, що його можна визначити більш ніж одним способом, це те, що його можна визначити лише одним із двох різних способів.

mainє визначеною користувачем функцією; реалізація не оголошує прототип для нього.

Те саме стосується fooабо bar, але ви можете визначити функції з цими іменами будь-яким способом.

Різниця полягає в тому, що mainвикликається реалізацією (середовищем виконання), а не лише власним кодом. Реалізація не обмежується звичайною семантикою викликів функції C, тому вона може (і повинна) мати справу з декількома варіаціями - але це не вимагає обробки нескінченно багатьох можливостей. int main(int argc, char *argv[])Форма дозволяє аргументи командного рядка, і int main(void)в C або int main()в C ++ це просто зручність для простих програм , які не потрібні для аргументів командного рядка процесу.

Що стосується того, як компілятор з цим справляється, це залежить від реалізації. У більшості систем, ймовірно, є конвенції викликів, які роблять дві форми фактично сумісними, і будь-які аргументи, передані mainвизначеному без параметрів, тихо ігноруються. Якщо ні, то компілятору чи компонувальнику не складе труднощів розглянути mainспеціально. Якщо вам цікаво, як це працює у вашій системі , ви можете переглянути деякі списки збірки.

І, як і багато речей на C та C ++, деталі значною мірою є результатом історії та довільних рішень, прийнятих дизайнерами мов та їх попередниками.

Зауважте, що і C, і C ++ дозволяють інші визначені реалізацією визначення, mainале рідко існує якась вагома причина використовувати їх. А для автономних реалізацій (таких як вбудовані системи без ОС), точка входу програми визначається реалізацією, і не обов'язково навіть викликається main.

Це mainпросто назва початкової адреси, яку визначає компонувальник, де mainце ім’я за замовчуванням. Усі імена функцій у програмі є початковими адресами, звідки функція запускається.

Аргументи функції висуваються / вискакуються / з стека, тому, якщо для функції не вказано аргументів, немає аргументів, що виштовхуються / вискакуються / вимикаються з стека. Ось як main може працювати як з аргументами, так і без них.

Ну, два різні підписи однієї і тієї ж функції main () з’являються на зображенні лише тоді, коли ви їх так хочете, я маю на увазі, якщо вашій програмі потрібні дані перед будь-якою фактичною обробкою вашого коду, ви можете передати їх за допомогою -

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

де змінна argc зберігає кількість переданих даних, а argv - це масив покажчиків на char, який вказує на передані значення з консолі. Інакше завжди добре походити

    int main()
    {
       //Code
    }

Однак у будь-якому випадку в програмі може бути один і лише один основний (), оскільки це єдиний момент, коли з програми починається її виконання, а отже, вона не може бути більше однієї. (сподіваюся, що це гідно)

Подібне запитання задавали і раніше: чому компілюється функція без параметрів (порівняно з фактичним визначенням функції)?

Однією з найкращих відповідей було:

У C func()означає, що ви можете передавати будь-яку кількість аргументів. Якщо ви не хочете жодних аргументів, тоді вам слід оголосити якfunc(void)

Отже, я думаю, це як mainоголошено (якщо ви можете застосувати термін "оголошено" main). Насправді ви можете написати щось подібне:

int main(int only_one_argument) {
    // code
}

і він все одно буде компілюватися та працювати.

Вам не потрібно перевизначати це. Оскільки одночасно буде використовуватися лише один. Так, є 2 різні версії основної функції