Void main ()

{int d;

d=getchar();

putchar(d);

putchar(‘\n’);}

Кроме того, в заголовочном файле conio.h описаны функции getch() – ввод символа без эха, getchе() – ввод символа с эхом. Эти функции позволяют вводить символы без нажатия клавиши Enter. Функция позволяет putch() осуществляет вывод символа на экран монитора. Например:

#include <conio.h>

Void main ()

{int cd;

cd=getch();

putch(cd);

cd=getche();

putch(cd);}

Ввод строковых констант выполняется с помощью функции gets(аргумент). Аргументом этой функции адрес переменной, которая должна быть объявлена в виде массива или указателя. Вывод строковых переменных и констант выполняется с помощью функции puts(аргумент). Здесь аргумент – переменная, объявленная в виде массива или указателя, или строковая константа, заключенная в двойные кавычки. Например:

#include <stdio.h>

Void main ()

{char s[10];

puts(“Введите строку не больше 10 символов”);

gets(s);

puts(“Введенная строка”);

puts(s); }

В языке С++ имеются свои операции включения данных в поток и извлечения данных из потока. Определение стандартных потоков ввода-вывода содержится в заголовочном файле iostream.h. Буферизованный выходной поток связывается с программой записью cout<<, а входной поток – cin>>.

int a=5;

cout<<a; // вывод на экран цифры 5

cin>>а; // ввод с клавиатуры значения переменной а

Эти операции реализованы так, что они автоматически распознают тип переменной или константы, расположенной справа. Например:

float pi=3.14;

int c=30;

cout<<pi; // вывод на экран числа 3.14

cout<<с; // вывод на экран числа 30

3 С++. Одновимірні масиви даних: визначення, ініціалізація, доступ до елементів масиву. Організація введення-виведення елементів масивів даних.

Массив – совокупность переменных одного типа. В массиве хранятся элементы , которые имеют одно имя и отличаются индексом.

Одномерные массивы:

тип имя_массива [ размер]

где тип- задает тип элементов объявляемого массива. Элементами массива не могут быть функции и элементы типа void.

имя массива - – это идентификатор массива

размер – целочисленное константное выражение в квадратных скобках, задает количество элементов массива.

Массив может определяться следующими способами:

1) числовой константой int a1[10];

2) с помощью const const int M=4;

float b1[M];

float b2[M+2];

3) с помощью директивы define #define N 20:

char c1[N];

Инициализация массива – присвоение начальных значений элементов при определении массива. Элементы массива инициализируются:

1)неявно(поумолчанию). Внутри статические массивы заполняются нулями, а внешние произвольными значениями.

2)явно. Явно массив может инициализироваться двумя способами: полная и неполная инциализация.

Полная инициализация – после определения массива ставится знак «=» и через «,» присваиваются значения элементам массива. int a1[5]={1,2,3,4,5} При полной явной инициализации размер массива можно не указывать. int a2[]={1,2,3,4,5}

Неполная инициализация int a1[]={1,2,3} – остальным элементам присваиваются значение нуля или мусор.

Доступ к элементам массива осуществляется через индексы элементов. При чем перечисление элементов начинается с нуля.

Ввод массивов может осуществляться несколькими способами:

-передача данных в виде параметров командной строки при запуске программы;

-в цикле запрос-ответ, когда программа сама запрашивает значения элементов массивов, а пользователь вводит их с клавиатуры;

-чтение данных массивов из текстовых или бинарных файлов.

Вывод массивов может осуществляться как на экран дисплея, так и в текстовые или бинарные файлы.

4 С++. Багатовимірні масиви даних: визначення, розташування в пам'яті, ініціалізація, доступ до елементів массиву

Многомерный массив – массив массивов ( массив, элементы которого являются массивы)

Определение многомерного массива:

тип имя_массива [n1][n2]….[nk]

где тип- задает тип элементов объявляемого массива. Элементами массива не могут быть функции и элементы типа void.

имя массива - – это идентификатор массива

n1…n_k-1 размер – целочисленное константное выражение в квадратных скобках, задает количество в массиве массивов размерности (k-1).

Общее количество элементов: n1*n2*… n_k

Пример: int a[2][3]={1,2,3,4,5,6}

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

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

cout<<&a[i][j]<<” “<<a[i][j]<<”\n”

На экране: 0x8b10off4 1

0x8b10off4 1

0x8b10off6 2

0x8b10off8 3

0x8b10offA 4

0x8b10offC 5

0x8b10offE 6

Расположение массива в памяти:

Доступ к элементам многомерного массива осуществляется

1) через индексы.

int b[5][3][6]; // массив

b[5][3][6]=100; // последний элемент массива

2) с помощью указателей( разыменование массива)

*(a[1]+2) или *(*(a+1)+2)

Пример: cout<<”a=”<<a; // 0x8b10off4 (1)

cout<<”a[0]=”<<a[0]; // 0x8b10off4 (1)

cout<<”a[1]=”<<a[1]; // 0x8b10offA (4)

cout<<”a[1]=”<<*(а+1); // 0x8b10offA (4)

cout<<”a[1][1]=”<<*(*(a+1)+1); // 0x8b10offC (5)

cout<<”sizeof(a);// 12b

cout<<”sizeof(&a);// 12b

cout<<”sizeof(a[1]);// 6b

cout<<”sizeof(a[1][0]);// 2b

cout<<”sizeof(&a[][0]);// 4b

Инициализация многомерного массива:

1)неявно(поумолчанию). Внутри статические массивы заполняются нулями, а внешние произвольными значениями.

2)явно. Явно массив может инициализироваться двумя способами: полная и неполная инициализация. При явной инициализации допускается не указывать самую левую размерность массива.

Явная полная – int b[2][2]={1,2,3,4};

Int a[2][3]={{1,2,3},{9,10,11}};

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

Явная неполная- int a[5][4]={1,2,3};

int k[3][4]={{1,2},{1,2}};

5 С++. Покажчики. Визначення, ініціалізація і операції над покажчиками. Зв'язок масивів та покажчиків.

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

тип *имя_указателя;

где тип указателя – это тип переменной, адрес которой содержит указатель.

int *ptri; // указатель на переменную типа int.

float *ptrf; // указатель на переменную типа float.

Каждое из этих определений выделяет в памяти ячейки для переменной типа указатель. Размер памяти, занимаемый указателем, можно определить: sizeof(имя_указателя). Например, int sz1=sizeof(ptri); int sz2=sizeof(ptrf);

В общем случае под указатель выделяется 4 байта для модели памяти large (2 байта – сегмент и 2 байта – смещение). Но сам указатель ни на что не указывает. Чтобы далее использовать эти указатели в программе, необходимо присвоить им конкретные значения с помощью операции присвоения, либо путем инициализации.

Указатель можно присваивать следующие значения:

• адрес переменной, который можно получить с помощью операции &;

• указатель, уже имеющий значение;

• явно заданный адрес памяти.

Указатели можно инициализировать:

тип *имя_указателя=инициализирующее выражение;

Фрагмент программы с примерами инициализации:

Пример.

int a=11;int *ptra, *ptrb;

ptra =&a;// указателю присвоили адрес переменной a

ptrb=ptra; //указателю присвоили содержимое указателя ptra

printf("%d %p %p %p %p %p\n",a,&a,ptra,&ptra,ptrb,&ptrb);

char*vb=(char*)0xB8000000;//начальный адрес видеопамяти

printf("vb=%p &vb=%p",vb,&vb); // vb=B800:0000 &vb=8ABF:0FF6

В результате работы этого фрагмента получим:

11  8ADA:0FFE  8ADA:0FFE  8ADA:0FFA  8ADA:0FFE  8ADA:0FF6

vb=B800:0000 &vb=8ABF:0FF6

Указатель очень часто используются для обращения (доступа) к объекту, на который указывает указатель. Этот процесс называют разыменованием и выполняется он с помощью операции разыменования (разадресации) "*". Рассмотрим пример с операцией разыменования:

Пример .

float f=1.3, *pf=&f;

cout<<"pf="<<pf; // pf=0xF9B00FFC

cout<<" *pf="<<*pf; // *pf=1.3

*fp=2.7;

cout<<" f="<<f; // f=2.7

Операция разыменования дает содержимое области памяти, на которую указывает указатель, которое может быть любого типа. Для того, чтобы операции с содержимым были возможны, компилятору необходимо знать его тип. Указатель сдвигается вперед (при прибавлении целого числа N) или назад (при вычитании целого числа N) на соответствующее количество переменных того типа, на который указывает указатель. Значение указателя всегда изменяется на число байтов, равное N*sizeof(*имя_указателя) или N*sizeof(тип_указателя).

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

Складывать два указателя в языке С(С)++ запрещено.

Над указателями можно выполнять следующие операции:

• взятие адреса & &ptra;

• разыменование * *ptra;

• определение размера указателя sizeof(ptra);

• преобразование типов (char*)ptra;

• присваивание ptra=&a;

• сложение и вычитание целых чисел ptra+=3; ptra–=2;

• инкремент, декремент ptra++; ptra–-;

• вычитание указателей int n=ptra-ptrb;

• операции отношения == != > >= < <=  ptra>ptrb;.

Рассмотрим некоторые операции над указателями.

Пример .

int a=1,b=7,c;

int *pa=&a, *pb=&b, *pc=&c;

printf("pa=%p pb=%p pc=%p \n",pa,pb,pc);

printf("pa-pb=%d pa-pc=%d ",pa-pb, pa-pc);

Результат:

pa=8B04:0FFE pb=8B04:0FFC bc=8B04:0FFA

pa-pb=1 pa-pc=2

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

Связь указателей с массивами

Существует связь между массивами и указателями. При определении массива ему выделяется память для всех элементов массива. Но имя массива воспринимается как константный указатель того типа, к которому отнесены элементы массива. Имя массива – это указатель-константа, значением которого служит адрес нулевого элемента массива.

Пример.

int m[]={1,2,3,4};

printf("*m=%d *(m+1)=%d\n",*m,*(m+1));// 1 2

for(int i=8;i<11;i++)

printf("%c",*(str+i));// C++

Если применить операцию sizeof(имя_массива), то результатом будет объем памяти в байтах, выделенный под весь массив. Если применить операцию взять адрес (&имя_массива), то получим адрес начального элемента массива. То есть имя массива ‑ это весь массив, а также адрес нулевого элемента.

Доступ к элементам массива осуществляется с использованием индекса, который является смещением от начала массива, arr[0], arr[1], arr[2]…, а также путем разыменования указателя *arr,*(arr+1),*(arr+2).

При обработке массива для компилятора без разницы, как записано обращение к элементам массива. Например:

int mas[4]={9,8,7,6};

int *pmas=mas;

Так к последнему элементу массива mas можно обратиться следующими способами: mas[3],*(mas+3),*(3+mas), 3[mas]. Эти записи эквивалентны. Можно также использовать указатель pmas: pmas[3],*(pmas+3),*(3+pmas), 3[pmas]. Все эти записи позволяют обратиться к элементу массива: 2[mas].

6 С++. Одновимірні масиви зміного розміру. Функції та оператори запитання (звільнення) пам'яті для одновимірного масиву даних.

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

Куча – это свободная память, место расположения которой зависит от операционной системы, модели памяти, для которой создана программа, и компилятора. Например, для Borland C++3.1 в случае использования при компиляции модели памяти small куча выделяется между концом сегмента данных программы и ее стеком. При использовании модели памяти large для кучи отводится вся память от сегмента стека до конца доступной для пользователя памяти. Отметим, что память в куче можно использовать не только для массивов, но я для любых других данных базового или производного типов.

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

В языке Си в заголовочных файлах <stdlib.h> и <alloc.h> описаны функции malloc(), calloc(), realloc(), free(), которые предназначены для выделения, изменения и высвобождения участков динамической памяти. Они сообщают (возвращают) в программу адрес начала свободного участка памяти (при его наличии) достаточного размера, т.е. они возвращают указатель. Этот указатель обычно (в зависимости от компилятора) имеет тип void*, который нужно преобразовать к типу данных создаваемого массива. После использования память освобождается. Наиболее часто применяют функции malloc() и free(). Синтаксис следующий: