Здесь располагается содержимое class "clearfloat" id "рамка"

Курс кружка "Программист"

У р о к и
  1. Этапы решения задач на компьютере. Разработка программы.
  2. *КОНТРОЛЬ*
  3. Понятие алгоритма. Свойства алгоритма.
  4. *КОНТРОЛЬ*
  5. Формы представления алгоритмов. Графический способ записи алгоритмов. Школьный алгоритмический язык.
  6. *КОНТРОЛЬ*
  7. Базовые алгоритмические структуры: базовая структура следование.
  8. *КОНТРОЛЬ*
  9. Базовые алгоритмические структуры: базовая структура ветвление.
  10. *КОНТРОЛЬ*
  11. Базовые алгоритмические структуры: базовая структура ЦИКЛ.
  12. *КОНТРОЛЬ*
  13. Эволюция языков программирования. Классификация языков программирования.
  14. *КОНТРОЛЬ*
  15. Язык Си++. Эволюция языка и его преимущества.
  16. *КОНТРОЛЬ*
  17. Синтаксис языка Си++.
  18. *КОНТРОЛЬ*
  19. Константы и переменные в С++. Преобразование типов данных.
  20. *КОНТРОЛЬ*
  21. Операторы используемые в С++.
  22. *КОНТРОЛЬ*
  23. Некоторые визуальные компоненты С++Builder.
  24. *КОНТРОЛЬ*
    ***Лабораторная работа № 1***
    Создание простого приложения в С++Builder.
  25. Основные константы и математические функции. Команда форматированного вывода строки.
  26. *КОНТРОЛЬ*
    ***Лабораторная работа № 2***
    Создание программы вычисления значения функции.
  27. Условные операторы выбора if.
  28. *КОНТРОЛЬ*
    ***Лабораторная работа № 3***
    Создание программы с разветвленной структурой.
  29. Условный оператор множественного выбора switch. Безусловный переход.
  30. *КОНТРОЛЬ*
    ***Лабораторная работа № 4***
    Создание программы со структурой ВЫБОР.
  31. Оператор цикла for (цикл со счетчиком).
  32. *КОНТРОЛЬ*
    ***Лабораторная работа № 5***
    Создание программы c циклом ДЛЯ.
  33. Операторы цикла с условием. Прерывание цикла.
  34. *КОНТРОЛЬ*
    ***Лабораторная работа № 6***
    Создание программы c циклом ПОКА.
  35. Одномерные массивы. Обработка строк.
  36. *КОНТРОЛЬ*
    ***Лабораторная работа № 7***
    Создание программы обработки строк.
  37. Многомерные массивы.
  38. *КОНТРОЛЬ*
    ***Лабораторная работа № 8***
    Создание программы обработки двумерного массива.
  39. Указатели и ссылки.
  40. *КОНТРОЛЬ*
  41. Функции: объявление, описание и использование.
  42. *КОНТРОЛЬ*
    ***Лабораторная работа № 9***
    Создание и использование функций в C++.
  43. Файлы и потоки. Файловый ввод/вывод с помощью компонентов.
  44. *КОНТРОЛЬ*
    ***Лабораторная работа № 10***
    Работа с файлами с помощью компонентов С++Builder.
  45. Файловый вывод/вывод в двоичном режиме.
  46. *КОНТРОЛЬ*
    ***Лабораторная работа № 11***
    Запись и чтение блоков из двоичного файла (произвольный доступ).

    ***Лабораторная работа № 12***
    Запись, дописывание и чтение потоков из файла.
Дополнения

20. Указатели и ссылки.

Указатель — это переменная, указывающая на адрес в памяти, где хранятся какие-то данные, например, значение некоторой другой переменной. В этом смысле имя этой другой переменной отсылает к ее значению прямо, а указатель — косвенно. Ссылка на значение посредством указателя называется косвенной адресацией.
Указатели, подобно любым другим переменным, перед своим использованием должны быть объявлены. Объявление указателя имеет вид:
type *ptr;
где type — один из предопределенных или определенных пользователем типов, а ptr — указатель. Читается это объявление так: "ptr является указателем на значение типа type". Например,
int *countPtr,   count;
объявляет переменную countPtr типа int * (т.е. указатель на целое число) и переменную count целого типа.

Может быть объявлен и указатель на void:
void *Pv;
Это универсальный указатель на любой тип данных. Но прежде, чем его использовать, ему надо в процессе работы присвоить значение указателя на какой-то конкретный тип данных. Например:
Pv = countPtr;
Указатели должны инициализироваться либо при своем объявлении, либо с помощью оператора присваивания. Указатель может получить в качестве начального значения 0, NULL или адрес. Указатель с начальным значением 0 или NULL ни на что не указывает. Для присваивания указателю адреса некоторой переменной используется операция адресации &, которая возвращает адрес своего операнда. Например, если имеются объявления
int y = 5;
int *yPtr, x;
то оператор
yPtr = &y;
присваивает адрес переменной y указателю yPtr.
Переменные- указатели должны всегда указывать на соответствующий тип данных. Например при объявлении указателя типа int компилятор, что все значения на которые ссылается этот указатель, имеют тип int.  Компилятор не позволит выполнить операцию присваивания указателей если их типы не одинаковы.
Например:
int *A;
double B;
A= &B ; //ошибка
Это ограничение можно обойти с помощью операции приведения типов, но с возможным риском искажения значения. Пример:
int *A;
double B;
A=(int *) &B; //ошибки не будет.
Для того чтобы получить значение, на которое указывает указатель, используется операция *, обычно называемая операцией косвенной адресации или операцией разыменования. Она возвращает значение объекта, на который указывает ее операнд (т.е. указатель). Например, если продолжить приведенный выше пример, то оператор
x = *yPtr
присвоит переменной x значение 5, т.е. значение переменной y, на которую указывает yPtr.
Массивы и указатели в Си++ тесно связаны и могут быть использованы почти эквивалентно. Имя массива можно понимать как константный указатель на первый элемент массива. Его отличие от обычного указателя только в том, что его нельзя модифицировать. Указатели можно использовать для выполнения любой операции, включая индексирование массива. Пусть вы сделали следующее объявление:
int b[5] = {1,2,3,4,5}, *Pt;
Тем самым вы объявили массив целых чисел b[5] и указатель на целое Pt. Поскольку имя массива является указателем на первый элемент массива, вы можете задать указателю Pt адрес первого элемента массива b с помощью оператора Pt = b;
Это эквивалентно присваиванию адреса первого элемента массива следующим образом
 Pt = &b[0];
Теперь можно сослаться на элемент массива b[3] с помощью выражения *(Pt + 3).
Указатели можно индексировать точно так же, как и массивы. Например, выражение Pt[3] ссылается на элемент массива b[3].
С указателями может выполняться ограниченное количество арифметических операций. Указатель можно увеличивать (++), уменьшать (--), складывать с указателем целые числа (+ или +=), вычитать из него целые числа (- или -=) или вычитать один указатель из другого.
Сложение указателей с целыми числами отличается от обычной арифметики. Прибавить к указателю 1 означает сдвинуть его на число байтов, содержащихся в переменной, на которую он указывал. Обычно подобные операции применяются к указателям на массивы. Если продолжить приведенный выше пример, в котором указателю Pt было присвоено значение b — указателя на первый элемент массива, то после выполнения оператора Pt += 2;
Pt будет указывать на третий элемент массива b. Истинное же значение указателя Pt изменится на число байтов, занимаемых одним элементом массива, умноженное на 2. Например, если каждый элемент массива b занимает 2 байта, то значение Pt (т.е. адрес в памяти, на который указывает Pt) увеличится на 4. Аналогичные правила действуют и при вычитании из указателя целого значения.
Переменные указатели можно вычитать один из другого. Например, если Pt указывает на первый элемент массива b, а указатель Pt1 — на третий, то результат выражения Pt1 — Pt будет равен 2 — разности индексов элементов, на которые указывают эти указатели. И так будет, несмотря на то, что адреса, содержащиеся в этих указателях, различаются на 4 (если элемент массива занимает 2 байта).
Арифметика указателей теряет всякий смысл, если она выполняется не над указателями на массив. Нельзя полагать, чтоб две переменные одинакового типа хранятся в памяти вплотную друг к другу, если только они не соседствуют в массиве. Сравнение указателей операциями >, <, >=, <= также имеют смысл только для указателей на один и тот же массив. Однако операции отношения == и != имеют смысл для любых указателей. При этом указатели равны, если они указывают на один и тот же адрес в памяти.
Указатель можно присваивать другому указателю, если оба указателя имеют одинаковый тип. В противном случае нужно использовать операцию приведения типа, чтобы преобразовать значение указателя в правой части присваивания к типу указателя в левой части присваивания. Исключением из этого правила является указатель на void (т.е. void*), который является общим указателем, способным представлять указатели любого типа. Указателю на void можно присваивать все типы указателей без приведения типа. Однако указатель на void не может быть присвоен непосредственно указателю другого типа — указатель на void сначала должен быть приведен к типу соответствующего указателя. Мы рассмотрели ранее указатели на массивы. Однако соотношение между массивами и указателями может быть и обратным — могут использоваться массивы указателей. Подобные структуры часто используются в массивах строк или в массивах указателей на различные объекты.
Например, вы можете сделать следующее объявление:
char *Sa[2]   =  {"Это первая строка",   "Вторая"};
Вы объявили массив размером 2 элементов типа (char *). Каждый элемент такого массива — строка. Но в C++ строка является, по существу, указателем на ее первый символ. Таким образом, каждый элемент в массиве строк в действительности является указателем на первый символ строки. Каждая строка хранится в памяти как строка, завершающаяся нулевым символом. Число символов в каждой из строк может быть различным. Таким образом, массив указателей на строки позволяет обеспечить доступ к строкам символов любой длины.
Указатели широко используются при передаче параметров в функции.
Ссылки — это специальный тип указателя, который позволяет работать с указателем как с объектом. Объявление ссылки делается с помощью операции ссылки, обозначаемой амперсандом  (&) — тем же символом, который используется для адресации.
Чаще всего ссылки используются при передаче в функции параметров по ссылке.