Fseek(указатель на файл, позиция, параметр)

где позиция – количество байтов (знаков), отстоящих от данного места, параметрSEEK_SET – начало файла,

SEEK_CUR – текущая позиция файла,

SEEK_END – конец файла.

Пример 1: прочесть знак из бинарного файла, отстоящий от начала файла на 9 байтов:

f_bin=fopen("D:/User/my_file.dat", "rb");

fseek(f_bin, 9, SEEK_SET);

fscanf(f_bin, "%c", &d);

printf("%c Fseek(указатель на файл, позиция, параметр)", d);

На экран будет выведено:

*

Пример 2: прочесть знак из бинарного файла, отстоящий от конца файла на 6 байтов:

f_bin=fopen("D:/User/my_file.dat", "rb");

fseek(f_bin, -6, SEEK_END);

fscanf(f_bin, "%c", &d);

printf("%c", d);

На экран будет выведено:

+

б) определение номера текущей позиции, занимаемой указателем Fseek(указатель на файл, позиция, параметр) файла (нумерация позиций начинается с нуля)

fgetpos(указатель на файл, fpos_t *pos)

где pos – текущая позиция указателя файла – переменная типа fpos_t (определен в stdio.h).

Пример: найти номера позиций исходного и конечного знаков файла:

fpos_t *nomer;

f_bin=fopen("D:/User/my_file.dat", "rb");

fgetpos(f_bin Fseek(указатель на файл, позиция, параметр), &nomer); // номер исходного знака

printf("\n nomer=%d", nomer);

while (!feof(f_bin)) // читаем файл до конца

{

fscanf(f_bin, "%c", &d);

}

fgetpos(f_bin, &nomer); // номер конечного знака

printf("\n nomer=%d", nomer);

На экран будет выведено:

nomer=0

nomer=15


Функции

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

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

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

Примерами подпрограмм являются программки вычисления отдельных функций, имеющихся в библиотеках языков программирования, – стандартных функций, также функций ввода-вывода. Эти подпрограммы расположены в системной библиотеке языка, подключаемой к программке юзера при ее обработке. Означает, используя в собственной программке, к Fseek(указатель на файл, позиция, параметр) примеру, функцию printf, мы обращаемся к стандартной библиотеке ввода-вывода stdio.h, подсоединяемой к нашей программке директивой препроцессора #include .

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

В отличие от Паскаля в языке Си употребляется только один Fseek(указатель на файл, позиция, параметр) вид подпрограмм – функции. Вообщем неважно какая программка на Си представляет собой совокупа взаимосвязанных функций, одна из которых является основной (головной) – main. С нее и начинается выполнение программки.

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

Один из недочетов Паскаля заключался Fseek(указатель на файл, позиция, параметр) в том, что описание применяемой функции необходимо было помещать вовнутрь вызывающей ее программки, в раздел описания процедур и функций. В языке Си описание функций помещается раздельно от вызывающих программ, а перед заголовком main() основной программки помещаются макеты (объявления) этих функций:

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

Макеты функций

Void main()

{

Головная программка с воззваниями к функциям

}

Описание функций

Таким Fseek(указатель на файл, позиция, параметр) макаром, функции, применяемые в программке, должны быть непременно объявлены – указан их макет. Макет – это заголовок функции с указанием ее типа, имени, типов и имен аргументов – формальных характеристик:

int summa(int a, int b);

void vorm_mass(int n, int m, int mass[n][m]);

Внимание! После закрывающих скобок точка Fseek(указатель на файл, позиция, параметр) с запятой ставится непременно!

Таким макаром, макет функции вполне соответствует ее заголовку, применяемому при ее предстоящем описании.

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

Int summa(int a, int b)

{

int s; // s – локальная переменная

s = a + b;

return s; // возврат вычисленного значения

}

void vorm_mass(int n, int m, int mass[n Fseek(указатель на файл, позиция, параметр)][m])

{

int i, j;

for (i=0; i

for (j=0; j

{

// задание значений элементам массива mass[n][m]

}

}

Внимание! После заголовка функции и закрывающих фигурных скобок точка с запятой не ставится!

В последнем случае оператор return не нужен, потому что функция vorm_mass имеет тип void – ничего не Fseek(указатель на файл, позиция, параметр) возвращает.

Если функция не имеет формальных характеристик, то их в заголовке функции
не указывают, но круглые скобки оставляют.

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

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

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

Функция возвращает вычисленное значение, если она завершается оператором возврата return, после которого следует имя переменной Fseek(указатель на файл, позиция, параметр) либо выражение, значение которого должна найти функция:

Int summa(int a, int b)

{

return a + b; // возврат вычисленного значения

}

Если после слова return ничего не стоит либо этого слова вообщем нет
в функции, то означает, что данная функция не возвращает никакого значения, и потому в ее заголовке должен быть указан тип void.

Формальные Fseek(указатель на файл, позиция, параметр) характеристики функции в Си соответствуют параметрам-значениям подпрограмм в Паскале: они служат только для передачи значений фактических характеристик в функцию и вычисления ее значения. Потому даже если снутри функции они меняются, то надлежащие им фактические (входные) характеристики не меняются, оставаясь такими же, какими они были при вызове функции: с чем Fseek(указатель на файл, позиция, параметр) пришел – с тем
и ушел
:

Int summa(int a, int b)

{

int s; // s – локальная переменная

a++;

b++;

s = a + b;

return s; // возврат вычисленного значения

}

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

Таким макаром, функция в Си вычисляет единственное значение, передаваемое вовне оператором return .

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

Сделаем функцию, которая меняет значениями две переменных:

Void swap Fseek(указатель на файл, позиция, параметр)(int a, int b)

{

int temp; // temp – локальная переменная

temp=a; // метод повторяющегося обмена

a=b;

b=temp;

}

Эта функция не производит никаких действий над фактическими параметрами, потому что будут обмениваться значениями только формальные характеристики: с чем пришел – с тем и ушел. Перепишем ее последующим образом:

void swap(int *a, int *b) // используем Fseek(указатель на файл, позиция, параметр) значения переменных

{ // по адресам переменных a и b

int temp;

temp=*a; // метод повторяющегося обмена

*a=*b; // значениями, находящимися

*b=temp; // по этим адресам

}

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

Обратимся к этой функции, к примеру, из головной программки:

int x, y;

x = 5;

y = 3;

swap(&x, &y); // используем адреса фактических переменных

В данном случае переменные x и y поменяются своими значениями.

Если в качестве формальных характеристик употребляются имена массивов (строк), то в Fseek(указатель на файл, позиция, параметр) перечне фактических характеристик перед ними знаки амперсанда &не ставятся: имя массива в Си является адресом его первого элемента. Потому в функцию передается не массив со всеми значениями его частей, а только адресок его первого элемента. Адреса всех других частей рассчитываются автоматом:

void poplavok(int n, int vector[n])

{

int top, bottom, temp;

for (top Fseek(указатель на файл, позиция, параметр)=0, bottom = n-1; top

{

temp = vector[top];

vector[top] = vector[bottom];

vector[bottom] = temp;

}

}

Эта функция переворачивает вектор vector[n] – делает «поплавок».

Более того, при передаче в функцию вектора можно не указывать его длину, оставляя квадратные скобки за его именованием пустыми:

void poplavok(int n, int vector[])

Обратимся к этой функции из головной Fseek(указатель на файл, позиция, параметр) программки:

#include

#include

void poplavok(int n, int vector[]); // макет функции

Int main()

{

int i, k=5;

int vect[k] = {1,2,3,4,5}; // инициализация вектора

printf("\n"); // вывод начального вектора

for (i=0; i

printf("%5d", vect[i]);

printf("\n");

poplavok(k, vect); // воззвание к функции

for (i=0; iвывод приобретенного вектора

printf("%5d", vect Fseek(указатель на файл, позиция, параметр)[i]);

printf("\n");

printf("\n");

}

void poplavok(int n, int vector[]) // описание функции

{

int top, bottom, temp;

for (top=0, bottom = n-1; top

{

temp = vector[top];

vector[top] = vector[bottom];

vector[bottom] = temp;

}

}

На экран будет выведено:

1 2 3 4 5

5 4 3 2 1

Если в качестве формального параметра функции употребляется многомерный массив, то в заголовке функции после Fseek(указатель на файл, позиция, параметр) его имени в отдельных квадратных скобках указываются все его размеры:

void vorm_mass(int n, int m, int mass[n][m])

{

int i, j;

for (i=0; i

for (j=0; j

{

mass[i][j]=i + j;

}

}

Обратимся к этой функции из головной программки:

#include

#include

void vorm_mass Fseek(указатель на файл, позиция, параметр)(int n, int m, int mass[n][m]); // макет

Int main()

{

int i, j;

int k=2, d=3;

int massiv[k][d];

vorm_mass(k, d, massiv); // воззвание к функции

printf("\n");

for (i=0; iвывод приобретенного массива

{ // построчно

for (j=0; j

printf("%5d", massiv[i][j]);

printf("\n");

}

}

void vorm_mass Fseek(указатель на файл, позиция, параметр)(int n, int m, int mass[n][m])

{ // описание функции

int i, j;

for (i=0; i

for (j=0; j

{

mass[i][j]=i + j;

}

}

Итог работы программки:

0 1 2

1 2 3

Рекурсия

Внедрение рекурсии в программировании базируется на рекурсивных математических определениях. Считается, что в арифметике рекурсивность как принцип определений употребляется с 1890 года Fseek(указатель на файл, позиция, параметр). В первый раз ее применил Д. Гильберт.

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

К примеру, вычисление факториала целого неотрицательного числа n! = 1·2·3·…·(n-1) · n . Не считая того, по определению, 0! = 1. Рекурсивное математическое определение факториала имеет вид

1 при Fseek(указатель на файл, позиция, параметр) n = 0,

n!=(n – 1)!·n при n > 0.

Последовательность чисел Фибоначчи имеет вид 1, 1, 2, 3, 5, 8, 13…

В ней два первых числа фиксированы и равны единице, а каждое следующее число равно сумме 2-ух прошлых. Рекурсивное математическое определение числа Фибоначчи с порядковым номером n имеет вид:

1 при n = 1,

1 при n = 2,

Fn=Fn-2 + Fn-1 при n > 2.

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

На базе рекурсивных определений можно выстроить малогабаритные и выразительные подпрограммы. Полностью разумеется, что за хоть каким Fseek(указатель на файл, позиция, параметр) из приведенных рекурсивных определений скрывается некоторый повторяющийся процесс вычислений. Таковой повторяющийся процесс допускает реализацию на базе некоей рекуррентной формулы, производной от соответственного рекурсивного определения. Рекуррентные формулы являются составными и определяют числовые последовательности, в каких каждый очередной член находится в зависимости от 1-го либо нескольких прошлых. При всем этом для рекуррентной формулы Fseek(указатель на файл, позиция, параметр) типично, что она представляет собой зависимость еще одного члена последовательности от строго определенных прошлых ее членов. Составной частью рекуррентной формулы является прямое определение 1-го либо нескольких исходных членов последовательности. В большинстве случаев определяемая последовательность нескончаема, потому требуется указать требуемое количество ее членов. Трансформируем вышеприведенные рекурсивные математические Fseek(указатель на файл, позиция, параметр) определения в рекуррентные формулы.

Разглядим последовательность факториалов целых чисел 0!, 1!, 2!, 3!, …, в какой ai = i!, i = 1, 2, 3, …. Эту же последовательность можно представить в виде рекуррентной формулы: ai = ai-1·i, a0 = 1, i = 1, 2, 3… Эта формула задает последовательность, в какой каждый очередной член зависит конкретно от предыдущего. Исходный член последовательности a0 задан прямою. Обнаружив член последовательности с порядковым Fseek(указатель на файл, позиция, параметр) номером i = n, мы тем решим задачку вычисления n!

Рекуррентная формула для вычисления числа Фибоначчи с данным порядковым номером i = n фактически не отличается от рекурсивного определения:

Fi = Fi-2 + Fi-1, F1 = 1, F2 = 1, i = 3, 4, 5,…

Итак, функция считается рекурсивной, если при решении задачки она обращается к самой для себя либо Fseek(указатель на файл, позиция, параметр) конкретно, либо через другие подпрограммы. Понятно, как на техническом уровне реализуется воззвание к подпрограмме в общем случае:

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

2) в свободном месте памяти размещаются все нужные локальные переменные вызываемой подпрограммы, также Fseek(указатель на файл, позиция, параметр) копии тех ее характеристик, которые передаются по значению,

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

При рекурсивном воззвании всякий раз приходится запоминать не только лишь адресок возврата, да и всю совокупа данных вызывающей подпрограммы (локальные переменные и параметры Fseek(указатель на файл, позиция, параметр)-значения). С этой целью употребляется автоматом выделяемая область памяти – стек, структура, работающая по принципу LIFO (Last in – first out: последним пришел – первым вышел). Таковой способ работы с памятью обеспечивает серьезное соответствие прямого порядка записи данных оборотному порядку их чтения. Только при помощи стека можно довольно легко обеспечить корректное окончание работы цепочки подпрограмм, любая из Fseek(указатель на файл, позиция, параметр) которых вызывает последующую: поначалу должна быть завершена последняя, потом – предпоследняя и т.д.. Наибольший размер стека – 65520 б. Потому последовательность рекурсивных воззваний не может быть нескончаемой. В хоть какой рекурсивной подпрограмме должна быть нерекурсивная (терминальная) ветвь, обеспечивающая выход из рекурсии. При переполнении стека работа программки прерывается и возникает сообщение об ошибке Fseek(указатель на файл, позиция, параметр).

Рекурсивная функция, вычисляющая факториал данного числа n, может иметь вид:

Long factorial(int n)

{

if (n <= 1)

return 1; // выход из рекурсии – терминальная ветвь

else return n * factorial(n-1);

}

При n = 5 эта функция будет работать последующим образом:

factorial := 5 * factorial(4)

5 * 4 * factorial(3)

5 * 4 * 3 * factorial(2)

5 * 4 * 3 * 2 * factorial(1)

5 * 4 * 3 * 2 * 1 = 120

В этом случае реализована так именуемая нисходящая рекурсия: вызов factorial(5) значит Fseek(указатель на файл, позиция, параметр), что функция factorial вызывает себя раз за разом: factorial(4), factorial(3), … – до того времени, пока не будет достигнута терминальная ситуация – ситуация окончания рекурсии. При каждом вызове текущие вычисления откладываются, локальные переменные и адресок возврата остаются в стеке. Терминальная ситуация factorial = 1 достигается при n = 1. При всем этом рекурсивный спуск завершается, начинается рекурсивный возврат изо всех Fseek(указатель на файл, позиция, параметр) вызванных на этот момент копий функции: начинает строиться ответ n*factorial(n-1). Сохраненные локальные характеристики выбираются из стека в оборотной последовательности, а получаемые промежные результаты: 1*1, 2*1, 3*2*1, 4*3*2*1, 5*4*3*2*1 – передаются вызывающим функциям.

Рекурсивная функция, вычисляющая n-й член ряда Фибоначчи, может иметь вид:

Int fibo(int n)

if ((n == 1)

Примеры

1. Составить функцию Fseek(указатель на файл, позиция, параметр), рекурсивно определяющую значение биномиального коэффициента при 0 по формулам:

= = 1, = +

Int binom(int m, int n)

(m == n))

return 1; // выход из рекурсии

else return binom(m, n-1) + binom(m-1, n-1);

2. Составить функцию, рекурсивно определяющую наибольший элемент в данной части целочисленного массива vectorn , начиная с k-го и до n-го элемента:

int max_element(int k Fseek(указатель на файл, позиция, параметр), int n, int vector[])

{

int temp;

if (k == n-1)

return a[n-1]

Else

{

temp = max_element(k+1, n, vector[]);

if (a[k] > temp)

return a[k];

else return temp;

}

}

3. Составить функцию, реализующую рекурсивный метод К. Хоара резвой сортировки массива vectorn. Сравниваются элементы vectori и vectorj , при этом i = 1, j = n-1. Если vectori< vectorj, то эти элементы Fseek(указатель на файл, позиция, параметр) уже отсортированы по возрастанию, потому значение правого индекса миниатюризируется на единицу, и метод повторяется. Если vectori> vectorj, то они изменяются местами, останавливается правый индекс и начинает возрастать левый. Обмен значениями с конфигурацией направления движения после каждого обмена длится до того времени, пока левый и правый индексы не повстречаются вместе: i = j. В данном случае элемент vectori будет стоять Fseek(указатель на файл, позиция, параметр) на собственном месте в массиве: слева от него стоят элементы меньше его, а справа – больше. После чего метод рекурсивно повторяется для левой и правой частей массива:

void quick_sort(int left, int right, int vector[])

{

int i, last;

if (left >= right) // в векторе меньше 2-ух частей

return Fseek(указатель на файл, позиция, параметр);

swap(left, (left + right)/2, vector);

last= left;

for (i=left+1; i<=right; i++)

if (vector[i]

swap(++last, i, vector);

swap(left, last, vector);

quick_sort(left, last-1, vector);

quick_sort(last+1, right, vector);

}

Операцию перестановки i-го и j-го частей массива можно оформить функцией

void swap(int i, int Fseek(указатель на файл, позиция, параметр) j, int vector[])

{

int temp;

temp=vector[i];

vector[i]=vector[j];

vector[j]=temp;

}

Особенности рекурсии:

· внедрение рекурсивной формы организации метода смотрится изящнее итерационной и дает более малогабаритный текст программки,

· недочеты рекурсии состоят в последующем:

1) если глубина рекурсии велика, то программка будет добиваться во время выполнения много памяти, что может привести Fseek(указатель на файл, позиция, параметр) к переполнению стека,

2) рекурсивные методы, обычно, производятся более медлительно,

3) при рекурсивном программировании велика возможность ошибок, вынуждающих программера к перезагрузке компьютера.

Таким макаром, если у программера есть возможность выбора меж итерацией и рекурсией, то желаемым выбором является итерация.

АДРЕСА И УКАЗАТЕЛИ

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

Для этой цели в Си употребляются указатели и динамические структуры.

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

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

Язык Си отличается от других языков программирования сначала широким внедрением указателей. Конкретно наличие в нем указателей сделало его очень комфортным для системного программирования.

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

Оперативка компьютера – это последовательность байтов, любой из которых имеет номер (адресок). Адреса байтов памяти идут по возрастанию: если к – это номер текущего б, то к - 1 – номер предшествующего, а к + 1 – следующего байтов. Указатель как раз Fseek(указатель на файл, позиция, параметр) и содержит адресок некого б памяти. Меняя значение указателя, можно передвигаться по памяти, адресуясь к разным данным, записанным в просматриваемых ячейках.

Таким макаром, в Си под указателем понимается переменная, содержащая адресок хоть какого объекта программки. Означает, указатель гласит о том, где в памяти расположен тот либо другой Fseek(указатель на файл, позиция, параметр) программный объект (переменная, массив, структура, функция), но ничего не гласит об имени и значении этого объекта. По аналогии – можно знать почтовый адресок человека, но этот адресок не дает нам информацию о количестве комнат в его квартире и ее обстановке.

Применение указателей полезно:

- при работе с массивами – обеспечивается внедрение сходу Fseek(указатель на файл, позиция, параметр) всех частей массива,

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

- при работе с файлами – обеспечивается резвый доступ к компонентам файла,

- при разработке новых переменных в процессе выполнения программки – можно динамически выделять память для их.

Для работы с указателями в Си употребляются две операции:

* – доступ по Fseek(указатель на файл, позиция, параметр) адресу (воззвание по адресу),

& – получение адреса.

Символ * , стоящий перед именованием переменной-указателя, значит «взять (записать) значение по данному адресу»: *ptr – записать значение по адресу ptr.

Символ & , стоящий перед именованием обыкновенной переменной, значит «получить адресок переменной»: &x – получить адресок переменной x.

Перед внедрением в программке указатели, как и любые другие переменные, должны быть описаны – задан тип объекта, адресок которого будет Fseek(указатель на файл, позиция, параметр) хранить указатель, поставлена звездочка * и задано имя указателя:

int i, j, *ptr;

float x, y, *ukaz;

char c, d, *adr;

Описаны указатели:

рtr – на хоть какой объект (переменную, массив, функцию) целого типа,

ukaz – на хоть какой объект вещественного типа,

adr – на хоть какой объект символьного типа.

После описания указателей им Fseek(указатель на файл, позиция, параметр) можно присвоить значения адресов переменных этого же типа, используя операцию получения адреса &:

ptr = &i;

ukaz = &x;

adr = &c;

На данный момент указатели ptr, ukaz, adr будут хранить адреса (номера) первых (младших) байтов памяти, отведенной для переменных i, x, c (адресок б памяти – это шестнадцатеричное число).

Присвоим этим переменным некие значения:

i = 5;

x = 3.1416;

c Fseek(указатель на файл, позиция, параметр) = ‘@’;

Обратимся к ним по адресу:

j = *ptr;

y = *ukaz;

d = *adr;

Содержимое ячейки памяти с адресом ptr (а там записано число 5 – ведь это адресок переменной i) будет присвоено переменной j, содержимое ячейки памяти с адресом ukaz – переменной y, содержимое ячейки памяти с адресом adr – переменной d.

Таким макаром, два оператора присваивания:

ptr = &i Fseek(указатель на файл, позиция, параметр);

j = *ptr;

делают то же самое, что и один оператор:

j = i;

Означает, можно организовать не только лишь прямую передачу данных от одной переменной к другой (j = i), да и косвенную – через адреса переменных, даже не упоминая их имен. Указатели позволяют обращаться к определенным ячейкам памяти и изменять их содержимое, не интересуясь тем Fseek(указатель на файл, позиция, параметр), значения каких конкретно переменных хранятся в этих ячейках:

*adr = ‘+’;

переменной по адресу adr присвоено значение знака ‘+’,

(*ptr)++;

значение переменной по адресу ptr возрастает на единицу,

(*ptr) += 3;

значение переменной по адресу ptr возрастает на 3,

j = (*ptr)++;

значение переменной по адресу ptr присваивается переменной j и после чего возрастает на единицу.

Если это выражение записать Fseek(указатель на файл, позиция, параметр) без скобок:

j = *ptr++;

то поначалу значение адреса ptr возрастает на единицу (получаем адресок последующей ячейки памяти), а потом содержимое новейшей ячейки памяти присваивается переменной j : операции доступа по адресу * и инкремента ++ имеют однообразный ценность, но производятся справа влево.


fseekukazatel-na-fajl-poziciya-parametr.html
fskn-i-minzdrav-kivayut-drug-na-druga-bolnoj-desyatiletiyami-terpit-arhiv-andreya-tarkovskogo-priobretennij-rossijskimi.html
fss-nazval-devyat-priznakov-poddelnogo-bolnichnogo-117246-g-moskva-nauchnij-proezd-13-k-310-tel-7495690-71-08.html