Обычная СИ-программа представляет собой определение функции main, которая для выполнения необходимых действий вызывает другие функции. Приведенные выше примеры программ представляли собой один исходный файл, содержащий все необходимые для выполнения программы функции. Связь между функциями осуществлялась по данным посредством передачи параметров и возврата значений функций. Но компилятор языка СИ позволяет также разбить программу на несколько отдельных частей (исходных файлов), оттранслировать каждую часть отдельно, и затем объединить все части в один выполняемый файл при помощи редактора связей.
При такой структуре исходной программы функции, находящиеся в разных исходных файлах могут использовать глобальные внешние переменные. Все функции в языке Си по определению внешние и всегда доступны из любых файлов. Например, если программа состоит из двух исходных файлов, как показано на рис.2., то функция main может вызывать любую из трех функций fun1, fun2, fun3, а каждая из этих функций может вызывать любую другую.
Для того, чтобы определяемая функция могла выполнять какие либо действия, она должна использовать переменные. В языке СИ все переменные должны быть объявлены до их использования. Объявления устанавливают соответствие имени и атрибутов переменной, функции или типа. Определение переменной вызывает выделение памяти для хранения ее значения. Класс выделяемой памяти определяется спецификатором класса памяти, и определяет время жизни и область видимости переменной, связанные с понятием блока программы.
В языке СИ блоком считается последовательность объявлений, определений и операторов, заключенная в фигурные скобки. Существуют два вида блоков - составной оператор и определение функции, состоящее из составного оператора, являющегося телом функции, и предшествующего телу заголовка функции (в который входят имя функции, типы возвращаемого значения и формальных параметров). Блоки могут включать в себя составные операторы, но не определения функций. Внутренний блок называется вложенным, а внешний блок - объемлющим.
Время жизни - это интервал времени выполнения программы, в течение которого программный объект (переменная или функция) существует. Время жизни переменной может быть локальным или глобальным. Переменная с глобальным временем жизни имеет распределенную для нее память и определенное значение на протяжении всего времени выполнения программы, начиная с момента выполнения объявления этой переменной. Переменная с локальным временем жизни имеет распределенную для него память и определенное значение только во время выполнения блока, в котором эта переменная определена или объявлена. При каждом входе в блок для локальной переменной распределяется новая память, которая освобождается при выходе из блока.
Все функции в СИ имеют глобальное время жизни и существуют в течение всего времени выполнения программы.
Область видимости - это часть текста программы, в которой может быть использован данный объект. Объект считается видимым в блоке или в исходном файле, если в этом блоке или файле известны имя и тип объекта. Объект может быть видимым в пределах блока, исходного файла или во всех исходных файлах, образующих программу. Это зависит от того, на каком уровне объявлен объект: на внутреннем, т.е. внутри некоторого блока, или на внешнем, т.е. вне всех блоков.
Если объект объявлен внутри блока, то он видим в этом блоке, и во всех внутренних блоках. Если объект объявлен на внешнем уровне, то он видим от точки его объявления до конца данного исходного файла.
Объект может быть сделан глобально видимым с помощью соответствующих объявлений во всех исходных файлах, образующих программу.
Спецификатор класса памяти в объявлении переменной может быть auto, register, static или extern. Если класс памяти не указан, то он определяется по умолчанию из контекста объявления.
Объекты классов auto и register имеют локальное время жизни. Спецификаторы static и extern определяют объекты с глобальным временем жизни.
При объявлении переменной на внутреннем уровне может быть использован любой из четырех спецификаторов класса памяти, а если он не указан, то подразумевается класс памяти auto.
Переменная с классом памяти auto имеет локальное время жизни и видна только в блоке, в котором объявлена. Память для такой переменной выделяется при входе в блок и освобождается при выходе из блока. При повторном входе в блок этой переменной может быть выделен другой участок памяти.
Переменная с классом памяти auto автоматически не инициализируется. Она должна быть проинициализирована явно при объявлении путем присвоения ей начального значения. Значение неинициализированной переменной с классом памяти auto считается неопределенным.
Спецификатор класса памяти register предписывает компилятору распределить память для переменной в регистре, если это представляется возможным. Использование регистровой памяти обычно приводит к сокращению времени доступа к переменной. Переменная, объявленная с классом памяти register, имеет ту же область видимости, что и переменная auto. Число регистров, которые можно использовать для значений переменных, ограничено возможностями компьютера, и в том случае, если компилятор не имеет в распоряжении свободных регистров, то переменной выделяется память как для класса auto. Класс памяти register может быть указан только для переменных с типом int или указателей с размером, равным размеру int.
Переменные, объявленные на внутреннем уровне со спецификатором класса памяти static, обеспечиваю возможность сохранить значение переменной при выходе из блока и использовать его при повторном входе в блок. Такая переменная имеет глобальное время жизни и область видимости внутри блока, в котором она объявлена. В отличие от переменных с классом auto, память для которых выделяется в стеке, для переменных с классом static память выделяется в сегменте данных, и поэтому их значение сохраняется при выходе из блока.
Пример: /* объявления переменной i на внутреннем уровне с классом памяти static. */ /* исходный файл file1.c */ main() { ... } fun1() { static int i=0; ... } /* исходный файл file2.c */ fun2() { static int i=0; ... } fun3() { static int i=0; ... }
В приведенном примере объявлены три разные переменные с классом памяти static, имеющие одинаковые имена i. Каждая из этих переменных имеет глобальное время жизни, но видима только в том блоке (функции), в которой она объявлена. Эти переменные можно использовать для подсчета числа обращений к каждой из трех функций.
Переменные класса памяти static могут быть инициализированы константным выражением. Если явной инициализации нет, то такой переменной присваивается нулевое значение. При инициализации константным адресным выражением можно использовать адреса любых внешних объектов, кроме адресов объектов с классом памяти auto, так как адрес последних не является константой и изменяется при каждом входе в блок. Инициализация выполняется один раз при первом входе в блок.
Переменная, объявленная локально с классом памяти extern, является ссылкой на переменную с тем же самым именем, определенную глобально в одном из исходных файлов программы. Цель такого объявления состоит в том, чтобы сделать определение переменной глобального уровня видимым внутри блока.
Пример: /* объявления переменной i, являющейся именем внешнего массива длинных целых чисел, на локальном уровне */ /* исходный файл file1.c */ main() { ... } fun1() { extern long i; ... } /* исходный файл file2.c */ long i={0}; fun2() { ... } fun3() { ... }
Объявление переменной i как extern в приведенном примере делает ее видимой внутри функции fun1. Определение этой переменной находится в файле file2.c на глобальном уровне и должно быть только одно, в то время как объявлений с классом памяти extern может быть несколько.
Объявление с классом памяти extern требуется при необходимости использовать переменную, описанную в текущем исходном файле, но ниже по тексту программы, т.е. до выполнения ее глобального определения. Следующий пример иллюстрирует такое использование переменной с именем st.
Пример: main() { extern int st; ... } static int st={0}; fun1() { ... }
Объявление переменной со спецификатором extern информирует компилятор о том, что память для переменной выделять не требуется, так как это выполнено где-то в другом месте программы.
При объявлении переменных на глобальном уровне может быть использован спецификатор класса памяти static или extern, а так же можно объявлять переменные без указания класса памяти. Классы памяти auto и register для глобального объявления недопустимы.
Объявление переменных на глобальном уровне - это или определение переменных, или ссылки на определения, сделанные в другом месте программы. Объявление глобальной переменной, которое инициализирует эту переменную (явно или неявно), является определением переменной. Определение на глобальном уровне может задаваться в следующих формах:
1. Переменная объявлена с классом памяти static. Такая переменная может быть инициализирована явно константным выражением, или по умолчанию нулевым значением. То есть обявления static int i=0 и static int i эквивалентны, и в обоих случаях переменной i будет присвоено значение 0.
2. Переменная объявлена без указания класса памяти, но с явной инициализацией. Такой переменной по умолчанию присваивается класс памяти static. То есть объявления int i=1 и static int i=1 будут эквивалентны.
Переменная объявленная глобально видима в пределах остатка исходного файла, в котором она определена. Выше своего описания и в других исходных файлах эта переменная невидима (если только она не объявлена с классом extern).
Глобальная переменная может быть определена только один раз в пределах своей области видимости. В другом исходном файле может быть объявлена другая глобальная переменная с таким же именем и с классом памяти static, конфликта при этом не возникает, так как каждая из этих переменных будет видимой только в своем исходном файле.
Спецификатор класса памяти extern для глобальных переменных используется, как и для локального объявления, в качестве ссылки на переменную, объявленную в другом месте программы, т.е. для расширения области видимости переменной. При таком объявлении область видимости переменной расширяется до конца исходного файла, в котором сделано объявление.
В объявлениях с классом памяти extern не допускается инициализация, так как эти объявления ссылаются на уже существующие и определенные ранее переменные.
1.6.2. Объявления функций
Функции всегда определяются глобально. Они могут быть объявлены с классом памяти static или extern. Объявления функций на локальном и глобальном уровнях имеют одинаковый смысл.
Правила определения области видимости для функций отличаются от правил видимости для переменных и состоят в следующем.
1. Функция, объявленная как static, видима в пределах того файла, в котором она определена. Каждая функция может вызвать другую функцию с классом памяти static из своего исходного файла, но не может вызвать функцию определенную с классом static в другом исходном файле. Разные функции с классом памяти static имеющие одинаковые имена могут быть определены в разных исходных файлах, и это не ведет к конфликту.
2. Функция, объявленная с классом памяти extern, видима в пределах всех исходных файлов программы. Любая функция может вызывать функции с классом памяти extern.
3. Если в объявлении функции отсутствует спецификатор класса памяти, то по умолчанию принимается класс extern.
Все объекты с классом памяти extern компилятор помещает в объектном файле в специальную таблицу внешних ссылок, которая используется редактором связей для разрешения внешних ссылок. Часть внешних ссылок порождается компилятором при обращениях к библиотечным функциям СИ, поэтому для разрешения этих ссылок редактору связей должны быть доступны соответствующие библиотеки функций.
1.6.3. Время жизни и область видимости программных объектов
Время жизни переменной (глобальной или локальной) определяется по следующим правилам.
1. Переменная, объявленная глобально (т.е. вне всех блоков), существует на протяжении всего времени выполнения программы.
2. Локальные переменные (т.е. объявленные внутри блока) с классом памяти register или auto, имеют время жизни только на период выполнения того блока, в котором они объявлены. Если локальная переменная объявлена с классом памяти static или extern, то она имеет время жизни на период выполнения всей программы.
Видимость переменных и функций в программе определяется следующими правилами.
1. Переменная, объявленная или определенная глобально, видима от точки объявления или определения до конца исходного файла. Можно сделать переменную видимой и в других исходных файлах, для чего в этих файлах следует ее объявить с классом памяти extern.
2. Переменная, объявленная или определенная локально, видима от точки объявления или определения до конца текущего блока. Такая переменная называется локальной.
3. Переменные из объемлющих блоков, включая переменные объявленные на глобальном уровне, видимы во внутренних блоках. Эту видимость называют вложенной. Если переменная, объявленная внутри блока, имеет то же имя, что и переменная, объявленная в объемлющем блоке, то это разные переменные, и переменная из объемлющего блока во внутреннем блоке будет невидимой.
4. Функции с классом памяти static видимы только в исходном файле, в котором они определены. Всякие другие функции видимы во всей программе.
Метки в функциях видимы на протяжении всей функции.
Имена формальных параметров, объявленные в списке параметров прототипа функции, видимы только от точки объявления параметра до конца объявления функции.
1.6.4. Инициализация глобальных и локальных переменных
При инициализации необходимо придерживаться следующих правил:
1. Объявления содержащие спецификатор класса памяти extern не могут содержать инициаторов.
2. Глобальные переменные всегда инициализируются, и если это не сделано явно, то они инициализируются нулевым значением.
3. Переменная с классом памяти static может быть инициализирована константным выражением. Инициализация для них выполняется один раз перед началом программы. Если явная инициализация отсутствует, то переменная инициализируется нулевым значением.
4. Инициализация переменных с классом памяти auto или register выполняется всякий раз при входе в блок, в котором они объявлены. Если инициализация переменных в объявлении отсутствует, то их начальное значение не определено.
5. Начальными значениями для глобальных переменных и для переменных с классом памяти static должны быть константные выражения. Адреса таких переменных являются константами и эти константы можно использовать для инициализации объявленных глобально указателей. Адреса переменных с классом памяти auto или register не являются константами и их нельзя использовать в инициаторах.
Пример: int global_var; int func(void) { int local_var; /* по умолчанию auto */ static int *local_ptr=&local_var; /* так неправильно */ static int *global_ptr=&global_var; /* а так правильно */ register int *reg_ptr=&local_var; /* и так правильно */ }
В приведенном примере глобальная переменная global_var имеет глобальное время жизни и постоянный адрес в памяти, и этот адрес можно использовать для инициализации статического указателя global_ptr. Локальная переменная local_var, имеющая класс памяти auto размещается в памяти только на время работы функции func, адрес этой переменной не является константой и не может быть использован для инициализации статической переменной local_ptr. Для инициализации локальной регистровой переменной reg_ptr можно использовать неконстантные выражения, и, в частности, адрес переменной local_ptr.
[В зависимости от того как ведёт себя или как должна вести себя программа, можно решить проблему по разному. Как понимаю Login_Form получает/заполняет данные о пользователе, тогда в месте где нужно получить от этой формы user_id просто дожидаешься точки когда форма уже все данные получила и тогда получаешь этот айди, хорошо кстати получение оформить в виде метода GetUserId() тогда в этом методе можно выждать паузу пока данные не пришли и только тогда возвратить нужный айди. Если ждать сразу нет возможности тогда нужно чтобы bool GetUserId(int & user_id) возвращало например true/false если уже данные есть или нет и только если вернуло true тогда user_id можно считать заполненым нужной величиной. Т.е. нужно где-то хранить форму и её иногда опрашивать чтобы получить нужные от неё данные, при этом можно либо блокирующий сделать GetUserId() который дожидается ввода либо не блокирующий который флаг успеха вернёт. При этом обязательно пока все данные не получены где-то эта форма хранится в виде переменной или члена класса. Ваше решение когда сохраняется указатель на user_id небезопасно, кто знает живой ли объект формы или уже не живой, т.е. указатель может быть действительным или нет. Зато если хранится объект формы всё время пока она не выполнила нужные действия тогда есть гарантия, что все её методы будут работать.
Если же всё равно нужно как-то с указателем решить эту проблему, тогда это тоже решаемо, только не так как в коде у вас, а так - нужно умный указатель использовать например std::shared_ptr, т.е. в классе формы мы не храним два члена (int user_id и int * ptr_user_id), а храним один член std::shared_ptr ptr_user_id, в конструкторе под него выделяем память ptr_user_id = new int(0), потом когда нужно в форме заполняем его при этом также из формы его сделаем возможным для получения через shared_ptr
Список параметров в определении и прототипе функции, кроме согласования типов параметров, имеет еще одно назначение.
Объявление параметра может содержать инициализатор, то есть выражение, которое должно обеспечить параметру присвоение начального значения. Инициализатор параметра не является константным выражением. Начальная инициализация параметров происходит не на стадии компиляции (как, например, выделение памяти под массивы), а непосредственно в ходе выполнения программы.
Следующие строки демонстрируют пример объявления функции с инициализацией параметров. Для инициализации параметра ww используется функция XX.
int ZZ(int tt, int ww = XX(BigVal));
Второй параметр можно проинициализировать и таким способом, вовсе не указывая его имени. Синтаксис объявления позволяет сделать и такое!
int ZZ(int tt, int = XX(BigVal));
Единственное условие подобной инициализации - соответствие типа параметра и типа выражения, значение которого используется при начальной инициализации.
Прототипы функции могут располагаться в различных областях видимости. Его можно даже разместить в теле определяемой функции. Каждое объявление функции может содержать собственные варианты объявления и инициализации параметров. Но во множестве объявлений одной и той же функции в пределах одной области видимости не допускается повторная инициализация параметров. Всему должен быть положен разумный предел.
Кроме того, в C++ действует еще одно ограничение, связанное с порядком инициализации параметров в пределах области видимости. Инициализация проводится непременно с самого последнего (самого правого) параметра в списке объявлений параметров. Инициализация параметров не допускает пропусков: инициализированные параметры не могут чередоваться с параметрами неинициализированными.
int MyF1 (int par1, int par2, int par3, int par4 = 10);
………………………………….
int MyF1 (int par1, int par2 = 20, int par3 = 20, int par4);
………………………………….
int MyF1 (int par1 = 100, int, int, int);
#include
int f(int, int=4);
int main(int argc, char* argv)
printf("%d\n", f(2)); //8
printf("%d\n", f(2,3)); //6
int f(int a, int b)
Функции с переменным числом параметров
При вызове функции с переменным числом параметров в вызове этой функции задается любое требуемое число аргументов. В объявлении и определении такой функции переменное число аргументов задается многоточием в конце списка формальных параметров или списка типов аргументов.
Все аргументы, заданные в вызове функции, размещаются в стеке. Количество формальных параметров, объявленных для функции, определяется числом аргументов, которые берутся из стека и присваиваются формальным параметрам. Программист отвечает за правильность выбора дополнительных аргументов из стека и определение числа аргументов, находящихся в стеке.
Примерами функций с переменным числом параметров являются функции из библиотеки функций языка СИ, осуществляющие операции ввода-вывода информации (printf, scanf и т.п.). Функция printf() в библиотеке объявлена следующим образом:
int printf(const char* ...);
Это гарантирует, что при любом вызове printf() ей будет передан первый аргумент типа const char*. Содержание такой строки, называемой форматной, определяет, необходимы ли дополнительные аргументы при вызове. При наличии в строке формата метасимволов, начинающихся с символа %, функция ждет присутствия этих аргументов.
Программист может разрабатывать свои функции с переменным числом параметров. Для обеспечения удобного способа доступа к аргументам функции с переменным числом параметров имеются три макроопределения (макросы) va_start, va_arg, va_end, находящиеся в заголовочном файле stdarg.h. Эти макросы указывают на то, что функция, разработанная пользователем, имеет некоторое число обязательных аргументов, за которыми следует переменное число необязательных аргументов. Обязательные аргументы доступны через свои имена как при вызове обычной функции. Для извлечения необязательных аргументов используются макросы va_start, va_arg, va_end в следующем порядке.
Макрос va_start предназначен для установки аргумента arg_ptr на начало списка необязательных параметров и имеет вид функции с двумя параметрами:
void va_start(arg_ptr, prav_param);
Параметр prav_param должен быть последним обязательным параметром вызываемой функции, а указатель arg_prt должен быть объявлен с предопределением в списке переменных типа va_list в виде:
va_list arg_ptr;
Макрос va_start должен быть использован до первого использования макроса va_arg.
Макрокоманда va_arg обеспечивает доступ к текущему параметру вызываемой функции и тоже имеет вид функции с двумя параметрами
type_arg va_arg(arg_ptr,type);
Эта макрокоманда извлекает значение типа type по адресу, заданному указателем arg_ptr, увеличивает значение указателя arg_ptr на длину использованного параметра (длина type) и таким образом параметр arg_ptr будет указывать на следующий параметр вызываемой функции. Макрокоманда va_arg используется столько раз, сколько необходимо для извлечения всех параметров вызываемой функции.
Макрос va_end используется по окончании обработки всех параметров функции и устанавливает указатель списка необязательных параметров на ноль (NULL).
Рассмотрим применение этих макросов для обработки параметров функции, вычисляющей среднее значение произвольной последовательности целых чисел. Поскольку функция имеет переменное число параметров, будем считать концом списка значение равное -1. Поскольку в списке должен быть хотя бы один элемент, у функции будет один обязательный параметр.
#include
#include
int sred_znach(int,...);
n=sred_znach(2,3,4,-1); /* вызов с четырьмя параметрами */
printf("n=%d\n",n);
n=sred_znach(5,6,7,8,9,-1); /* вызов с шестью параметрами */
printf("n=%d\n",n);
int sred_znach(int x,...)
int i=0, j=0, sum=0;
va_start(uk_arg,x); /* установка указателя uk_arg на */
/* первый необязятельный параметр */
if (x!=-1) sum=x; /* проверка на пустоту списка */
else return (0);
while ((i=va_arg(uk_arg,int))!=-1)
/* выборка очередного */
{ /* параметра и проверка */
sum+=i; /* на конец списка */
va_end(uk_arg); /* закрытие списка параметров */
Пример 2: Возможен другой вариант - первый параметр функции отвечает за количество суммируемых элементов. Кроме того, можно отказаться от применения макросов и разобрать стек в коде функции.
#include
#include
int sred_znach2(int,...);
n=sred_znach2(3,2,3,4);
printf("n=%d\n",n);
int sred_znach2(int n,...)
int *pPointer = &n;
for (int i=n ; i; i--) Sum += *(++pPointer);
При создании программных продуктов необходимо уметь чётко и качественно оперировать всей необходимой терминологий. Вот, например, взять такое слово, как инициализация. Это что такое, вы знаете? Сомневаюсь, иначе бы вы не читали эту статью. Поэтому давайте рассмотрим, что подразумевают под этим термином, какие бывают виды, а также разберём несколько проблем, которые могут возникнуть при использовании электроники.
Инициализация - это что такое?
Так называют процессы создания, активации, подготовки к работе и определение необходимых параметров, чтобы приложение могло качественно и без ошибок работать. Это обязательный шаг по приведению любого устройства или программы в состояние, когда оно может использоваться. Само действие инициализации может направляться извне относительно объекта влияния. В большинстве случаев подразумевается исключительно настройка необходимых параметров, а также правил работы, по которым будет функционировать программа.
Примеры
Давайте рассмотрим, что представляет собой инициализация. Это что такое? Понять будет легче всего, используя несколько реальных примеров:
- Под инициализацией магнитного диска винчестера понимают его форматирование. Также может быть сюда отнесена и запись управляющей информацией (меток томов, описателей дорожек и подобные манипуляции).
- Под инициализацией программы понимают задание необходимых переменных или установку в нулевое значение программных переменных (счётчиков, адресов, переключателей, указателей) перед тем, как само приложение будет выполнено. Всё устанавливается согласно тому, что делается для этого типа ПО или содержится в виде указаний в самом файле.
- Инициализация для вывода на принтер данных подсистемы печати. Это определение, которое подразумевает следующее: на каком устройстве необходимо перенести данные на бумагу и провести учёт всех необходимостей. Так, следует определить формат печати, расширение, использовать ли цвет (если он есть) и другие параметры. Сначала на устройство подаётся управляющий сигнал и проводится сканирование его возможностей, чтобы произвести первоначальную настройку принтера и предложить пользователю вариант, который может быть осуществлён имеющейся техникой.
А вот теперь давайте рассмотрим случай на практике запуска приложения. Допустим, существует ошибка инициализации при запуске игры. В качестве базы было выбрано Симс 3 - довольно популярное приложение, в котором требуется управлять человеком, создавая ему обеспеченную жизнь.
Из-за чего возникает в Sims-3
Самый распространённый вариант проблемы - это 0×0175dcbb. Этот номер используется для обозначения именно неполадок с инициализацией приложения. Она может возникнуть из-за того, что базовая игра конфликтует с дополнениями, модами и драйверами видеокарты, которые были установлены на компьютере. Причём вы не застрахованы даже при покупке лицензионной игры - если проблема есть, лицензия не приведёт к её автоматическому решению.
Что же делать, если ошибка 0×0175dcbb уже есть?
Итак, ошибка возникла. Сейчас разберёмся, как мы можем её убрать. Хотя рассматривать будем игру, но многие знания, написанные далее, могут пригодиться и при работе с серьёзными приложениями. Помните, что самая старая проблема - это архаические программные компоненты. В первую очередь нас интересуют драйвера видеокарт. Их можно скачать на сайтах производителей, что мы собственно и сделали. Также нелишним будет установить или обновить до последней версии NET Framework - желательно делать это с ресурса разработчика, коим является Microsoft.
А теперь отметим самые популярные причины неполадки: дополнительные моды, которые были написаны сторонними разработчиками. В таких случаях, увы, придётся удалить само расширение. Если есть информация, из-за которой делать это вы не хотите, то можно просто переименовать папку Mods. При появлении ошибки после установки необходимо удалить с помощью деинсталлятора саму программу и переустановить её ещё раз. Если это всё не помогло (а такое бывает часто), то можно сделать заключение, что повреждён диск, где находится сама игра. И единственное благоразумное решение - обменять его (или скачать с торрента пиратскую версию).
Заключение
Что устанавливать на свой компьютер, решать только вам. Но впредь, прежде чем добавлять в стабильно работающий продукт контент, разработанный сторонними людьми, необходимо хорошо подумать и проявить значительную внимательность к качеству скачанных дополнений. Потому что может быть ошибка инициализации обновления, а возможность отката обычно не предусматривается. И тогда придётся удалять всю программу и устанавливать её заново. Если уж решено было так сделать, то необходимо позаботится о сохранности наработанных данных. Их копию нужно разместить где-то в безопасном и укромном месте, например, на рабочем столе или флеш-накопителе. Вот и всё, нами была детально рассмотрена инициализация. Это что такое, вы наверняка поняли. Ведь мы разобрали не только текстовую составляющую, но и рассмотрели несколько конкретных примеров.
Список параметров в определении и прототипе функции, кроме согласования типов параметров, имеет ещё одно назначение.
Объявление параметра может содержать инициализатор, то есть выражение, которое должно обеспечить параметру присвоение начального значения. Инициализатор параметра не является константным выражением. Начальная инициализация параметров происходит не на стадии компиляции (как, например, выделение памяти под массивы), а непосредственно в ходе выполнения программы.
Следующие строки демонстрируют пример объявления функции с инициализацией параметров. Для инициализации параметра ww используется функция XX.
Int BigVal;
int XX(int);
int ZZ(int tt, int ww = XX(BigVal));
Второй параметр можно проинициализировать и таким способом, вовсе не указывая его имени. Синтаксис объявления позволяет сделать и такое!
Int ZZ(int tt, int = XX(BigVal));
Единственное условие подобной инициализации - соответствие типа параметра и типа выражения, значение которого используется при начальной инициализации.
Прототипы функции могут располагаться в различных областях видимости. Его можно даже разместить в теле определяемой функции. Каждое объявление функции может содержать собственные варианты объявления и инициализации параметров. Но во множестве объявлений одной и той же функции в пределах одной области видимости не допускается повторная инициализация параметров. Всему должен быть положен разумный предел.
Кроме того, в C++ действует ещё одно ограничение, связанное с порядком инициализации параметров в пределах области видимости. Инициализация проводится непременно с самого последнего (самого правого) параметра в списке объявлений параметров. Инициализация параметров не допускает пропусков: инициализированные параметры не могут чередоваться с параметрами неинициализированными.
Int MyF1 (int par1, int par2, int par3, int par4 = 10);
int MyF1 (int par1, int par2 = 20, int par3 = 20, int par4);
int MyF1 (int par1 = 100, int, int, int);
Список параметров в определении функции строится по аналогичным правилам. В списке параметров определения функции также допускаются инициализаторы, в ряде случаев также могут быть опущены имена параметров. Разумеется, включение в заголовок определения функции безымянного параметра затрудняет возможность использования этого параметра в определяемой функции. К безымянному параметру невозможно обращаться по имени.
И всё же отказ от использования параметра может быть оправдан. Такие параметры, вернее их спецификаторы, позволяют сократить затраты на модификацию сложных многомодульных программ, когда в результате изменения функции меняется число параметров этой функции. Ненужные параметры могут быть отключены без изменения многочисленных вызовов этой функции. В этом случае имеет смысл сохранить общее количество параметров функции, а имя ненужного параметра из списка параметров удалить.
33передача параметров функции main c++
При создании консольного приложения в языке программирования С++, автоматически создается строка очень похожая на эту:
| int main(int argc, char* argv) // параметры функции main() |
Эта строка - заголовок главной функции main(), в скобочках объявлены параметры argс и argv. Так вот, если программу запускать через командную строку, то существует возможность передать какую-либо информацию этой программе, для этого и существуют параметры argcи argv. Параметр argc имеет тип данных int, и содержит количество параметров, передаваемых в функцию main. Причем argc всегда не меньше 1, даже когда мы не передаем никакой информации, так как первым параметром считается имя функции. Параметр argv это массив указателей на строки. Через командную строку можно передать только данные строкового типа. Указатели и строки - это две большие темы, под которые созданы отдельные разделы. Так вот именно через параметр argv и передается какая-либо информация. Разработаем программу, которую будем запускать через командную строку Windows, и передавать ей некоторую информацию.
Время жизни и область видимости программных объектов Классы памяти.
Время жизни переменной (глобальной или локальной) определяется по следующим правилам.
1. Переменная, объявленная глобально (т.е. вне всех блоков), существует на протяжении всего времени выполнения программы.
2. Локальные переменные (т.е. объявленные внутри блока) с классом памяти register или auto, имеют время жизни только на период выполнения того блока, в котором они объявлены. Если локальная переменная объявлена с классом памяти static или extern, то она имеет время жизни на период выполнения всей программы.
Видимость переменных и функций в программе определяется следующими правилами.
1. Переменная, объявленная или определенная глобально, видима от точки объявления или определения до конца исходного файла. Можно сделать переменную видимой и в других исходных файлах, для чего в этих файлах следует ее объявить с классом памяти extern.
2. Переменная, объявленная или определенная локально, видима от точки объявления или определения до конца текущего блока. Такая переменная называется локальной.
3. Переменные из объемлющих блоков, включая переменные объявленные на глобальном уровне, видимы во внутренних блоках. Эту видимость называют вложенной. Если переменная, объявленная внутри блока, имеет то же имя, что и переменная, объявленная в объемлющем блоке, то это разные переменные, и переменная из объемлющего блока во внутреннем блоке будет невидимой.
4. Функции с классом памяти static видимы только в исходном файле, в котором они определены. Всякие другие функции видимы во всей программе.
Метки в функциях видимы на протяжении всей функции.
Имена формальных параметров, объявленные в списке параметров прототипа функции, видимы только от точки объявления параметра до конца объявления функции.
Классы памяти в с++.
2) register
3) static
4) extern
auto
int i; -> auto int i;
Классы памяти в с++.
Существует 4 спецификатора класса памяти:
2) register
3) static
4) extern
Если класс памяти не указан, он определяется по умолчанию из контекста объявления.
Объекты классов auto и register имеют локальное время жизни.
Спецификаторы static и extern определяют объекты с глобальным временем жизни, но точный смысл каждого спецификатора зависит от того, находится ли он на внешнем или на внутреннем уровне и от того, является ли объект функцией или переменной.
На внутреннем уровне при объявлении переменной может быть использован любой из 4 спецификаторов класса памяти. Если спецификатор опущен, то подразумевается auto
int i; -> auto int i;
Переменная с классом памяти auto имеет локальное время жизни. Она видима только в том блоке, в котором объявлена. Память для этой переменной выделяется при входе в блок и освобождается при выходе. При повторном входе в блок память для этой переменной может быть распределена в другом месте.
register
Предписывает компилятор распределить память под переменную в регистре процессора, если это возможно. Переменная с классом памяти register имеет ту же область видимости, что и auto.
Когда компилятор встречает спецификатор register, а свободного регистра не имеется, то для переменной распределяется память auto.
Регистровая память, если она имеется, может быть назначена только для переменной типа int и указателей.
static
Переменные, объявленные на внутреннем уровне со спецификатором static, обеспечивают возможность сохранить значение локальной переменной при выходе из блока и использовать его при следующем входе в блок.
extern
Переменная, объявленная со спецификатором extern, является ссылкой на переменную с тем же именем, определенную на внешнем уровне в любом исходном файле программы.
Цель объявления extern состоит в том, чтобы сделать объявление переменной внешнего уровня видимой внутри блока.
35Инициализация глобальных и локальных переменных
Существуют локальные и глобальные переменные. Так вот, переменные, объявленные внутри функции, называются локальными. Локальные переменные имеют свои области видимости, этими областями являются функции, в которых объявлены переменные. Таким образом, в разных функциях можно использовать переменные с одинаковыми именами, что в свою очередь очень удобно. Разделение переменных на глобальные и локальные соответствует одному из главных правил программирования, а именно – принципу наименьших привилегий. То есть, переменные, объявленные внутри одной функции, должны быть доступны только для этой функции и ни чему другому, в конце концов, они создавались именно для этой функции. Глобальные переменные объявляются вне тела какой-либо функции, и поэтому область видимости таких переменных распространяется на всю программу. Обычно глобальные переменные объявляются перед главной функцией, но можно объявлять и после функции main(), но тогда данная переменная не будет доступна в функции main().
Разработаем программу, в которой будут объявлены две переменные, локальная и глобальная, с одинаковым именем.
37Динамические массивы. Особенности выделения и освобождения памяти для многомерных массивов.
Динамическим называется массив, размер которого может меняться во время исполнения программы. Для изменения размера динамического массива язык программирования, поддерживающий такие массивы, должен предоставлять встроенную функцию или оператор. Динамические массивы дают возможность более гибкой работы с данными, так как позволяют не прогнозировать хранимые объёмы данных, а регулировать размер массива в соответствии с реально необходимыми объёмами. В отличие от динамических массивов существуют статические массивы и массивы переменной длины. Размер статического массива определяется на момент компиляции программы. Размер массива переменной длины определяется во время выполнения программы. Отличием динамического массива от массива переменной длины является автоматическое изменение размеров, что не трудно реализуется в случаях его отсутствия, поэтому часто не различают массивы переменной длины с динамическими массивами.
Динамические массивы ограниченного размера и их объём
Простейший динамический массив - это массив с фиксированным размером длинны, который делится на две части: в первой хранятся элементы динамического массива, а вторая часть является резервной или неиспользуемой. Вы можете добавлять или удалять элементы в конец динамического массива в определённое время используя резервное пространство массива, до тех пор, пока оно не исчерпается. Число элементов, используемых в динамических массивах это логический размер или просто размер, в то время как размер основного массива называется объёмом динамического массива или физическим размером, который является максимально возможным размером, без переопределения размера данных.
В приложениях, где логический размер ограничен, достаточна структура данных фиксированного размера. Это может привести к неприятным последствиям, поскольку больше пространства может понадобится позже. Однако многие программисты предпочитают писать код с использованием массивов способных к изменению размеров с самого начала, а затем, на этапе оптимизации, некоторые массивы заменяют на массивы с фиксированным размером. Изменение размеров базового массива является дорогой задачей, она обычно включает в себя копирование всего содержимого массива.
38Директивы препроцессора. Макроопределения.
Почти все программы на языке С++ используют специальные команды для компилятора, которые называются директивами. В общем случае директива – это указание компилятору языка С++ выполнить то или иное действие в момент компиляции программы. Существует строго определенный набор возможных директив, который включает в себя следующие определения:
#define, #elif, #else, #endif, #if, #ifdef, #ifndef, #include, #undef.
Директива #define используется для задания констант, ключевых слов, операторов и выражений, используемых в программе. Общий синтаксис данной директивы имеет следующий вид:
#define <идентификатор> <текст>
#define <идентификатор> (<список параметров>) <текст>
Директива #undef отменяет определение, введенное ранее директивой #define. Предположим, что на каком-либо участке программы нужно отменить определение константы FOUR. Это достигается следующей командой:
Отличие директивы #if от директив #ifdef и #ifndef заключается в возможности проверки более разнообразных условий, а не только существует или нет какие-либо константы. Например, с помощью директивы #if можно проводить такую проверку:
Используемая в приведенных примерах директива #include позволяет добавлять в программу ранее написанные программы и сохраненные в виде файлов. Например, строка
#include < stdio.h >
Макроопределение - директива #define
Макроопределение, или макроподстановка - пожалуй, самая мощная директива препроцессора. И вместе с тем самая коварная. Давайте посмотрим, как ей пользоваться. Взгляните на такой кусочек программы:
int x;
int y;
int i;
for (i=0; i<100; i++) {
x[i]=fx(i);
y[i]=fy(i);
}
Этот код считает значения функций fx и fy в 100 точках - например, для того, чтобы потом построить их графики. Если нам понадобится увеличить количество точек, придется в трех местах заменять 100 на другое число - и писанины много, и ошибиться легко.
45Шаблоны функций.
Шабло́ны (англ. template ) - средство языка C++, предназначенное для кодирования обобщённых алгоритмов, без привязки к некоторым параметрам (например, типам данных, размерам буферов, значениям по умолчанию).
В C++ возможно создание шаблонов функций и классов.
Шаблоны позволяют создавать параметризованные классы и функции. Параметром может быть любой тип или значение одного из допустимых типов (целое число, enum, указатель на любой объект с глобально доступным именем, ссылка). Например, нам нужен какой-то класс:
Class SomeClass{ int SomeValue; int SomeArray; ...};
Для одной конкретной цели мы можем использовать этот класс. Но, вдруг, цель немного изменилась, и нужен еще один класс. Теперь нужно 30 элементов массива SomeArray и вещественный тип SomeValue элементов SomeArray. Тогда мы можем абстрагироваться от конкретных типов и использовать шаблоны с параметрами. Синтаксис: в начале перед объявлением класса напишем слово template и укажем параметры в угловых скобках. В нашем примере:
Template < int ArrayLength, typename SomeValueType > class SomeClass{ SomeValueType SomeValue; SomeValueType SomeArray[ ArrayLength ]; ...};
Тогда для первой модели пишем:
SomeClass < 20, int > SomeVariable;
для второй:
SomeClass < 30, double > SomeVariable2;
Хотя шаблоны предоставляют краткую форму записи участка кода, на самом деле их использование не сокращает исполнимый код, так как для каждого набора параметров компиляторсоздаёт отдельный экземпляр функции или класса.
46 Шаблоны классов.
Любой шаблон начинается со слова template, будь то шаблон функции или шаблон класса. После ключевого словаtemplate идут угловые скобки - < >, в которых перечисляется список параметров шаблона. Каждому параметру должно предшествовать зарезервированное слово class или typename. Отсутствие этих ключевых слов будет расцениваться компилятором как синтаксическая ошибка. Некоторые примеры объявления шаблонов.
Ключевое слово typename говорит о том, что в шаблоне будет использоваться встроенный тип данных, такой как: int, double,float, char и т. д. А ключевое слово class сообщает компилятору, что в шаблоне функции в качестве параметра будут использоваться пользовательские типы данных, то есть классы. Но не в коем случае не путайте параметр шаблона и шаблон класса. Если нам надо создать шаблон класса, с одним параметром типа int и char, шаблон класса будет выглядеть так.
Как видите шаблон класса Stack объявлен и определен в файле с main-функцией. Конечно же такой способ утилизации шаблонов никуда не годится, но для примера сойдет. В строках 7 - 20 объявлен интерфейс шаблона класса. Объявление класса выполняется привычным для нас образом, а перед классом находится объявление шаблона, в строке 7. При объявлении шаблона класса, всегда используйте такой синтаксис.
Строки 47 - 100 содержат элемент-функции шаблона класса Stack, причем перед каждой функцией необходимо объявлять шаблон, точно такой же, как и перед классом - template
Чтобы привязать каждую элемент-функцию к шаблону класса, как обычно используем бинарную операцию разрешения области действия - :: с именем шаблона класса - Stack
Обратите внимание на объявление объекта myStack шаблона класса Stack в функции main, строка 24. В угловых скобочка необходимо явно указывать используемый тип данных, в шаблонах функций этого делать не нужно было. Далее в mainзапускаются некоторые функции, которые демонстрируют работу шаблона класса Stack. Результат работы программы смотрим ниже.
47Библиотека STL. Другие библиотеки контейнерных классов.