Эти обучающие уроки предназначены для всех, независимо от того, новичок вы в программировании или у вас уже есть обширный опыт программирования на других языках! Данный материал для тех, кто хочет изучить языки С/С++ от самых его основ до сложнейших конструкций.
C++ является языком программирования, знание этого языка программирования позволит вам управлять вашим компьютером на высшем уровне. В идеале вы сможете заставить компьютер сделать всё, что сами захотите. Наш сайт поможет вам в освоении языка программирования C++.
Установка /IDE
Самое первое, что вы должны сделать, прежде чем приступить к изучении C++, это убедиться, что у вас есть IDE — интегрированная среда разработки (программа в которой вы будете программировать). Если у вас нет IDE, тогда вам сюда . Когда определитесь с выбором IDE, установите её и потренируйтесь создавать простые проекты.
Введение в язык C++
Язык C++ представляет собой набор команд, которые говорят компьютеру, что необходимо сделать. Этот набор команд, обычно называется исходный код или просто код. Командами являются или «функции» или «ключевые слова». Ключевые слова(зарезервированные слова С/С++) являются основными строительными блоками языка. Функции являются сложными строительными блоками, так как записаны они в терминах более простых функций — вы это увидите в нашей самой первой программе, которая показана ниже. Такая структура функций напоминает содержание книги. Содержание может показывать главы книги, каждая глава в книге может иметь своё собственное содержание, состоящее из пунктов, каждый пункт может иметь свои подпункты. Хотя C++ предоставляет много общих функций и зарезервированных слов, которые вы можете использовать, все-таки возникает потребность в написании своих собственных функций.
В какой же части программы начало? Каждая программа в C++ имеет одну функцию, её называют главная или main-функция, выполнение программы начинается именно с этой функции. Из главной функции, вы также можете вызывать любые другие функции, неважно, являются ли они написанными нами, или, как упоминалось ранее, предоставляются компилятором.
Так как же получить доступ к этим Стандартным функциям? Чтобы получить доступ к стандартным функциям, которые поставляются с компилятором, необходимо подключить заголовочный файл используя препроцессорную директиву — #include . Почему это эффективно? Давайте посмотрим на примере рабочей программы:
#include
Рассмотрим подробно элементы программы. #include это директива «препроцессору», которая сообщает компилятору поместить код из заголовочного файла iostream в нашу программу перед тем как создать исполняемый файл. Подключив к программе заголовочный файл вы получаете доступ к множеству различных функций, которые можете использовать в своей программе. Например, оператору сout требуется iostream . Строка using namespace std; сообщает компилятору, что нужно использовать группу функций, которые являются частью стандартной библиотеки std . В том числе эта строка позволяет программе использовать операторы, такие как cout . Точка с запятой является частью синтаксиса C++. Она сообщает компилятору, что это конец команды. Чуть позже вы увидите, что точка с запятой используется для завершения большинства команд в C++.
Следующая важная строка программы int main() . Эта строка сообщает компилятору, что есть функция с именем main , и что функция возвращает целое число типа int . Фигурные скобки { и } сигнализируют о начале { и конце } функции. Фигурные скобки используются и в других блоках кода, но обозначают всегда одно — начало и конец блока, соответственно.
В C++ объект cout используется для отображения текста (произносится как «Cи аут»). Он использует символы << , известные как «оператор сдвига», чтобы указать, что отправляется к выводу на экран. Результатом вызова функции cout << является отображение текста на экране. Последовательность \n фактически рассматривается как единый символ, который обозначает новую строку (мы поговорим об этом позже более подробно). Символ \n перемещает курсор на экране на следующую строку. Опять же, обратите внимание на точку с запятой, её добавляют в конец, после каждого оператора С++.
Следующая команда cin.get() . Это еще один вызов функции, которая считывает данные из входного потока данных и ожидает нажатия клавиши ENTER. Эта команда сохраняет консольное окно от закрытия, до тех пор пока не будет нажата клавиша ENTER. Это даёт вам время для того, чтобы посмотреть результат выполнения программы.
По достижении конца главной функции (закрывающая фигурная скобка), наша программа вернёт значение 0 для операционной системы. Это возвращаемое значение является важным, поскольку, проанализировав его, ОС может судить о том, успешно завершилась наша программа или нет. Возвращаемое значение 0 означает успех и возвращается автоматически (но только для типа данных int , другие функции, требуют вручную возвращать значение), но если бы мы хотели вернуть что-то другое, например 1, мы должны были бы сделать это вручную.
#include
Для закрепления материала, наберите код программы в своей IDE и запустите его. После того, как программа запустилась, и вы увидели результат работы, поэкспериментируйте немного с оператором cout . Это поможет вам привыкнуть к языку.
Обязательно комментируйте свои программы!
Добавляйте комментарии к коду, чтобы сделать его понятнее не только для себя но и для других. Компилятор игнорирует комментарии при выполнении кода, что позволяет использовать любое количество комментариев, чтобы описать реальный код. Чтобы создать комментарий используйте или // , который сообщает компилятору, что остальная часть строки является комментарием или /* и затем */ . Когда вы учитесь программировать, полезно иметь возможность комментировать некоторые участки кода, для того, чтобы увидеть, как изменяется результат работы программы. Подробно прочитать о технике комментирования, вы можете .
Что делать со всеми этими типами переменных?
Иногда это может сбить с толку — иметь несколько типов переменных, когда кажется, что некоторые типы переменных являются избыточными. Очень важно использовать правильный тип переменной, так как некоторым переменным, требуется больше памяти, чем другим. Кроме того, из-за способа хранения в памяти, числа с плавающей точкой, типы данных float и double являются «неточным», и не должны использоваться, когда необходимо сохранить точное целое значение.
Объявление переменных в C++
Чтобы объявить переменную используется синтаксис тип <имя>; . Вот некоторые примеры объявления переменных:
Int num; char character; float num_float;
Допустимо объявление нескольких переменных одного и того же типа в одной строке, для этого каждая из них должна быть отделена запятой.
Int x, y, z, d;
Если вы смотрели внимательно, вы, возможно, видели, что объявление переменной всегда сопровождается точкой с запятой. Подробнее о соглашении — «об именовании переменных», можно .
Распространенные ошибки при объявлении переменных в C++
Если вы попытаетесь использовать переменную, которую не объявили, ваша программа не будет скомпилирована, и вы получите сообщение об ошибке. В C++, все ключевые слова языка, все функции и все переменные чувствительны к регистру.
Использование переменных
Итак, теперь вы знаете, как объявить переменную. Вот пример программы, демонстрирующий использование переменной:
#include
Давайте рассмотрим эту программу и изучим её код, строку за строкой. Ключевое слово int говорит о том, что number — целое число. Функция cin >> считывает значение в number , пользователь должен нажать ввод после введенного числа. cin.ignore () — функция, которая считывает символ и игнорирует его. Мы организовали свой ввод в программу, после ввода числа, мы нажимаем клавишу ENTER, символ который также передаётся в поток ввода. Нам это не нужно, поэтому мы его отбрасываем. Имейте в виду, что переменная была объявлена целого типа, если пользователь попытается ввести десятичное число, то оно будет обрезано (то есть десятичная часть числа будет игнорироваться). Попробуйте ввести десятичное число или последовательность символов, когда вы запустите пример программы, ответ будет зависеть от входного значения.
Обратите внимание, что при печати из переменной кавычки не используются. Отсутствие кавычек сообщает компилятору , что есть переменная, и, следовательно, о том, что программа должна проверять значение переменной для того, чтобы заменить имя переменной на её значение при выполнении. Несколько операторов сдвига в одной строке вполне приемлемо и вывод будет выполняться в том же порядке. Вы должны разделять строковые литералы (строки, заключенные в кавычки) и переменные, давая каждому свой оператор сдвига << . Попытка поставить две переменные вместе с одним оператором сдвига << выдаст сообщение об ошибке . Не забудьте поставить точку с запятой. Если вы забыли про точку с запятой, компилятор выдаст вам сообщение об ошибке при попытке скомпилировать программу.
Изменение и сравнение величин
Конечно, независимо от того, какой тип данных вы используете, переменные не представляют особого интереса без возможности изменения их значения. Далее показаны некоторые операторы, используемые совместно с переменными:
- * умножение,
- - вычитание,
- + сложение,
- / деление,
- = присвоение,
- == равенство,
- > больше,
- < меньше.
- != неравно
- >= больше или равно
- <= меньше или равно
Операторы, которые выполняют математические функции , должны быть использованы справа от знака присвоения, для того, чтобы присвоить результат переменной слева.
Вот несколько примеров:
A = 4 * 6; // использование строчного комментария и точки с запятой, a равно 24 a = a + 5; // равно сумме исходного значения и пяти a == 5 // не присваивается пять, выполняется проверка, а равно 5 или нет
Вы часто будете использовать == в таких конструкциях, как условные операторы и циклы.
A < 5 // Проверка, a менее пяти? a > 5 // Проверка, a больше пяти? a == 5 // Проверка, a равно пяти? a != 5 // Проверка, а неравно пяти? a >= 5 // Проверка, a больше или равно пяти? a <= 5 // Проверка, a меньше или равно пяти?
Данные примеры не очень наглядно показывают использование знаков сравнения, но когда мы начнём изучать операторы выбора , вы поймете, зачем это надо.
9 ответов
Некоторые из функций языка C начинаются как хаки, которые только что сработали.
Одной из этих функций является несколько подписей для основного, а также списков аргументов переменной длины.
Программисты заметили, что они могут передавать дополнительные аргументы функции, и с их компилятором ничего плохого не происходит.
Это так, если вызывающие соглашения таковы, что:
- Вызывающая функция очищает аргументы.
- Самые левые аргументы ближе к вершине стека или к базе фрейма стека, так что ложные аргументы не делают недействительной адресацию.
Один набор условных вызовов, который подчиняется этим правилам, является передачей параметров на основе стека, в результате чего вызывающий пользователь выдает аргументы, и они помещаются справа налево:
;; 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 не принимает никаких аргументов или только int, char ** , он работает нормально, а также если он не принимает никаких аргументов из-за соглашений о вызовах.
Если бы вы делали такие вещи в своей программе, это было бы непереносимо и считалось бы поведением undefined по 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 . Затем он проверяет, может ли конец тела потенциально достижим. Если это так, он вставляет return 0;
Нет никакой перегрузки main даже в С++. Основная функция - это точка входа для программы, и должно существовать только одно определение.
Для стандартного C
Для размещенной среды (обычной), стандарт C99 говорит:
5.1.2.2.1 Запуск программы
Функция, вызванная при запуске программы, называется main . Реализация не объявляет прототипа для этой функции. Это должно быть определенный с типом возврата int и без параметров:
Int main(void) { /* ... */ }
или с двумя параметрами (называемыми здесь argc и argv , хотя любые имена могут использоваться, поскольку они являются локальными для функции, в которой они объявляются):
Int main(int argc, char *argv) { /* ... */ }
или эквивалент; 9) или каким-либо другим способом реализации.
9) Таким образом, int можно заменить на имя typedef, определенное как int , или тип argv можно записать как char **argv , и и так далее.
Для стандартного С++:
3.6.1 Основная функция
1 Программа должна содержать глобальную функцию main, которая является назначенным началом программы. [...]
2 Реализация не должна предопределять основную функцию. Эта функция не должна быть перегружена . Он должен имеют тип возвращаемого типа int, но в противном случае его тип определяется реализацией. Все реализации должны допускать оба следующих определения main:
Int main() { /* ... */ }
Int main(int argc, char* argv) { /* ... */ }
В стандарте С++ явно говорится: "Он [основная функция] должен иметь тип возвращаемого типа int, но в противном случае его тип определяется реализацией" и требует тех же двух сигнатур, что и стандарт C.
В размещенной среде (среда C, которая также поддерживает библиотеки C) - операционная система вызывает main .
В не-размещенной среде (один предназначен для встроенных приложений) вы всегда можете изменить точку входа (или выйти) вашей программы, используя директивы предварительного процессора, такие как
#pragma startup #pragma exit
Если приоритет является необязательным интегральным числом.
Запуск Pragma выполняет функцию перед тем, как основной (приоритетный) и выход прагмы выполняет функцию после основной функции. Если существует более одной директивы запуска, приоритет определяет, что будет выполняться первым.
Это одна из странных асимметрий и специальных правил языка C и С++.
По-моему, он существует только по историческим причинам, и нет реальной серьезной логики. Обратите внимание, что main является особенным также по другим причинам (например, main в С++ не может быть рекурсивным, и вы не можете взять его адрес, а на C99/С++ вы можете опустить окончательный оператор return).
Обратите внимание, что даже в С++ это не перегрузка... либо программа имеет первую форму, либо имеет вторую форму; он не может иметь обоих.
Что необычно для main не в том, что его можно определить более чем одним способом, он может быть определен только одним из двух способов.
main - пользовательская функция; реализация не объявляет прототип для него.
То же самое верно для foo или bar , но вы можете определять функции с этими именами так, как вам нравится.
Различие заключается в том, что main вызывается реализацией (среда выполнения), а не только вашим собственным кодом. Реализация не ограничивается обычной семантикой вызова функции C, поэтому она может (и должна) иметь дело с несколькими вариантами, но не требует обработки бесконечно многих возможностей. Форма int main(int argc, char *argv) допускает аргументы командной строки, а int main(void) в C или int main() в С++ - это просто удобство для простых программ, которые не требуют обработки аргументов командной строки.
Что касается того, как компилятор справляется с этим, это зависит от реализации. Большинство систем, вероятно, имеют соглашения о вызовах, которые делают две формы эффективно совместимыми, и любые аргументы, переданные в main , определенные без параметров, игнорируются. В противном случае компилятору или компоновщику не составит труда специально обработать main . Если вам интересно, как это работает в вашей системе, вы можете посмотреть некоторые списки сборок.
И, как и многие другие на C и С++, детали в значительной степени являются результатом истории и произвольных решений, сделанных разработчиками языков и их предшественников.
Обратите внимание, что оба C и С++ допускают другие определения, определенные для реализации для main , но редко есть веские основания для их использования. А для автономных реализаций (таких как встроенные системы без ОС) точка входа в программу определяется реализацией и необязательно даже называется main .
main - это просто имя для начального адреса, решенного компоновщиком, где main - имя по умолчанию. Все имена функций в программе - это начальные адреса, где начинается функция.
Borland С++ поддерживает три аргумента main(). Первые два - это традиционные argc и argv. Это единственные аргументы функции main(), определяемые стандартом ANSI С. Они позволяют передавать аргументы командной строки в программу. Аргументы командной строки - это информация, следующая за именем программы в командной строке операционной системы. Например, когда программа компилируется с помощью строчного компилятора Borland, набирается, как правило, bcc имя_ программы
Где имя_программы - это программа, которую необходимо откомпилировать. Имя программы передается компилятору в качестве аргумента.
Параметр argc содержит число аргументов командной строки и является целым числом. Он всегда равен, по крайней мере, 1, поскольку имя программы квалифицируется как первый аргумент. Параметр argv - это указатель на массив символьных указателей. Каждый элемент данного массива указывает на аргумент командной строки. Все аргументы командной строки - это строки. Все числа конвертируются программой во внутренний формат. Следующая программа выводит «Hello», а затем имя пользователя, если его набрать прямо за именем программы:
#include
{
if(argc!=2)
{
printf ("You forgot to type your name\n");
return 1;
}
printf("Hello %s", argv);
return 0;
}
Если назвать данную программу name, а имя пользователя Сергей, то для запуска программы следует набрать:
name Сергей.
В результате работы программы появится:
«Hello Сергей».
Аргументы командной строки должны отделяться пробелами или табуляциями. Запятые, точки с запятыми и им подобные символы не рассматриваются как разделители. Например:
Состоит из трех строк, в то время как
Herb,Rick,Fred
Это одна строка - запятые не являются разделителями.
Если необходимо передать строку, содержащую пробелы или табуляции в виде одного аргумента, следует ее заключить в двойные кавычки. Например, это один аргумент:
"this is a test"
Важно правильно объявить argv. Наиболее типичным методом является:
Пустые скобки указывают на то, что массив не имеет фиксированной длины. Можно получить доступ к отдельным элементам с помощью индексации argv. Например, argv указывает на первую строку, всегда содержащую имя программы. argv указывает на следующую строку и так далее.
Ниже приведен небольшой пример по использованию аргументов командной строки. Он отсчитывает в обратном порядке от значения, указанного в командной строке, и при достижении нуля подает сигнал. Обратим внимание, что первый аргумент содержит число, преобразованное в целое число с использованием стандартной функции atoi(). Если в качестве второго аргумента присутствует строка "display", то на экране будет отображаться сам счетчик.
/* программа отсчета */
#include
#include
# include
int main(int argc, char *argv)
{
int disp, count;
if(argc<2)
{
printf("You must enter the length of the count\n");
printf ("on the command line. Try again.\n");
return 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
else disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d ", count);
printf("%c", "\a"); /* на большинстве компьютеров это звонок */
return 0;
}
Обратим внимание, что если не указаны аргументы, появляется сообщение об ошибке. Это наиболее типично для программ, использующих аргументы командной строки для выдачи инструкций, если была попытка запустить программу без правильной информации.
Для доступа к отдельным символам командной строки следует добавить второй индекс к argv. Например, следующая программа выводит все аргументы, с которыми она вызывалась, по одному символу за раз:
#include
int main(int argc, char *argv)
{
int t, i;
for(t=0; t
i = 0;
while(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf (" ");
}
return 0;
}
Надо помнить, что первый индекс предназначен для доступа к строке, а второй - для доступа к символу строки.
Обычно argc и argv используются для получения исходных команд. Теоретически можно иметь до 32767 аргументов, но большинство операционных систем не позволяют даже близко подойти к этому. Обычно данные аргументы используются для указания имени файла или опций. Использование аргументов командной строки придает программе профессиональный вид и допускает использование программы в командных файлах.
Если подсоединить файл WILDARGS.OBJ, поставляемый с Borland С++, то можно будет использовать шаблоны в аргументах типа *.EXE. (Borland С++ автоматически обрабатывает шаблоны и соответствующим образом увеличивает argc.) Например, если подсоединить к следующей программе WILDARGS.OBJ, она выдаст, сколько файлов соответствует имени указанного в командной строке файла:
/* Скомпонуйте данную программу с WILDARGS.OBJ */
#include
int main(int argc, char *argv)
{
register int i;
printf("%d files match specified name\n", argc-1);
printf("They are: ");
for(i=1; i
return 0;
}
Если назвать данную программу WA, затем запустить ее как указано ниже, получим число файлов, имеющих расширение ЕХE, и список имен этих файлов:
Помимо argc и argv Borland С++ также предоставляет третий аргумент командной строки -env. Параметр env позволяет программе получить доступ к информации о среде операционной системы. Параметр env должен следовать за argc и argv и объявляется следующим образом:
Как можно видеть, env объявляется так же, как и argv. Так же, как и argv, это указатель на массив строк. Каждая строка - это строка среды, определенная операционной системой. Параметр env не имеет аналога параметра argc, который сообщал бы, сколько имеется строк среды. Вместо этого последняя строка среды нулевая. Следующая программа выводит все строки среды, определенные на текущий момент в операционной системе:
/* данная программа выводит все строки окружения */
#include
int main(int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]/ t++)
printf("%s\n", env[t]);
return 0;
}
Обратим внимание, что хотя argc и argv не используются программой, они должны присутствовать в списке параметров. С не знает имена параметров. Вместо этого их использование определяется по порядку объявления параметров. Фактически можно обозвать параметр как угодно. Поскольку argc, argv и env - это традиционные имена, то лучше их использовать и далее, чтобы любой человек, читающий программу, мог мгновенно понять, что это аргументы функции main().
Для программ типичной задачей является поиск значения, определенного в строке среды. Например, содержимое строки PATH позволяет программам использовать пути поиска. Следующая программа демонстрирует, как найти строки, объявляющие стандартные пути поиска. Она использует стандартную библиотечную функцию strstr(), имеющую следующий прототип:
Char *strstr(const char *str1, const char *str2);
Функция strstr() ищет строку, на которую указывает str1 в строке, на которую указывает str2. Если такая строка найдена, то возвращается указатель на первое положение. Если не найдено соответствий, то функция возвращает NULL.
/* программа ищет среди строк окружения строку, содержащую PATH */
#include
#include
int main (int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]; t++)
{
if(strstr(env[t], "PATH"))
printf("%s\n", env[t]);
}
return 0;
}
Страница 53 из 85
1.5.3. Передача параметров функции main
Функция main, с которой начинается выполнение программы на языке программирования С, может быть определена с параметрами, которые передаются из внешнего окружения, например, из командной строки. Во внешнем окружении действуют свои правила представления данных, а точнее, все данные представляются в виде строк символов. Для передачи этих строк в функцию main используются два параметра, первый параметр служит для передачи числа передаваемых строк, второй для передачи самих строк. Общепринятые (но не обязательные) имена этих параметров argc и argv. Параметр argc имеет тип int, его значение формируется из анализа командной строки и равно количеству слов в командной строке, включая и имя вызываемой программы (под словом понимается любой текст не содержащий символа пробел). Параметр argv это массив указателей на строки, каждая из которых содержит одно слово из командной строки. Если слово должно содержать символ пробел, то при записи его в командную строку оно должно быть заключено в кавычки.
Функция main может иметь и третий параметр, который принято называть argp, и который служит для передачи в функцию main параметров операционной системы (среды) в которой выполняется программа на языке программирования С.
Заголовок функции main имеет вид:
Если, например, командная строка программы на языке программирования С имеет вид:
A:\>cprog working "C program" 1
то аргументы argc, argv, argp представляются в памяти как показано в схеме на рис.1.
Argc [ 4 ]
argv --> -->
-->
-->
-->
argp --> -->
-->
-->
-->
Рис.1. Схема размещения параметров командной строки
Операционная система поддерживает передачу значений для параметров argc, argv, argp, а на пользователе лежит ответственность за передачу и использование фактических аргументов функции main.
Следующий пример представляет программу печати фактических аргументов, передаваемых в функцию main из операционной системы и параметров операционной системы.
Пример:
int main (int argc, char *argv, char *argp)
{ int i=0;
printf ("\n Имя программы %s", argv);
for (i=1; i>=argc; i++)
printf ("\n аргумент %d равен %s", argv[i]);
printf ("\n Параметры операционной системы:");
while (*argp)
{ printf ("\n %s",*argp);
argp++;
}
return (0);
}
Доступ к параметрам операционной системы можно также получить при помощи библиотечной функции geteuv, ее прототип имеет следующий вид:
char *geteuv (const char *varname);
Аргумент этой функции задает имя параметра среды, указатель на значение которой выдаст функция geteuv. Если указанный параметр не определен в среде в данный момент, то возвращаемое значение NULL.
Используя указатель, полученный функцией geteuv, можно только прочитать значение параметра операционной системы, но нельзя его изменить. Для изменения значения параметра системы предназначена функция puteuv.
Компилятор языка программирования С строит С-программу таким образом, что вначале работы программы выполняется некоторая инициализация, включающая, кроме всего прочего, обработку аргументов, передаваемых функции main, и передачу ей значений параметров среды. Эти действия выполняются библиотечными функциями _setargv и _seteuv, которые всегда помещаются компилятором перед функцией main.
Если программа на языке программирования С не использует передачу аргументов и значений параметров операционной системы, то целесообразно запретить использование библиотечных функций _setargv и _seteuv поместив в языке программирования С-программу перед функцией main функции с такими же именами, но не выполняющие никаких действий (заглушки). Начало программы в этом случае будет иметь вид:
Setargv()
}
-seteuv()
{ return ; /* пустая функция */
}
int main()
{ /* главная функция без аргументов */
...
...
renurn (0);
}
В приведенной программе при вызове библиотечных функций _setargv и _seteuv будут использованы функции помещенные в программу пользователем и не выполняющие никаких действий. Это заметно снизит размер получаемого exe-файла.
В программы на языке Си можно передавать некоторые аргументы. Когда вначале вычислений производится обращение к 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, если используются стандартно - определенные макроимена. В противном случае эта переменная не будет определена.
