Int test; // объявили целочисленную переменную

int & s_test; // ошибка! ссылка не связана с переменной

double & d_test=test; // ошибка! тип ссылки не совпадает с типом

// переменной, на которую ссылается

int & t_test=test; // теперь верно!

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

Адрес переменной нельзя изменить, это константа, однако в С++ определен специальный тип переменных – указатель, который хранит адрес или местоположение переменной в оперативной памяти.

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

þ Не удивляйтесь, что один и тот же символ используется для операции умножения и разыменования. Смысл символа понятен из контекста, в котором он применяется.

Следующий листинг поясняет использование указателей.

int *p1; // объявлен указатель на целое с именем p1

double *p_up; // объявлен указатель на вещественное число

int i =12;

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

// выводим значения i двумя путями:

cout<<*p1<<endl;

cout <<i;

// изменяем значение переменной i с помощью указателя

*p1 = 23;

cout << i;

þ Обратите внимание, что компилятору следует знать, на какой тип переменной ссылается указатель, так как количество байт, отводимое под различные типы переменных, различно.

Работу с переменной, адресом переменной и указателем на переменную можно проиллюстрировать схемой:

При объявлении указателя возможны различные способы расположения знака * и пробела:

char *str;

float* param;

long * ini;

Выберите любой вариант по своему вкусу. Например, комбинация char *str; подчеркивает, что*str является переменной типа char. Важно только помнить, что объявление вида

int* pi, ni;

создает указатель pi и обычную переменную ni типа int. То есть необходимо использовать * для каждого объявления указателя!

Массивы и строки.

v Массив ‑ это совокупность однотипных элементов (int ,double,char и т.д.).

Для определения целочисленного массива в C/C++ надо написать:

int z[10]; //массив из 10 целых чисел

Общее форма для объявления массива:

typename arrayName[arraysize];

Здесь typename - тип элементов массива (double, float и т.д.), arrayName‑ имя массива, arraysize ‑задает число элементов массива и должно быть типа const, либо постоянным выражением, для которого все значения должны быть известны уже во время трансляции[4].

Ниже приведенный листинг показывает примеры верного и неверного объявления массивов.

int ar[3]; // объявлен целочисленный массив из 3 элементов

const int k=11; // объявлена целочисленная константа к

int n, m=4; // объявлены переменные типа целое

n=12;

double z[k],y[3*k]; // верное объявление массивов

double nz[n], ny[m]; // неверное объявление массивов

Элементы массивов в C/C++ всегда нумеруются с нуля. Таким образом, в приведенном в начале параграфа примере массив будет состоять из целочисленных элементов z[0], z[1], z[2], ...z[9]. Индекс внутри квадратных скобок позволяет обратиться к любому элементу массива. При объявлении массива можно сразу инициализировать его элементы:

double mass[3]={1.1, 11.24, 0.45};

Не будет ошибкой и такой вариант инициализации:

int arr[]={14, 0, 6, 12};

В этом случае компилятор самостоятельно подсчитает количество элементов объявленного массива.

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

int arr[]={14, 0, 6, 12}; // объявление и инициализация массива

int varr[4]; // объявление массива

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

{

varr[i] = 3*arr[i]; // в цикле происходит поэлементное

// присваивание массива varr

cout<<varr[i]<<’\t’; // возможен только поэлементный вывод

// значений массива

}

þ При обращении к элементам массива автоматического контроля границ массива не производится! Программа не запретит вам обратиться к элементу varr[-1] или varr[5]. Естественно, это приведет к ошибкам, часто с непредсказуемым результатом.

Многомерные массивы.

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

int z[3][4]; //массив из 12 целых чисел

Двумерный массив в С/С++‑ это массив массивов, т.е. каждый элемент массива z[0], z[1] и т.д. является указателем на одномерный массив. Двумерный массив располагается в памяти по строкам:

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

int a[3][3]={{11,12,13},{21,22,23},{31,32,33}};

Первый индекс нумерует строки, а второй – столбцы. Таким образом, a[0][1]=12, a[2][0]=31.

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

þ Заметим, что понятие массивов в С/С++ тесно связано с указателями. Имя массива – это указатель на нулевой элемент массива. Таким образом, выражения arrи&arr[0] ‑ эквивалентны. Более подробно об этом будет сказано в разделе Динамическое определение массивов.

Двумерный массив хорошо моделирует математический объект – матрицу, поэтому используется дольно часто.

Строки

В языке С изначально не определен строковый тип данных. Вместо этого можно использовать так называемую С-строку – специально организованный массив символов.

þ Альтернативный способ описания строк в С++ появился вместе с классом string,нами он не рассматривается.

Инициализация строки может происходить так:

char s[100] = "пример строки";

или так:

char str[] = "объявление строки";

Неиспользуемым элементам массива s присваиваются специальные “нулевые” символы - \0. Так что в отличие от обычных массивов, конец строки можно найти по нулевому элементу. Так, последний символ строки s из предыдущего примера не ‘и’, а именно «нулевой символ» (не ноль, не пробел!)

Следующий листинг определяет длину строки по положению «нулевого» символа:

#include <iostream.h>

void main()

{

char st[]="0123456789";

cout<<st<<endl;//строку можно выводить целиком

int i=0;

while(st[i]!='\0')

i++;

cout<<i<<'\t'<<st[i];

}

На экран будет выведена строка 0123456789, затем число 10 (т.о. число элементов в символьном массиве 11), а последний, одиннадцатый символ на экране не отобразиться. Еще раз: строки всегда включают конечный нулевой символ, так что писать его при присвоении строки не требуется!

Для ввода-вывода строки используются потоковые объекты cin и cout, при этом посимвольный ввод-вывод, как для «обычных» массивов необязателен:

#include <iostream.h>

Void main()

{

const int len=80;

char st[len];

cin<<st; // строку можно вводить и

cout<<st<<endl;// выводить “целиком”

}

Проблема при вводе строк возникнет, если мы попытаемся ввести строку, состоящую из нескольких слов. Так как ввод выполняется до первого пробела, знака табуляции или символа конца строки ( \n ), то вместо двух (нескольких слов) будет введено только первое слово. Решение проблемы – воспользоваться методом getline:

#include <iostream.h>

Void main()

{ const int len=80;

char st[len];