Использование динамических массивов

Конечно, строки — это те же символьные массивы, и тот факт, что new и delete также могут использовать­ся для создания и освобождения динамических массивов любого типа, не будет для вас сюрпризом. Листинг 1.12 демонстрирует это.

Листинг 1.12. NEWARRAY.CPP (объявление массивов с помощью new) 1:

1: #include <iostream.h>

2:

3: #define COUNT 100 // Количество целых значений

4:

5: main()

6: {

7: int *array; // Массив целых значений

8: int i; // Индекс массива

9:

10: array = new int[COUNT];

11:

12: // Заполнение массива

13: for (i = 0; i < COUNT; i++)

14: array[i] = i;

15:

16: // Вывод содержимого массива

17: for (i = 0; i < COUNT; i++) {

18: cout.width(8);

19: cout << array[i];

20: }

21: delete[ ] аггау;

22: return 0;

23: }

 

В этом примере в строке 7 объявляется указатель на массив целых значений. В строке 10 используется new для выделения места для 100 целых значений. Затем массив заполняется значениями от 0 до 99 и выводится в 8-символьных столбцах с помощью цикла for в строках 17-20. Строка 21 удаляет массив, используя пустые скобки в выражении delete[ ] для того, чтобы, как и в предыдущем листинге, указать компилятору, что удаля­ется массив, а не одно целое значение.

Многомерные динамические массивы

Для объявления указателя на двух- или трехмерный массив (или большей размерности) надо указать количест­во элементов во второй и последующей позициях. Например, для массива 10x20 вещественных значений двойной точности:

int (*matrix)[20];

Оно определяет matrix, как указатель на массив из 20 целых. Вы должны заключить в круглые скобки (*matrix), поскольку квадратные скобки массива имеют больший приоритет, чем символ указателя *. Целых значений еще даже не существует; все что вы сделали — только дали указание компилятору, что matrix — указатель на массив определенного размера.

Чтобы выделить память для матрицы размером 10x20 и присво­ить ее адрес переменной matrix,надо:

matrix = new int[10][20];

Оператор new выделяет память для массива. Адрес, получившийся в результате, присваивается matrix. Для создания куба 8x8x8 следует написать следующее:

int (*matrix)[8][8];

matrix = new int[8][8][8];

Такое объявление matrix определяет вторую и третью размерность массива, указывая компилятору, что matrix адресует массив целых значений размерностью 8x8. Выражение new определяет все три измерения, вы­деляя пространство для указанного числа массивов 8x8, другими словами — трехмерного куба.

При вьщелении пространства для многомерного массива первый индекс может быть переменной, а второй и последующие должны быть константами. Например, если целая переменная v равна 40, то следующие строки

int (*matrix)[20];

matrix = new int[v][20];

выделяют пространство для двухмерного массива размерностью 40x20 элементов целых значений, адресуемого matrix.

Удаление многомерных массивов любой размерности происходит так, как будто они имеют лишь одно измерение:

delete[] matrix;

Перегрузка функций

Пример: программа, которая должна рисовать не­сколько различных фигур. Каждая функция прорисовки имеет свое собственное имя, что делает код "усыпан­ным" функциями типа DrawEllipse, DrawCircle, DrawSquare, DrawLine и т.д мы получим программу, словно написанную заикой:

DrawEllipse(ellipse); DrawCircle(circle); DrawSquare(square); DrawLine(line);

Не будет ли лучше, если вы используете одно и то же имя функции (назовем ее Draw) для вывода всех фигур?

Draw(ellipse); Draw(circle); Draw(square); Draw(line);

В С++ многочисленные функции могут иметь одинаковое имя до тех пор, пока они отличаются хотя бы одним параметром. Функции "перегружены", поскольку их имена одинаковы, а выполняемая ими работа — различна.

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

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

Листинг 1.13. OVERLOAD.CPP (перегрузка функций)

1:#include <iostream.h>

2:

3:int square(int а);

4:double square(double а);

5:long double square(long double a);

6:

Main()

8:{

9: int x = 10;

10 double у = 20.5;

11 long double z = 30.75;

12:

13: cout << square(x) << '\n';

14: cout << square(y) << '\n';

15: cout << square(z) << '\n';

16: return 0;

17: }
18:

19:int square(int а)

20:{

21: return а * а;

22: }
23:

24:double square(double а)

25:{

26: return а * а;

27: }
28:

29:long double square(long double a)

30:{

31: return а * а;

32: }

Прототипы трех перегруженных функции square() определены в строках 3-5. Все функции имеют одина­ковое имя, но, тем не менее, они различны, поскольку каждая из них отличается хотя бы одним параметром от другой. Сами функции реализованы в строках 19-32 как раздельные, т.е. имеющие различные имена.

В строках 13-15 показано, как перегруженные функции могут прояснять суть программы. Несмотря на различия в типах данных, очевидно, что каждый оператор выводит квадрат аргумента. Это куда более прият­но, чем различать функции по именам типа squareInt(), squareDouble() и squareLongDouble(). Конечно, ре­шать, стоит ли перегружать функции, которые выполняют более или менее схожую работу, придется вам. Ес­ли вы назовете все функции в вашей программе одним и тем же именем (с учетом того, что они должны от­личаться хотя бы одним своим аргументом), то ваш код может стать совершенно непостижимым, как новелла, представляющая собой многократное повторение одного и того же слова.