Несколько подробностей о функции main. Аргументы функции MAIN()
Основная форма записи функции имеет следующий вид
тип_возврата имя_функции (список_параметров ) { тело_функции } Тип данных, возвращаемых функцией, задаётся с помощью элемента тип_возврата . Под элементом список_параметров подразумевается список разделяемых запятыми переменных которые могут принимать любые аргументы, передаваемой функцией.В версии C89, если тип данных возвращаемый функцией, явно не задан, то подразумевается тип int . В языке C++ и версии C99, тип int по умолчанию, не поддерживается, хотя в большинстве компиляторов C++ такое предположение остаётся в силе.
Прототипы функций
В языке C++ все функции должны иметь прототипы, а в языке C прототипы формально необязательны, но весьма желательны. Общая форма определения прототипа имеет следующий вид.
тип_возврата имя_функции (список_параметров ); Например. float fn(float x); //или float fn(float);В языке C для задания прототипа функции, не имеющей параметров, вместо списка параметров используется ключевое слово void . В языке C++ пустой список параметров в прототипе функция означает, что функция на имеет параметров. Слово void в этом случае необязательно.
Возврат значений (оператор return )
Возврат значений в функции осуществляется с помощью оператора return . он имеет две формы записи.
Return; return значение ;
В языке C99 и C++ форма оператора return , которая не задаёт возвращаемого значения, должна использоваться только в void -функциях.
Перегрузка функций
В языке C++ функции могут перегружаться . Когда говорят, что функция перегружена, это означает, что две или более функций имеют одинаковые имена, однако все версии перегруженных функций имеют различное количество или тип параметров. Рассмотрим пример следующие три перегруженные функции.
Void func (int a){ cout
В каждом случае для определения того, какая версия функции func() будет вызвана, анализируется тип и количество аргументов.
Передача аргументов функции по умолчанию
В языке C++ параметру функции можно присвоить значение по умолчанию, которое автоматически будет использовано в том случае, если при вызове функции соответствующий аргумент не будет задан. Например.
Void func (int a = 0, int b = 10){} //вызов func(); func(-1); func(-1, 99);
Области видимости и время жизни переменных.
В языках C и C++ определенны правила видимости, которые устанавливают такие понятия как область видимости и время жизни объектов. Различают глобальную область видимости и локальную.
Глобальная область видимости существует вне всех других областей. Имя объявленное в глобальной области, известно всей программе. Например глобальная переменная доступна для использования всеми функциями программы. Глобальные переменные существуют на протяжении всего жизненного цикла программы.
Локальная область видимости определяется границами блока. Имя объявленное внутри локальной области,известно только внутри этой области. Локальные переменные создаются при входе в блок и разрушаются при выходе из него. Это означает, что локальные переменные не хранят своих значений между вызовами функций. Чтобы сохранить значения переменных между вызовами, можно использовать модификатор static .
Рекурсия
В языках C и C++ функции могут вызывать сами себя. Этот процесс называют рекурсией , а функцию, которая сама себя вызывает - рекурсивной. В качестве примера приведём функцию fact(), вычисляющую факториал целого числа.
Int fact (int n) { int ans; if (n == 1) return 1; ans = fact (n-1) * n; return ans; }
Функция main()
Выполнение C/C++ программы начинается с выполнения функции main() . (Windows-программы вызывают функцию WinMain());
Функция main() не имеет прототипа. Следовательно, можно использовать различные формы функции main() . Как для языка C, так и для языка C++ допустимы следующие варианты функции main() .
Int main(); int main(int argc, char *argv)
Как видно из второй формы записи, ф. main() поддерживает по крайней мере два параметра. Они называются argc и argv . Эти аргументы будут хранить количество аргументов командной строки и указатель на них соответственно. Параметр argc имеет целый тип, и его значение всегда будет не меньше числа 1, поскольку как предусмотрено в языках C и C++, первым аргументом является всегда имя программы. Параметр argv должен быть объявлен как массив символьных указателей, в которых каждый элемент указывает на аргумент командной строки. Ниже приведён пример программы, в которой демонстрируется использование этих аргументов.
#include
Передача указателей
Несмотря на то что в языках C и С++ по умолчанию используется передача параметров по значению, можно вручную построить вызов ф. с передачей параметров по ссылке. Для этого нужно аргументу передать указатель. Поскольку в таком случае функции передаётся адрес аргумента, оказывается возможным изменять значение аргумента вне функции . Например.
Void swap (int *x, int *y) { int temp; temp = *x; *x = *y; *y = temp; } //вызов swap (&a, &b);
В языке C++ адрес переменной можно передать функции автоматически. Это реализуется с помощью параметра-ссылки . При использовании параметра-ссылки функции передаётся адрес аргумента, и функция работает с аргументом, а не с копией. Чтобы создать параметр-ссылку необходимо перед его именем поставить символ "амперсанда" (&). Внутри ф. этот параметр можно использовать обычным образом, не прибегая к оператору "звёздочка" (*), например.
Void swap (int &x, int &y){ int temp; temp = x; x = y; y = temp; } //вызов swap (a, b);
Спецификаторы функций
В языке C++ определенны три спецификатора функций:
- inline
- virtual
- explict
Спецификатор inline представляет собой обращённое к компилятору требование: вместо создания вызова функции раскрыть её код прямо в строке. Если компилятор не может вставить функцию в строку он имеет право проигнорировать это требование. Спецификатором inline могут определяться как функции-члены, так и не функции-члены.
В качестве виртуальной функции (с помощью спецификатора virual ) ф. определяется в базовом классе и переопределяется в производным классом. На примере виртуальных функций можно понять, как язык C++ поддерживает полиморфизм.
Спецификатор explicit применяется только к конструкторам, Конструктор, определённый как explicit , будет задействован только в том случае, когда инициализация в точности соответствует тому, что задано конструктором. Никаких преобразований выполняться не будет (т.е. спецификатор explicit создаёт "неконвертирующий конструктор").
Шаблоны функций
Общая форма определения шаблонной функции имеет следующий вид.
Tetemplate тип> тип_возврата имя_функции (список_параметров ) { //тело функции } Здесь тип означает метку - заполнитель для типа данных, с которыми эта функция фактически будет иметь дело. В операторе template можно определить несколько параметров-типов данных, используя форму списка элементов, разделённых запятыми.
Рассмотрим пример.
Template
Указатели на функцию
На функцию, как и на любой другой объект языка C, Можно создать указатель. Синтаксис следующий.
тип_возврата (*имя_указателя )(описание_переменных ); Данное объявление создаёт указатель на функцию с именем имя_указателя , в которой содержаться переменные описание_переменных и которая возвращает значение типа тип_возврата .Функцию с помощью указателя можно вызвать следующим образом.
имя_указателя = имя_функции ; переменная = имя_указателя (переменные ); Здесь первая строка создаёт ссылку на функцию имя_функции . Вторая строка собственно производит вызов функции через указатель имя_указателя , в которую передаются переменные переменные , возврат значения происходит в переменную переменная .Следующий пример демонстрирует создание указателя и и два способа вызова функции через указатель, а также передачу функции как параметра другим функциям.
Double y; double (*p)(doublr x); p=sin; //создание указателя на функцию sin() y = (*p)(2.5); //вызов y = p(2.5); //вызов //передача функции как параметра double y; double f(double (*c)(double x), double y){ return c(y); //вызываем переданную функцию в указатель c и возвращаем значение } y = f(sin, 2.5); //передаём функции f функцию sin, а также параметр который будет обрабатываться
Создавать массивы указателей на функции так же можно.
Int f1(void); int f2(void); int f3(void); int (*p)(void) = {f1, f2, f3} y = (*p)(); //вызов функции f2 y = p(); //вызов функции f3
Возможности языков семейства Си по истине безграничны, однако, в этой свободе кроются и недостатки: всегда нужно программисту держать ухо востро и контроллировать "переполнение буфера", чтобы потом программа не вылетала в "синий экран" на массе разнообразных версий Windows и железа у пользователей. Те же крэкеры и реверсеры специально ищут в коде программ на Си уязвимости, куда можно подсадить любой вирусный код, об этом более подробно автор рассказывал в своём видеокурсе . Я там многое узнал и теперь мой код стал значительно более безопасный.
Функция main.
Каждая программа на С и C++ должна иметь функцию main; причем ваше дело, где вы ее поместите. Некоторые программисты помещают ее в начале файла, некоторые в конце. Однако независимо от ее положения необходимо помнить следующее: Аргументы функции "main". Запускающая процедура Borland C++ посылает функции main три параметра (аргумента): argc, argv и env. - argc, целое, - это число аргументов командной строки, посылаемое функции main, - argv это массив указателей на строки (char * ). Под версией DOS 3.x и более поздними argv определяется как полный маршрут запускаемой программы. При работе под более ранними версиями DOS argv указывает на нулевую строку (""). argv указывает на первую после имени программы строку командной строки. argv указывает на вторую после имени программы строку командной строки. argv указывает на последний аргумент, посылаемый функции main. argv содержит NULL. - env также является массивом указателей на строки. Каждый элемент env содержит строку вида ENVVAR=значение. ENVVAR - это имя переменной среды, типа PATH или 87. <значение> это значение данной переменной окружения, например C:\DOS;C:\TOOLS (для PATH) или YES (для 87). Заметим, однако, что если вы описываете некоторые из этих аргументов, то вы должны описывать их в таком порядке: argc, argv, env. Например, допустимы следующие объявления аргументов: main() main(int argc) /* допустимо но не очень хорошо */ main(int argc, char *argv) main(int argc, char *argv, char *env) Объявление main(int argc) не очень удобно тем, что зная количество параметров, вы не имеете доступа к ним самим. Аргумент env всегда доступен через глобальную переменную environ. Смотрите описание переменной environ (в Главе 3) и функции putenv и getenv (в Главе 2). Параметры argc и argv также доступны через переменные_argc и _argv. Пример программы, использующей argc, argv и env. Это пример программы ARGS.EXE, которая демонстрирует простейший путь использования аргументов, посылаемых функции main. /* программа ARGS.C */ #includeМинимальной программой на C++ является
Int main() { } // the minimal C++ program
В этой программе представлено объявление функции main, которая не принимает никаких аргументов. Фигурные скобки отражают группировку в C++ и в данном случае показывают тело функции main. То есть начало функции main - открывающая скобка, и конец функции main - закрывающая скобка. Двойной слэш показывает начало комментария. Комментарии игнорируются компилятором и служат для уточнения информации в коде.
Каждая программа, написанная на C++, имеет в себе функцию main() , с которой начинается запуск программы. Функция main(), как правило, возвращает результат своего выполнения, о чем сигнализирует int (integer - целочисленный), который написан перед функцией main() . При правильном, успешном завершении функция main() возвращает в качестве результата 0 . Значение результата, отличное от нуля сигнализирует о нештатном завершении программы.
Возвращаемое программой значение по завершению может использоваться в операционной системе для служебных целей.
Типичным примером первой программы на любом языке программирования является вывод текста "Hello, World!":
#include
Но так ли всё просто в данной программе? В целом, уже одна эта маленькая программа несёт в себе очень большой пласт информации, который необходимо понимать для разработки на C++.
- Директива
#include
#include
сообщает компилятору о том, что необходимо подключить некий заголовочный файл, компоненты которого планируется использовать в файле, где объявлена функция main() . iostream - это стандартная библиотека ввода вывода из STL. То есть здесь уже используется функционал библиотек, хоть и являющихся для языка стандартом. И последний момент - это угловые скобки, в которых находится название библиотеки, которые говорят о том, что это включение внешних файлов в проект, а не тех которые находятся в составе проекта. Те же файлы, которые находятся в составе проекта подключаются обрамляясь в обычные кавычки, например #include "myclass.h". Такое подключение библиотек является стандартом. Например, в Visual Studio при несоблюдении данного стандарта будут выпадать ошибки.
std - это использование пространства имён, в котором находится оператор вывода cout. Пространства имён были введены в C++ для того, чтобы убрать конфликты имён между библиотеками и проектом разработчика, если где-то имеются повторяющиеся наименования функций или классов. В Java для разрешения конфликтов имён используется система пакетов.
cout - это оператор вывода, у которого перегружен оператор << , чтобы не использовать отдельную функцию для вывода текста в консоль.
Это помимо того, что запись функции main может иметь различный вид, хотя стандартом являются две записи:
- int main()
- int main(int argc, char* argv)
Можно встретить ещё записи типа void main() и т.д. Но это ошибочные записи, хотя в некоторых компиляторах они будут компилироваться, причём даже без ошибок и предупреждений.
В записи int main(int argc, char* argv) передаются аргументы:
- argc - указывает количество переданных аргументов. Всегда не меньше 1, поскольку всегда передаётся имя программы
- argv - массив указателей на аргументы, которые передаются в качестве строковых переменных.
Если argc больше 1, значит при запуске программы были переданы дополнительные аргументы.
Проверка может выглядеть следующим образом:
#include В целом, есть большое количество моментов, которые необходимо понимать в C++ даже для небольшой программы, но от этого только интереснее;-) Однажды заинтересовался, содержимым стека функции main процесса в linux. Провел некоторые изыскания и теперь представляю вам результат. Варианты описания функции main: Argc - число параметров Размер сегмента стека можно глянуть в файле maps: Перед тем, как загрузчик передаст управление в main, он инициализирует содержимое массивов параметров командной строки, переменных окружения, вспомогательный вектор. Для 32 битов не проверял, но скорее всего достаточно только разделить размеры на два. 1. Обращение к адресам, выше верхней точки, вызывает Segfault. Вспомогательный вектор Второй способ получить содержимое вектора: Самый удобочитаемое представление получается установкой переменной окружения LD_SHOW_AUXV. LD_SHOW_AUXV=1 ls Возвращение из main() Надеюсь, было интересно. Спасибо пользователю Xeor за полезную наводку. В программы на
языке Си можно передавать некоторые
аргументы. Когда вначале вычислений
производится обращение к main(), ей
передаются три параметра. Первый из них
определяет число командных аргументов
при обращении к программе. Второй
представляет собой массив указателей
на символьные строки, содержащие эти
аргументы (в одной строке - один аргумент).
Третий тоже является массивом указателей
на символьные строки, он используется
для доступа к параметрам операционной
системы (к переменным окружения). Любая такая строка
представляется в виде: переменная
= значение\0 Последнюю строку
можно найти по двум заключительным
нулям. Назовем аргументы
функции main() соответственно: argc, argv и
env (возможны и любые другие имена). Тогда
допустимы
следующие
описания: main(int
argc, char *argv) main(int
argc, char *argv, char *env) Предположим, что
на диске A: есть некоторая программа
prog.exe. Обратимся к ней следующим образом: A:\>prog.exe
file1 file2 file3 Тогда argv - это
указатель на строку A:\prog.exe, argv - на
строку file1 и т.д. На первый фактический
аргумент указывает argv, а на последний
- argv. Если argc=1, то после имени программы
в командной строке параметров нет. В
нашем примере argc=4. Рекурсией называется
такой способ вызова, при котором функция
обращается к самой себе. Важным моментом
при составлении рекурсивной программы
является организация выхода. Здесь
легко допустить ошибку, заключающуюся
в том, что функция будет последовательно
вызывать саму себя бесконечно долго.
Поэтому рекурсивный процесс должен шаг
за шагом так упрощать задачу, чтобы в
конце концов для нее появилось не
рекурсивное решение. Использование
рекурсии не всегда желательно, так как
это может привести к переполнению стека. В системах
программирования подпрограммы для
решения часто встречающихся задач
объединяются в библиотеки. К числу таких
задач относятся: вычисление математических
функций, ввод/вывод данных, обработка
строк, взаимодействие со средствами
операционной системы и др. Использование
библиотечных подпрограмм избавляет
пользователя от необходимости разработки
соответствующих средств и предоставляет
ему дополнительный сервис. Включенные
в библиотеки функции поставляются
вместе с системой программирования. Их
объявления даны в файлах *.h (это так
называемые включаемые или заголовочные
файлы). Поэтому, как уже упоминалось
выше, в начале программы с библиотечными
функциями должны быть строки вида: #include
<включаемый_файл_типа_h> Например: #include
Существуют также
средства для расширения и создания
новых библиотек с программами пользователя. Для глобальных
переменных отводится фиксированное
место в памяти на все время работы
программы. Локальные переменные хранятся
в стеке. Между ними находится область
памяти для динамического распределения. Функции malloc() и
free() используются для динамического
распределения свободной памяти. Функция
malloc() выделяет память, функция free()
освобождает ее. Прототипы этих функций
хранятся в заголовочном файле stdlib.h и
имеют вид: void
*malloc(size_t size); void
*free(void *p); Функция malloc()
возвращает указатель типа void; для
правильного использования значение
функции надо преобразовать к указателю
на соответствующий тип. При успешном
выполнении функция возвращает указатель
на первый байт свободной памяти размера
size. Если достаточного количества памяти
нет, возвращается значение 0. Чтобы
определить количество байтов, необходимых
для переменной, используют операцию
sizeof(). Пример использования
этих функций: #include
#include
p
= (int *) malloc(100 * sizeof(int)); /* Выделение
памяти для
100 целых
чисел */ printf("Недостаточно
памяти\n"); for
(i = 0; i < 100; ++i) *(p+i) = i; /* Использование
памяти */ for
(i = 0; i < 100; ++i) printf("%d", *(p++)); free(p);
/* Освобождение памяти
*/ Перед использованием
указателя, возвращаемого malloc(), необходимо
убедиться, что памяти достаточно
(указатель не нулевой). Препроцессор
Препроцессор Си
- это программа, которая обрабатывает
входные данные для компилятора.
Препроцессор просматривает исходную
программу и выполняет следующие действия:
подключает к ней заданные файлы,
осуществляет подстановки, а также
управляет условиями компиляции. Для
препроцессора предназначены строки
программы, начинающиеся с символа #. В
одной строке разрешается записывать
только одну команду (директиву
препроцессора). Директива #define
идентификатор подстановка вызывает замену
в последующем тексте программы названного
идентификатора на текст подстановки
(обратите внимание на отсутствие точки
с запятой в конце этой команды). По
существу, эта директива вводит
макроопределение (макрос), где
"идентификатор" - это имя
макроопределения, а "подстановка"
- последовательность символов, на которые
препроцессор заменяет указанное имя,
когда находит его в тексте программы.
Имя макроопределения принято набирать
прописными буквами. Рассмотрим примеры: Первая строка
вызывает замену в программе идентификатора
MAX на константу 25. Вторая позволяет
использовать в тексте вместо открывающей
фигурной скобки ({) слово BEGIN. Отметим, что
поскольку препроцессор не проверяет
совместимость между символическими
именами макроопределений и контекстом,
в котором они используются, то рекомендуется
такого рода идентификаторы определять
не директивой #define, а с помощью ключевого
слова const с явным указанием типа (это в
большей степени относится к Си++): const
int MAX = 25; (тип int можно не
указывать, так как он устанавливается
по умолчанию). Если директива
#define имеет вид: #define
идентификатор(идентификатор, ...,
идентификатор) подстановка причем между первым
идентификатором и открывающей круглой
скобкой нет пробела, то это определение
макроподстановки с аргументами. Например,
после появления строки вида: #define
READ(val) scanf("%d", &val) оператор READ(y);
воспринимается так же, как scanf("%d",&y);.
Здесь val - аргумент и выполнена
макроподстановка с аргументом. При наличии длинных
определений в подстановке, продолжающихся
в следующей строке, в конце очередной
строки с продолжением ставится символ
\. В макроопределение
можно помещать объекты, разделенные
знаками ##, например: #define
PR(x, у) x##y После этого PR(а,
3) вызовет подстановку а3. Или, например,
макроопределение #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", year); Опишем другие
директивы препроцессора. Директива
#include уже встречалась ранее. Ее можно
использовать в двух формах: #include
"имя файла" #include
<имя файла> Действие обеих
команд сводится к включению в программу
файлов с указанным именем. Первая из
них загружает файл из текущего или
заданного в качестве префикса каталога.
Вторая команда осуществляет поиск файла
в стандартных местах, определенных в
системе программирования. Если файл,
имя которого записано в двойных кавычках,
не найден в указанном каталоге, то поиск
будет продолжен в подкаталогах, заданных
для команды #include <...>. Директивы
#include могут вкладываться одна в другую. Следующая группа
директив позволяет избирательно
компилировать части программы. Этот
процесс называется условной компиляцией.
В эту группу входят директивы #if, #else,
#elif, #endif, #ifdef, #ifndef. Основная форма записи
директивы #if имеет вид: #if
константное_выражение
последовательность_операторов Здесь проверяется
значение константного выражения. Если
оно истинно, то выполняется заданная
последовательность операторов, а если
ложно, то эта последовательность
операторов пропускается. Действие директивы
#else подобно действию команды else в языке
Си, например: #if
константное_выражение последовательность_операторов_2 Здесь если
константное выражение истинно, то
выполняется последовательность_операторов_1,
а если ложно - последовательность_операторов_2. Директива #elif
означает действие типа "else if".
Основная форма ее использования имеет
вид: #if
константное_выражение последовательность_операторов #elif
константное_выражение_1 последовательность_операторов_1 #elif
константное_выражение_n последовательность_операторов_n Эта форма подобна
конструкции языка Си вида: if...else if...else
if... Директива #ifdef
идентификатор устанавливает
определен ли в данный момент указанный
идентификатор, т.е.
входил ли он в директивы вида #define.
Строка вида #ifndef
идентификатор проверяет является
ли неопределенным в данный момент
указанный идентификатор. За любой из
этих директив может следовать произвольное
число строк текста, возможно, содержащих
инструкцию #else (#elif использовать нельзя)
и заканчивающихся строкой #endif. Если
проверяемое условие истинно, то
игнорируются все строки между #else и
#endif, а если ложно, то строки между
проверкой и #else (если слова #else нет, то
#endif). Директивы #if и #ifndef могут "вкладываться"
одна в другую. Директива вида #undef
идентификатор приводит к тому,
что указанный идентификатор начинает
считаться неопределенным, т.е. не
подлежащим замене. Рассмотрим примеры.
Три следующие директивы: проверяют определен
ли идентификатор WRITE (т.е. была ли команда
вида #define WRITE...), и если это так, то имя
WRITE начинает считаться неопределенным,
т.е. не подлежащим замене. Директивы #define
WRITE fprintf проверяют является
ли идентификатор WRITE неопределенным, и
если это так, то определятся идентификатор
WRITE вместо имени fprintf. Директива #error
записывается в следующей форме: #error
сообщение_об_ошибке Если она встречается
в тексте программы, то компиляция
прекращается и на экран дисплея выводится
сообщение об ошибке. Эта команда в
основном применяется на этапе отладки.
Заметим, что сообщение об ошибке не надо
заключать в двойные кавычки. Директива #line
предназначена для изменения значений
переменных _LINE_ и _FILE_, определенных в
системе программирования Си. Переменная
_LINE_ содержит номер строки программы,
выполняемой в текущий момент времени.
Идентификатор _FILE_ является указателем
на строку с именем компилируемой
программы. Директива #line записывается
следующим образом: #line
номер "имя_файла" Здесь номер - это
любое положительное целое число, которое
будет назначено переменной _LINE_, имя_файла
- это необязательный параметр, который
переопределяет значение _FILE_. Директива #pragma
позволяет передать компилятору некоторые
указания. Например, строка говорит
о том, что в программе на языке Си имеются
строки на языке ассемблера.
Например: Рассмотрим некоторые
глобальные идентификаторы или макроимена
(имена макроопределений). Определены
пять таких имен: _LINE_, _FILE_, _DATE_, _TIME_, _STDC_.
Два из них (_LINE_ и _FILE_) уже описывались
выше. Идентификатор _DATE_ определяет
строку, в которой сохраняется дата
трансляции исходного файла в объектный
код. Идентификатор _TIME_ задает строку,
сохраняющую время трансляции исходного
файла в объектный код. Макрос _STDC_ имеет
значение 1, если используются стандартно
- определенные макроимена. В противном
случае эта переменная не будет определена.
1. int main()
2. int main(int argc, char **argv)
3. int main(int argc, char **argv, char **env)
4. int main(int argc, char **argv, char **env, ElfW(auxv_t) auxv)
5. int main(int argc, char **argv, char **env, char **apple)
argv - нуль-терминальный массив указателей на строки параметров командной строки
env - нуль-терминальный массив указателей на строки переменных окружения. Каждая строка в формате ИМЯ=ЗНАЧЕНИЕ
auxv - массив вспомогательных значение (доступно только для PowerPC )
apple - путь к исполняемому файлу (в MacOS и Darwin )
Вспомогательный вектор - массив с различной дополнительной информацией, такой как эффективный идентификатор пользователя, признак setuid бита, размер страницы памяти и т.п.
cat /proc/10918/maps
…
7ffffffa3000-7ffffffff000 rw-p 00000000 00:00 0
…
После инициализации верхняя часть стека выглядит примерно так, для 64битной версии.
Старший адрес сверху.1.
0x7ffffffff000
Верхняя точка сегмента стека. Обращение вызывает segfault
0x7ffffffff0f8
NULL
void*
8
0x00"
2.
filename
char
1+
«/tmp/a.out»
char
1
0x00
...
env
char
1
0x00
...
char
1
0x00
3.
0x7fffffffe5e0
env
char
1
..
char
1
0x00
...
argv
char
1
0x00
...
char
1
0x00
4.
0x7fffffffe5be
argv
char
1+
«/tmp/a.out»
5.
Массив случайной длины
6.
данные для auxv
void*
48"
AT_NULL
Elf64_auxv_t
16
{0,0}
...
auxv
Elf64_auxv_t
16
7.
auxv
Elf64_auxv_t
16
Ex.: {0x0e,0x3e8}
NULL
void*
8
0x00
...
env
char*
8
8.
0x7fffffffe308
env
char*
8
0x7fffffffe5e0
NULL
void*
8
0x00
...
argv
char*
8
9.
0x7fffffffe2f8
argv
char*
8
0x7fffffffe5be
10.
0x7fffffffe2f0
argc
long int
8"
число аргументов + 1
11.
Локальные переменные и аргументы, функций вызываемых до main
12.
Локальные переменные main
13.
0x7fffffffe1fc
argc
int
4
число аргументов + 1
0x7fffffffe1f0
argv
char**
8
0x7fffffffe2f8
0x7fffffffe1e8
env
char**
8
0x7fffffffe308
14.
Переменные локальных функций
" - описания полей в документах не нашел, но в дампе явно видны.
2. Строка, содержащая путь к исполняемому файлу.
3. Массив строк с переменными окружения
4. Массив строк с параметрами командной строки
5. Массив случайной длинны. Его выделение можно отключить командами
sysctl -w kernel.randomize_va_space=0
echo 0 > /proc/sys/kernel/randomize_va_space
6. Данные для вспомогательного вектора (например строка «x86_64»)
7. Вспомогательный вектор. Подробнее ниже.
8. Нуль-терминальный массив указателей на строки переменных окружения
9. Нуль-терминальный массив указателей на строки параметров командной строки
10.Машинное слово, содержащее число параметров командной строки (один из аргументов «старших» функций см. п. 11)
11.Локальные переменные и аргументы, функций вызываемых до main(_start,__libc_start_main..)
12.Переменные, объявленные в main
13.Аргументы функции main
14.Переменные и аргументы локальных функций.
Для i386 и x86_64 нельзя получить адрес первого элемента вспомогательного вектора, однако содержимое этого вектора можно получить другими способами. Один из них - обратиться к области памяти, лежащей сразу за массивом указателей на строки переменных окружения.
Это должно выглядеть примерно так:
#include
Структуры Elf{32,64}_auxv_t описаны в /usr/include/elf.h. Функции заполнения структур в linux-kernel/fs/binfmt_elf.c
hexdump /proc/self/auxv
AT_HWCAP: bfebfbff //возможности процессора
AT_PAGESZ: 4096 //размер страницы памяти
AT_CLKTCK: 100 //частота обновления times()
AT_PHDR: 0x400040 //информация о заголовке
AT_PHENT: 56
AT_PHNUM: 9
AT_BASE: 0x7fd00b5bc000 //адрес интерпретатора, то бишь ld.so
AT_FLAGS: 0x0
AT_ENTRY: 0x402490 //точка входа в программу
AT_UID: 1000 //идентификаторы пользователя и группы
AT_EUID: 1000 //номинальные и эффективные
AT_GID: 1000
AT_EGID: 1000
AT_SECURE: 0 //поднят ли setuid флаг
AT_RANDOM: 0x7fff30bdc809 //адрес 16 случайных байт,
генерируемых при запуске
AT_SYSINFO_EHDR: 0x7fff30bff000 //указатель на страницу, используемую для
//системных вызовов
AT_EXECFN: /bin/ls
AT_PLATFORM: x86_64
Слева - название переменной, справа значение. Все возможные названия переменных и их описание можно глянуть в файле elf.h. (константы с префиксом AT_)
После инициализации контекста процесса управление передается не в main(), а в функцию _start().
main() вызывает уже из __libc_start_main. Эта последняя функция имеет интересную особенность - ей передается указатель на функцию, которая должна быть выполнена после main(). И указатель этот передается естественно через стек.
Вообще аргументы __libc_start_main имеют вид, согласно файла glibc-2.11/sysdeps/ia64/elf/start.S
/*
* Arguments for __libc_start_main:
* out0: main
* out1: argc
* out2: argv
* out3: init
* out4: fini //функция вызываемая после main
* out5: rtld_fini
* out6: stack_end
*/
Т.е. чтобы получить адрес указателя fini нужно сместиться на два машинных слова от последней локальной переменной main.
Вот что получилось(работоспособность зависит от версии компилятора):
#include
Удач.
Рекурсия
Библиотечные функции