X[0] X[1] X[2] X[3] X[4]

10 20 30 40 50

2. В языке Си нет проверки правильности индекса (т.е. номера элемента). Выход за границы массива чреват непредсказуемыми последствиями.

Как известно, массив - это конечная совокупность данных одного типа. Можно говорить о массивах целых чисел, массивов символов и.т.д. Мы можем даже определить масссив, элементы которого - массивы( массив массивов), определяя, таким образм, многомерные массивы. Любой массив в программе должен быть описан: после имени массива добаляют квадратные скобки [], внутри которых обычно стоит число, показывающее количество элементов массива. Например, запись int x[10]; определяет x как массив из 10 целых чисел. В случае многомерных массивов показывают столько пар скобок , какова размерность массива, а число внутри скобок показывает размер массива по данному измерению. Например, описание двумерного массива выглядит так: int a[2][5];. Такое описание можно трактовать как матрицу из 2 строк и 5 столбцов. Для обрщения к некоторому элементу массива указывают его имя и индекс, заключенный в квадратные скобки(для многомерног массива - несколько индексов , заключенные в отдельные квадратные скобки): a[1][3], x[i] a[0][k+2]. Индексы массива в Си всегда начинаются с 0, а не с 1, т.е. описание int x[5]; порождает элементы x[0], x[1], x[2], x[3], x[4], x[5]. Индекс может быть не только целой константой или целой переменной, но и любым выражением целого типа. Переменная с индексами в программе используется наравне с простой переменной (например, в операторе присваивания, в функциях ввода- вывода). Начальные значения массивам в языке Си могут быть присвоены при компиляции только в том случае, если они объявлены с классом памяти extern или static, например:

         static int a[6]={5,0,4,-17,49,1};   

   обеспечивает присвоения a[0]=5; a[1]=0; a[2]=4 ... a[5]=1. Как видите, для начального присвоения значений некоторому массиву надо в описании поместить справа от знака = список инициирующих значений, заключенные в фигурные скобки и разделенные запятыми. Двумерный массив можно инициировать так:

     static int matr[2][5] = {{3,4,0,1,2},{6,5,1,4,9}};  

Матрица хранится в памяти построчно, т.е. самый правый индекс в наборе индексов массива меняется наиболее быстро.

Пример

#include<stdio.h>

void main(void)

{//демонстрирует работу с одномерным массивом

int mas[]={2,3,1,8,0,3,5,6,8,9};

int temp;

printf("ne otsortirovannij massiv\n");

for(int i=0;i<10;i++)

printf("%d ",mas[i]);

temp;

for(int i=0;i<10;i++)

for(int j=0;j<10;j++)

if (mas[i]>mas[j]){

temp=mas[i];

mas[i]=mas[j];

mas[j]=temp;

}

printf("\n\notsortirovannij massiv\n");

for(int i=0;i<10;i++)

printf("%d ",mas[i]);

}

Результат работы программы

Указатели.

Указаетль - это переменная, которая содержит адрес некоторого объекта в памяти компьютера. Понятно, что адрес - целое число. Понимание и правильное использование указателей очень важно для создания хороших программ.

Многие конструкции языка Си требуют применения указателей. Например, указатели необходимы для успешного использования функций и динамического распределения памяти. С указателями следует обращаться очень осторожно. Так использование в программе неинициализированного указателя может привести к "зависанию" компьютера. При неправильном, неаккуратном использовании указателей в программе могут возникнуть ошибки, которые очень трудно бывает обнаружить. Обойтись же без указателей в программах на язке Си нельзя.

3. Объявление указателей в Си.     Указатель объявляется следующим образом.

1. Вначале указывается тип указателя. Это некоторый тип языка Си. В данном случае он определяет тип объекта, на который указывает указатель.

2. Вслед за этим через пробел ставится звездочка - *. Она обозначает, что следующая за ней переменная является указателем.

Получается довольно простая формула:

тип *<простая переменная>

Например:

char *ch;

nt *temp, i, *j, *k;

loat *pt, fon;

Здесь указателями являются: ch, temp, j, k pt.

Операции над указателями в Си.

Простейшая операция над указателями - это операция &, что означает "взять адрес". Существует еще одна операция над указателями. Она обозначается символом звездочка *. Смысл этой операции таков: "значение, расположенное по указанному адресу".

Хотя знак звездочка * соответствует обычной операции умножения, но никак нельзя перепутать эти две операции. Ведь арифметическая операция умножения имеет два операнда. Иначе говоря, при умножении должны быть указаны, как данные, два числа, участвующие в умножении. Поэтому и говорят, что умножение - это бинарная операция. Операция * над указателями, в отличие от арифметического умножения, - это унарная операция. То есть, другими словами, она использует всего один операнд (одно данное).

Рассмотрим простейшие программки, поясняющие использование указателей в языке Си.

#include<stdio.h>

void main(void)

{//демонстрирует работу с указателями

float a=12.5;

float y;

float *p;

p=&a;

y=*p;

printf("a = %f y = %f \n",a,y);

(*p)++;//увеличили на 1 значение, взятое по указателю p

printf("a = %f y = %f \n",a,y);

y=y**p;//умножаем y на значение, взятое по указателю p

printf("y = %f \n",y);

}

Результат

Директивы препроцессора

При каждом запуске компилятора сначала запускается препроцессор, который выполняет директивы начинающиеся с символа #. При выполнении этих команд создается временный файл исходного кода, с которым уже работает компилятор.

Директива #include

Строка #include "имя файла"

Заменяет эту строку полным содержимым файла имя. файла. Если не указан путь то файл сначала ищется в директории исходного файла , затем в директории заданной в опциях компилятора(обычно директория Include).

Строка #include <имя файла>

Ищет файл только в директории заданной в опциях компилятора.

Директива #define

#define идентификатор строка символов

Заменяет все последующие вхождения идентификатора строкой символов. Пример:

#define A_NUMBER 100

int n=A_NUMBER;

n присвоится значение 100

#define можно применять также для определения макросов, например:

#define SWAP(a,b) temp=(a);(a)=(b);(b)=temp

Подробнее о #define (и в частности о макросах) будет отдельная статья.

Директива #undef

#undef идентификатор

Отменяет прероцессорное определение идентификатора.

Директивы #if #else #endif

#if выражение

.....

#endif

Проверяет истинно ли выражение и если истинно, то выполняет все последующие строки до директивы #endif.

Конструкция типа:

#if выражение

....

#else

...

#endif Проверяет выражение, если оно истинно то выполняются строки между #if и #else а если ложно то между #else и #endif.

Директивы #ifdef #ifndef

#ifdef идентификатор

.....

#endif

Проверяет определен ли идентификатор в препроцессоре в данный момент(директивой #define) и если определен, то выполняет все последующие строки до директивы #endif.

#ifndef идентификатор

.....

#endif

Наоборот, выполняет все последующие строки до директивы #endif если идентификатор не определен в препроцессоре в данный момент.

Директива #error

#error- сообщение об ошибке. Останавливает работу компилятора и выдает сообщение об ошибке. Например:

#ifndef smth_important

#error smth important isn't defined

#endif

Компилятор выдаст что-то типа:

Fatal F1003 file.cpp 2: Error directive: smth important isn't defined

*** 1 errors in Compile ***

Директива #line

Директива #line константа "имя файла"Заставляет компилятор считать, что константа задает номер следующей строки исходного файла, и текущий входной файл именуется идентификатором. Если идентификатор отсутствует, то запомненное имя файла не изменяется.

Директива #pragma

#pragma - это директива препроцессора, которая реализует возможности компилятора. Эти особенности могут быть связанны с типом компилятора.Разные типы компиляторов могут поддерживать разные директивы. Общий вид директивы:

#pragma команда компилятора

Например:

#pragma message("сообщение")- просто выдает сообщение при компиляции.

Области видимости

Функции и внешние переменные, из которых состоит Си-программа, каждый раз компилировать все вместе нет никакой необходимости. Исходный текст можно хранить в нескольких файлах. Ранее скомпилированные программы можно загружать из библиотек. В связи с этим возникают следующие вопросы:

• Как писать объявления, чтобы на протяжении компиляции используемые переменные были должным образом объявлены?

• В каком порядке располагать объявления, чтобы во время загрузки все части программы оказались связаны нужным образом?

• Как организовать объявления, чтобы они имели лишь одну копию?

• Как инициализировать внешние переменные?

Начнем с того, что разобьем программу-калькулятор на несколько файлов. Конечно, эта программа слишком мала, чтобы ее стоило разбивать на файлы, однако разбиение нашей программы позволит продемонстрировать проблемы, возникающие в больших программах.

Областью видимостиимени считается часть программы, в которой это имя можно использовать. Для автоматических переменных, объявленных в начале функции, областью видимости является функция, в которой они объявлены. Локальные переменные разных функций, имеющие, однако, одинаковые имена, никак не связаны друг с другом. То же утверждение справедливо и в отношении параметров функции, которые фактически являются локальными переменными.

Область действия внешней переменной или функции простирается от точки программы, где она объявлена, до конца файла, подлежащего компиляции. Например, если main,sp,val,pushиpopопределены в одном файле в указанном порядке, т. е.

main() {...}

int sp = 0;

double val[MAXVAL];

void push(double f) {...}

double pop(void) {...}

то к переменным spиvalможно адресоваться изpushиpopпросто по их именам; никаких дополнительных объявлений для этого не требуется. Заметим, что вmainэти имена не видимы так же, как и самиpushиpop.

Однако, если на внешнюю переменную нужно сослаться до того, как она определена, или если она определена в другом файле, то ее объявление должно быть помечено словом extern.

Важно отличать объявлениевнешней переменной от ееопределения. Объявление объявляет свойства переменной (прежде всего ее тип), а определение, кроме того, приводит к выделению для нее памяти. Если строки

int sp;

double val[MAXVAL];

расположены вне всех функций, то они определяютвнешние переменныеspиval, т. e. отводят для них память, и, кроме того, служат объявлениями для остальной части исходного файла. А вот строки

extern int sp;

extern double val[];

объявляютдля оставшейся части файла, чтоsp- переменная типаint, аval- массив типаdouble(размер которого определен где-то в другом месте); при этом ни переменная, ни массив не создаются, и память им не отводится.

На всю совокупность файлов, из которых состоит исходная программа, для каждой внешней переменной должно быть одно-единственное определение; другие файлы, чтобы получить доступ к внешней переменной, должны иметь в себе объявлениеextern. (Впрочем, объявлениеexternможно поместить и в файл, в котором содержится определение.) В определениях массивов необходимо указывать их размеры, что в объявленияхexternне обязательно. Инициализировать внешнюю переменную можно только в определении. Хотя вряд ли стоит организовывать нашу программу таким образом, но мы определим push и pop в одном файле, а val и sp - в другом, где их и инициализируем. При этом для установления связей понадобятся такие определения и объявления:

В файле 1:

extern int sp;

extern double val[];

void push(double f) {...}

double pop(void) {...}

В файле2:

int sp = 0;

double val[MAXVAL];

Поскольку объявления externнаходятся в началефайла1и вне определений функций, их действие распространяется на все функции, причем одного набора объявлений достаточно для всегофайла1. Та же организацияextern-объявлений необходима и в случае, когда программа состоит из одного файла, но определения sp и val расположены после их использования.

Классы памяти и область действия

Автоматические, внешние, статические и регистровые переменные.

Каждая переменная имеет тип и принадлежит к некоторому классу памяти. Время жизни и область действия идентификатора определяются ассоциированным с ним классом памяти. Существуют четыре разновидности классов памяти:

auto- автоматический - локальные идентификаторы, память для которых выделяется при входе в блок, т.е. составной оператор, и освобождается при выходе из блока. Слово auto является сокращением слова automatic.

static - статический - локальные идентификаторы, существующие в процессе всех выполнений блока. В отличие от идентификаторов типа auto, для идентификаторов типа static память выделяется только один раз - в начале выполнения программы, и они существуют, пока программа выполняется.

extern- внешний - идентификаторы, называемые внешними, external, используются для связи между функциями, в том числе независимо скомпилированными функциями, которые могут находиться в различных файлах. Память, ассоциированная с этими идентификаторами, является постоянной, однако ее содержимое может меняться. Эти идентификаторы описываются вне функции.

register- регистровый - идентификаторы, подобные идентификаторам типа auto. Их значения, если это возможно, должны помещаться в регистрах машины для обеспечения быстрого доступа к данным.

Если класс памяти идентификатора не указан явно, то его класс памяти задается положением его определения в тексте программы. Если идентификатор определяется внутри функции, тогда его класс памяти auto, в остальных случаях идентификатор имеет класс памяти extern.

Автоматические переменные

По умолчанию переменные, описанные внутри функции, являются автоматическими. Можно, однако, это подчеркнуть явно с помощью ключевого слова auto:

main( )

{

auto int kat;

}

Так поступают, если хотят, например, показать, что определение переменной не нужно искать вне функции.

Автоматические переменные имеют локальную область действия. Только функция, в которой переменная определена, знает ее. Другие функции могут использовать переменные с тем же самым именем, но это будут независимые переменные, находящиеся в разных ячейках памяти.

Автоматическая переменная начинает существовать при вызове функции, содержащей ее. Когда функция завершает свою работу и возвращает управление туда, откуда ее вызвали, автоматическая переменная исчезает. Область действия автоматической переменной ограничена блоком, т.е. { }, в котором переменная описана.

!	Мы всегда должны описывать наши переменные в начале тела функции (блока). Областью действия их является вся функция. Можно описать переменную внутри подблока. Тогда переменная будет известна только в этой части функции, однако этого лучше не делать. Это дурной стиль программирования!

Внешние переменные

Переменная, описанная вне функции, является внешней.

Глобальные переменные определяются на том же уровне, что и функции, т.е. они не локальны ни в каком блоке. Постоянные глобальные переменные инициализируются нулем, если явно не задано другое начальное значение. Областью действия является вся программа. Они должны быть описаны во всех файлах программы, в которых к ним есть обращения. Некоторые компиляторы требуют, чтобы глобальные переменные были определены только в одном файле, и описаны как внешние в других файлах, где они используются. Глобальные переменные должны быть описаны в файле до первого использования.

Пример:

int global_flag;

Внешнюю переменную можно описать и в функции, которая использует ее, при помощи ключевого слова extern. Группу extern-описаний можно совсем опустить, если исходные определения переменных появляются в том же файле и перед функцией, которая их использует. Включение ключевого словаexternпозволяет функции использовать внешнюю переменную, даже если она определяется позже в этом или другом файле. Оба файла должны быть скомпилированы, связаны или собраны в одно и то же время.

Если слово extern не включено в описание внутри функции, то под этим именем создается новая автоматическая переменная. Мы можем пометить вторую переменную как автоматическую с помощью слова auto.

Статические переменные

Статическиездесь означает, что переменные остаются в работе. Они имеют такую же область действия, как автоматические переменные, но они не исчезают, когда содержащая их функция закончит свою работу. Компилятор хранит их значения от одного вызова функции до другого.

Пример:

/* Статическая переменная */

#include <stdio.h>

void man_woman( )

{

int man = 1;

static int woman = 1;

printf("man = %d and woman = %d\n",

man++, woman++);

}

void main(void)

{

int count;

for(count = 1;count <= 3; count ++)

{

printf("Count students %d:\n", count);

man_woman ( );

}

}

Результат работы программы

Функция man_woman увеличивает каждую переменную после печати ее значения. Работа этой программы дает следующие результаты:

Подсчет студентов 1:

юношей = 1 и девушек = 1

Подсчет студентов 2:

юношей = 1 и девушек = 2

Подсчет студентов 3:

юношей = 1 и девушек = 3

Статическая переменная woman помнит, что ее значение было увеличено на 1, в то время как для переменной man начальное значение устанавливается каждый раз заново. Это указывает на разницу в инициализации: man инициализируется каждый раз, когда вызывается man_woman ( ), в то время как woman инициализируется только один раз при компиляции функции man_woman ( ).

Внешние статические переменные

Можно описать статическиепеременные вне любой функции. Это создает внешнюю статическую переменную. Разница между внешней переменной и внешней статической переменной заключается в области их действия. Обычная внешняя переменная может использоваться функциями в любом файле, а внешняя статическая переменная может использоваться только функциями того же самого файла, причем после определения переменной. Статическую переменную мы описываем вне любой функции.

Регистровые переменные

Обычно переменные хранятся в памяти машины. Регистровые переменные запоминаются в регистрах центрального процессора, где доступ к ним и работа с ними выполняются гораздо быстрее, чем в памяти. В остальном регистровые переменные аналогичны автоматическим переменным.

Пример:

main( )

{

register int pleat;

}

Компилятор сравнивает наши требования с количеством доступных регистров, поэтому мы можем и не получить то, что хотим. В этом случае переменная становится простой автоматической переменной.

Особенности работы с языком Си. Какой класс памяти применять? Ответ на вопрос - автоматический. Этот класс памяти выбран по умолчанию. Использование внешних переменных очень соблазнительно. Если описать все переменные как внешние, то не будет забот при использовании аргументов и указателей для связи между функциями в прямом и обратном направлениях. Но тогда возникает проблема с функцией С, изменяющей переменные в функции А, а мы этого не хотели! Такая проблема значительно перевешивает кажущуюся привлекательность широкого использования внешних переменных. Одно из золотых правил программирования заключается в соблюдении принципа "необходимо знать только то, что нужно". Организуйте работу каждой функции автономно, насколько это возможно, и используйте глобальные переменные только тогда, когда это действительно необходимо!

Операция получения адреса & неприменима к регистровым переменным. Любые переменные в блоке, кроме формальных параметров функции, могут быть определены как статические.

Подведем итог.

Классы памяти, которые описываются внутри функции:

1. автоматический, продолжительность существования - временно, область действия - локальная;

2. регистровый, продолжительность существования - временно, область действия - локальная;

3. статический, продолжительность существования - постоянно, область действия - локальная.

Классы памяти, которые определяются вне функции:

1. внешний, продолжительность существования - постоянно, область действия глобальная (все файлы);

2. внешний статический, продолжительность существования - постоянно, область действия - глобальная (один файл).

Определение и вызов функций

Функция - это совокупность объявлений и операторов, обычно предназначенная для решения определенной задачи. Каждая функция должна иметь имя, которое используется для ее объявления, определения и вызова. В любой программе на СИ должна быть функция с именем main (главная функция), именно с этой функции, в каком бы месте программы она не находилась, начинается выполнение программы.

При вызове функции ей при помощи аргументов (формальных параметров) могут быть переданы некоторые значения (фактические параметры), используемые во время выполнения функции. Функция может возвращать некоторое (одно !) значение. Это возвращаемое значение и есть результат выполнения функции, который при выполнении программы подставляется в точку вызова функции, где бы этот вызов ни встретился. Допускается также использовать функции не имеющие аргументов и функции не возвращающие никаких значений. Действие таких функций может состоять, например, в изменении значений некоторых переменных, выводе на печать некоторых текстов и т.п..

С использованием функций в языке СИ связаны три понятия - определение функции (описание действий, выполняемых функцией), объявление функции (задание формы обращения к функции) и вызов функции.

Определение функции задает тип возвращаемого значения, имя функции, типы и число формальных параметров, а также объявления переменных и операторы, называемые телом функции, и определяющие действие функции. В определении функции также может быть задан класс памяти.

Пример:

int rus (unsigned char r)

{ if (r>='А' && c<=' ')

return 1;

else

return 0;

}

В данном примере определена функция с именем rus, имеющая один параметр с именем r и типом unsigned char. Функция возвращает целое значение, равное 1, если параметр функции является буквой русского алфавита, или 0 в противном случае.

Передача аргументов, стек.

При вызове функции с переменным числом параметров в вызове этой функции задается любое требуемое число аргументов. В объявлении и определении такой функции переменное число аргументов задается многоточием в конце списка формальных параметров или списка типов аргументов.

Все аргументы, заданные в вызове функции, размещаются в стеке. Количество формальных параметров, объявленных для функции, определяется числом аргументов, которые берутся из стека и присваиваются формальным параметрам. Программист отвечает за правильность выбора дополнительных аргументов из стека и определение числа аргументов, находящихся в стеке.

Примерами функций с переменным числом параметров являются функции из библиотеки функций языка СИ, осуществляющие операции ввода-вывода информации (printf,scanf и т.п.). Подробно эти функции рассмотрены во третьей части книги.

Программист может разрабатывать свои функции с переменным числом параметров. Для обеспечения удобного способа доступа к аргументам функции с переменным числом параметров имеются три макроопределения (макросы) va_start, va_arg, va_end, находящиеся в заголовочном файле stdarg.h. Эти макросы указывают на то, что функция, разработанная пользователем, имеет некоторое число обязательных аргументов, за которыми следует переменное число необязательных аргументов. Обязательные аргументы доступны через свои имена как при вызове обычной функции.

Функция форматированного вывода printf

Функция printf() является функцией стандартного вывода. С помощью этой функции можно вывести на экран монитора строку символов, число, значение переменной... 

Функция printf() имеет прототип в файле stdio.h int printf(char *управляющая строка, ...);

В случае успеха функция printf() возвращает число выведенных символов.

Управляющая строка содержит два типа информации: символы, которые непосредственно выводятся на экран, и спецификаторы формата, определяющие, как выводить аргументы.

Функция printf() это функция форматированного вывода. Это означает, что в параметрах функции необходимо указать формат данных, которые будут выводиться. Формат данных указывается спецификаторами формата. Спецификатор формата начинается с символа % за которым следует код формата.

Спецификаторы формата:

%с	символ
%d	целое десятичное число
%i	целое десятичное число
%e	десятичное число в виде x.xx e+xx
%E	десятичное число в виде x.xx E+xx
%f	десятичное число с плавающей запятой xx.xxxx
%F	десятичное число с плавающей запятой xx.xxxx
%g	%f или %e, что короче
%G	%F или %E, что короче
%o	восьмеричное число
%s	строка символов
%u	беззнаковое десятичное число
%x	шестнадцатеричное число
%X	шестнадцатеричное число
%%	символ %
%p	указатель
%n	указатель

Кроме того, к командам формата могут быть применены модификаторы l и h.

%ld	печать long int
%hu	печать short unsigned
%Lf	печать long double

В спецификаторе формата, после символа % может быть указана точность (число цифр после запятой). Точность задаётся следующим образом: %.n<код формата>. Где n - число цифр после запятой, а <код формата> - один из кодов приведённых выше.

Например, если у нас есть переменная x=10.3563 типа float и мы хотим вывести её значение с точностью до 3-х цифр после запятой, то мы должны написать:

printf("Переменная x = %.3f",x);

Результат: Переменная x = 10.356

Вы также можете указать минимальную ширину поля отводимого для печати. Если строка или число больше указанной ширины поля, то строка или число печатается полностью.   Например, если вы напишите:

printf("%5d",20);

то результат будет следующим:    20

Обратите внимание на то, что число 20 напечаталось не с самого начала строки. Если вы хотите чтобы неиспользованные места поля заполнялись нулями, то нужно поставить перед шириной поля символ 0. Например:

printf("%05d",20);

Результат: 00020

Кроме спецификаторов формата данных в управляющей строке могут находиться управляющие символы:

\b	BS, забой
\f	Новая страница, перевод страницы
\n	Новая строка, перевод строки
\r	Возврат каретки
\t	Горизонтальная табуляция
\v	Вертикальная табуляция
\"	Двойная кавычка
\'	Апостроф
\\	Обратная косая черта
\0	Нулевой символ, нулевой байт
\a	Сигнал
\N	Восьмеричная константа
\xN	Шестнадцатеричная константа
\?	Знак вопроса

Чаще всего вы будете использовать символ \n. С помощью этого управляющего символа вы сможете переходить на новую строку. Посмотрите примеры программ и вы всё поймёте.

Примеры программ.

/* Пример 1 */

#include <stdio.h>

void main(void)

{     int a,b,c;        // Объявление переменных a,b,c

    a=5;

    b=6;

    c=9;

    printf("a=%d, b=%d, c=%d",a,b,c);

}

Результат работы программы:

a=5, b=6, c=9

 

/* Пример 2 */

#include <stdio.h>

void main(void)

{     float x,y,z;

    x=10.5;

    y=130.67;

    z=54;

    printf("Координаты объекта: x:%.2f, y:%.2f, z:%.2f", x, y, z);

}

Результат работы программы:

Координаты объекта: x:10.50, y:130.67, z:54.00

Функция стандартного ввода scanf()

Функция scanf() - функция форматированного ввода. С её помощью вы можете вводить данные со стандартного устройства ввода (клавиатуры). Вводимыми данными могут быть целые числа, числа с плавающей запятой, символы, строки и указатели.

Функция scanf() имеет следующий прототип в файле stdio.h: int scanf(char *управляющая строка);

Функция возвращает число переменных которым было присвоено значение.

Управляющая строка содержит три вида символов: спецификаторы формата, пробелы и другие символы. Спецификаторы формата начинаются с символа %.

Спецификаторы формата:

%c	чтение символа
%d	чтение десятичного целого
%i	чтение десятичного целого
%e	чтение числа типа float (плавающая запятая)
%h	чтение short int
%o	чтение восьмеричного числа
%s	чтение строки
%x	чтение шестнадцатеричного числа
%p	чтение указателя
%n	чтение указателя в увеличенном формате

При вводе строки с помощью функции scanf() (спецификатор формата %s), строка вводиться до первого пробела!! т.е. если вы вводите строку "Привет мир!" с использованием функции scanf()

char str[80];        // массив на 80 символов scanf("%s",str);

то после ввода результирующая строка, которая будет храниться в массиве str будет состоять из одного слова "Привет". ФУНКЦИЯ ВВОДИТ СТРОКУ ДО ПЕРВОГО ПРОБЕЛА! Если вы хотите вводить строки с пробелами, то используйте функцию 

char *gets( char *buf );

С помощью функции gets() вы сможете вводить полноценные строки. Функция gets() читает символы с клавиатуры до появления символа новой строки (\n). Сам символ новой строки появляется, когда вы нажимаете клавишу enter. Функция возвращает указатель на buf. buf - буфер (память) для вводимой строки.

Напишем пример программы, которая позволяет ввести целую строку с клавиатуры и вывести её на экран с помощью gets().

#include <stdio.h> void main(void) {     char buffer[100];       // массив (буфер) для вводимой строки     gets(buffer);            // вводим строку и нажимаем enter     printf("%s",buffer);    // вывод введённой строки на экран }

Ещё одно важное замечание! Для ввода данных с помощью функции scanf(), ей в качестве параметров нужно передавать адреса переменных, а не сами переменные. Чтобы получить адрес переменной, нужно поставить перед именем переменной знак &(амперсанд). Знак & означает взятие адреса.

Что значит адрес? Попробую объяснить. В программе у нас есть переменная. Переменная хранит своё значение в памяти компьютера. Так вот адрес, который мы получаем с помощью & это адрес в памяти компьютера где храниться значение переменной. 

Давайте рассмотрим пример программы, который показывает нам как использовать &

#include <stdio.h>

void main(void)

{     int x;

    printf("Введите переменную x:");

    scanf("%d",&x);

    printf("Переменная x=%d",x);

}

Теперь давайте вернёмся к управляющей строке функции scanf(). Ещё раз:

int scanf(char *управляющая строка);

Символ пробела в управляющей строке дает команду пропустить один или более пробелов в потоке ввода. Кроме пробела может восприниматься символ табуляции или новой строки. Ненулевой символ указывает на чтение и отбрасывание этого символа.

Разделителями между двумя вводимыми числами являются символы пробела, табуляции или новой строки. Знак * после % и перед кодом формата (спецификатором формата) дает команду прочитать данные указанного типа, но не присваивать это значение.

Например:

scanf("%d%*c%d",&i,&j);

при вводе 50+20 присвоит переменной i значение 50, переменной j - значение 20, а символ + будет прочитан и проигнорирован.

В команде формата может быть указана наибольшая ширина поля, которая подлежит считыванию.

Например:

scanf("%5s",str);

прророотт необходимость прочитать из потока ввода первые 5 символов. При вводе 123т и7890ABC массив str будет содержать только 12345, остальные символы будут ртоигнорированы. Разделители: пробел, символ табуляции и символ новой строки - при вводе олвола воспринимаются, как и все другие символы.

Указатели на функции

Указатели на функции– мощное средство языка С. Функция располагается в памяти по определенному адресу. Адресом функции является ее точка входа. Именно этот адрес используется при вызове функции. Так как указатель хранит адрес функции, то она может быть вызвана с помощью этого указателя. Он позволяет также передавать ее другим функциям в качестве аргумента.

В программе на С адресом функции служит ее имя без скобок и аргументов (это похоже на адрес массива, который равен имени массива без индексов).

Пример:

void error(char* p) { /* ... */ }

         void (*efct)(char*);   // указатель на функцию

        voidf()

         {

           efct= &error;      //efctнастроен на функциюerror

           (*efct)("error");   // вызовerrorчерез указательefct

}

о

Для вызова функции с помощью указателя (efct в нашем примере) надо вначале применить операцию косвенности к указателю - *efct. Поскольку приоритет операции вызова () выше, чем приоритет косвенности *, нельзя писать просто *efct("error"). Это будет означать *(efct("error")), что является ошибкой. По той же причине скобки нужны и при описании указателя на функцию. Однако, писать просто efct("error") можно, т.к. транслятор понимает, что efct является указателем на функцию, и создает команды, делающие вызов нужной функции.

Отметим, что формальные параметры в указателях на функцию описываются так же, как и в обычных функциях. При присваивании указателю на функцию требуется точное соответствие типа функции и типа присваиваемого значения. Например:

  void (*pf)(char*);          // указатель на void(char*)

          void f1(char*);             // void(char*);

          int f2(char*);              // int(char*);

бл          void f3(int*);              // void(int*);

          voidf()

          {

            pf= &f1;                // нормально

            pf= &f2;                // ошибка: не тот тип возвращаемогожэхюж

                                      // значения

           pf= &f3;                // ошибка: не тот тип параметра

           (*pf)("asdf");            // нормально

            (*pf)(1);                 // ошибка: не тот тип параметра

            int i = (*pf)("qwer");    // ошибка: void присваивается int

          }

Правила передачи параметров одинаковы и для обычного вызова,  и для вызова с помощью указателя.

Декларация структур.

Cтруктуры - это составной объект, в который входят элементы любых типов, за исключением функций. В отличие от массива, который является однородным объектом, структура может быть неоднородной. Тип структуры определяется записью вида:

struct { список определений }

В структуре обязательно должен быть указан хотя бы один компонент. Определение структур имеет следующий вид:

тип-данных описатель;

где тип-данных указывает тип структуры для объектов, определяемых в описателях. В простейшей форме описатели представляют собой идентификаторы или массивы.

Пример:

struct { double x,y; } s1, s2, sm[9];

struct { int year;

char moth, day; } date1, date2;

Переменные s1, s2 определяются как структуры, каждая из которых состоит из двух компонент х и у. Переменная sm определяется как массив из девяти структур. Каждая из двух переменных date1, date2 состоит из трех компонентов year, moth, day. >p>Существует и другой способ ассоциирования имени с типом структуры, он основан на использовании тега структуры. Тег структуры аналогичен тегу перечислимого типа. Тег структуры определяется следующим образом:

struct тег { список описаний; };

где тег является идентификатором.

В приведенном ниже примере идентификатор student описывается как тег структуры:

struct student { char name[25];

int id, age;

char prp; };

Тег структуры используется для последующего объявления структур данного вида в форме:

struct тег список-идентификаторов;

Пример:

struct studeut st1,st2;

Использование тегов структуры необходимо для описания рекурсивных структур. Ниже рассматривается использование рекурсивных тегов структуры.

struct node { int data;

struct node * next; } st1_node;

Тег структуры node действительно является рекурсивным, так как он используется в своем собственном описании, т.е. в формализации указателя next. Структуры не могут быть прямо рекурсивными, т.е. структура node не может содержать компоненту, являющуюся структурой node, но любая структура может иметь компоненту, являющуюся указателем на свой тип, как и сделано в приведенном примере.

Доступ к компонентам структуры осуществляется с помощью указания имени структуры и следующего через точку имени выделенного компонента, например:

st1.name="Иванов";

st2.id=st1.id;

st1_node.data=st1.age;