Объявление и инициализация массивов

⇐ ПредыдущаяСтр 2 из 4Следующая ⇒

При объявлении массива можно использовать инициализаторы. Список инициализирующих значений состоит из констант, разделенных запятыми. Весь список должен быть заключен в фигурные скобки. Количество значений в инициализаторе не должно быть больше размера массива. Если значений в инициализаторе меньше, остальным элементам массива присваивается 0. Каждая константа должна иметь тип, совместимый с типом массива.

Пример инициализации массива целых чисел

int a[5]={0, 1, 2, 3, 4};

Если при объявлении массива используется инициализатор, можно не указывать размер массива – подсчет будет произведен компилятором. Массивы, объявленные без указания границы изменения индекса, называют безразмерными.

Пример // безразмерные массивы

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

Массивы типа char можно инициализировать строковыми константами.

Пример. Инициализация массива типа char. Поскольку строки заканчиваются символом '\0', граница массива должна быть на единицу больше длины слова. Поэтому для хранения слова " february", состоящего из 8 символов, потребовался массив из 9 элементов.

// инициализация char

char login[8] = {'j', 'a', 'n', 'u', 'a', 'r', 'y', '\0'};

char password[9]=" february";

Пример. Объявление и инициализация строк, содержащих символы кириллицы – на каждый символ в строке нужно 2 байта.

char fio_r[7]=" ФИО";

char Fio_r[]={'Ф', 'И', 'О', '\0'};

Поскольку строка символов является массивом, нельзя присвоить одну строку другой – необходимо выполнить операцию присваивания для каждого элемента. Точно так же нельзя сравнивать строки. Для выполнения этих и других операций со строками можно использовать встроенные функции, объявленные в файле string.h. В частности, присваивание символьных массивов реализуется функцией strcpy(s1, s2), сравнение – функцией strcmp(s1, s2), важнейшая для строк операция склеивания (конкатенация) выполняется функцией strcat(s1, s2), для вычисления длины строки введена функция strlen(s). Поиск в содержимом строки можно выполнить с помощью функций strchr(s, ch) и strstr(s1, s2).

Указатели

Указатель – это переменная, содержащая адрес другой переменной. Применяя операцию * (операция разыменования ), получаем значение, записанное по данному адресу. С помощью операции &, примененной к переменной, можно узнать адрес, по которому эта переменная хранится в памяти.

При объявлении указателя также используется *, кроме того, указывается тип данных, на которые ссылается указатель.

Тип_данных *имя_указателя;

Пример. Объявление указателей и обращение к памяти. Значение переменной px – адрес памяти, а *px – данные, записанные по адресу px.

int x=100; // переменная

cout< < " \n x=" < < x;

int* px; // указатель на int

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

*px =200; /* Изменения значения, записанного по адресу px */

При создании указателя память выделяется только для хранения адреса. Для выделения памяти под данные используется оператор new. Выделение памяти оператором new:

указатель = new Тип

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

Для динамически размещаемого одномерного массива используется следующая форма оператора new:

p=new type [size]

Для удаления динамически размещаемого одномерного массива исполь-зуется оператор

delete [ ] p;

Пример

int *p;

int i;

p = new int [5]; // выделение памяти для 5 целых

Указатели и массивы

Имя массива является указателем и содержит адрес первого элемента массива. Если, например, w имя массива, то *w – значение первого элемента массива, а обращение w[i] к i-му элементу массива есть сокращенная форма операции с указателями *(w+i).

Пример.

const int N=10;

int w[N]= {0, 10, 20, 30, 40, 50, 60, 70, 80, 90}; // массив из 10 элементов

int *v; // указатель

v=w+5;

cout< < *v; // будет выведено значение 50

1. 2.1.7 Использование объектов класса string (строк)

Для того чтобы использовать объекты класса string, необходимо включить соответствующий заголовочный файл:

#include < string>

Пример строки, представленной объектом типа string и инициализированной строкой символов:

#include < string>

string st( " Строка-объект\n" );

Длину строки возвращает функция-член size() (длина не включает завершающий нулевой символ).

cout < < st.size() < < " символов\n";

Вторая форма определения строки задает пустую строку:

string st2; // пустая строка

Третья форма конструктора инициализирует объект типа string другим объектом того же типа - строка st3 инициализируется строкой st:

string st3( st );

Копирование строк выполняется с помощью обычной операции присваивания: st2 = st3; // копируем st3 в st2

Для конкатенации строк используется операция сложения (+) или операция сложения с присваиванием (+=). Пусть даны две строки:

string s1( " hello, " );

string s2( " world\n" );

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

string s3 = s1 + s2;

Чтобы добавить s2 в конец s1, следует написать:

s1 += s2;

Операция сложения может конкатенировать объекты класса string не только между собой, но и со строками встроенного типа. Можно переписать пример, приведенный выше, так, чтобы специальные символы и знаки препинания представлялись встроенным типом, а значимые слова – объектами класса string:

const char *pc = ", ";

string s1( " hello" );

string s2( " world" );

string s3 = s1 + pc + s2 + " \n";

Подобные выражения работают потому, что компилятор знает, как автоматически преобразовывать объекты встроенного типа в объекты класса string. Возможно и простое присваивание встроенной строки объекту string:

string s1;

const char *pc = " a character array";

s1 = pc; // правильно

Обратное преобразование, однако, не работает. Попытка выполнить следующую инициализацию строки встроенного типа вызовет ошибку компиляции:

char *str = s1; // ошибка компиляции

Чтобы осуществить такое преобразование, необходимо явно вызвать функцию-член с названием c_str():

char *str = s1.c_str(); // почти правильно

Функция c_str() возвращает указатель на символьный массив, содержащий строку объекта string в том виде, в каком она находилась бы во встроенном строковом типе. Приведенный выше пример инициализации указателя char *str все еще не совсем корректен. c_str() возвращает указатель на константный массив, чтобы предотвратить возможность непосредственной модификации содержимого объекта через этот указатель, имеющий тип

const char *

Правильный вариант инициализации массива символов:

const char *str = s1.c_str(); // правильно

Определение структур

Данные различных типов можно объединить под одним именем с помощью структур. Структуры – это составные типы данных, построенные с использованием других типов. Рассмотрим следующее определение структуры:

struct Person

{

char name[ 20 ];

char surname[ 20 ];

int age;

};

Ключевое слово struct начинает определение структуры. Идентификатор Person – это тег (имя) структуры. Тег структуры используется при объявлении переменных в качестве наименования типа. Имена, объявленные в фигурных скобках, – это элементы (или члены) структуры. Элементы одной и той же структуры должны иметь уникальные имена, но две разные структуры могут содержать элементы с одинаковыми именами. Элементы структуры могут быть любого типа. Каждое определение структуры должно заканчиваться точкой с запятой.

Переменные структуры объявляются так же, как и переменные других типов.

Person newPerson, personArray[ 10 ], *personPtr;

Для доступа к элементам структуры (или класса) используются операции доступа к элементам – операция точка (.) и операция стрелка (-> ). Операция точка обращается к элементу структуры (или класса) по имени переменной объекта. Например, чтобы напечатать значение элемента age структуры newPerson, используется оператор:

cout < < newPerson.age < < endl;

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

personPtr = new Person[50];

Присваивание элементу структуры age значения 18 personPtr -> age=18;

Функции

Для более эффективного управления кодом используется разделение программы на отдельные логические модули – функции. Модульное программирование предполагает:

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

– определение функции, включающее заголовок функции и последовательность операторов, реализующих функцию;

– вызов функции путем указания ее имени и замены формальных параметров значениями (фактическими параметрами).

Пример использования функции.

#include < iostream>

using namespace std;

int sum(int, int); /* Объявление функции sum - прототип */

int main()

{ int a, b, c;

cin > > a > > b;

c=sum(a, b); // Вызов функции

cout < < " \n sum = " < < c;

return 0;

}

int sum(int a, int b)

{ // Определение функции

return a+b;

}

Объявление функции

До обработки вызова функции компилятору должно быть известно её имя и типы параметров. Прототип функции является оператором и должен заканчиваться точкой с запятой. В прототипе функции можно не приводить имена параметров, – достаточно указать список типов параметров.

Возвращаемый_тип Имя_функции(список типов_параметров);

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

Пример. Блок определения функции предшествует её вызову, поэтому в программе нет объявления функции (прототипа).

#include < iostream> using namespace std;

int sum(int a, int b)

{ // Определение функции

return a+b;

}

int main()

{ int a, b, c;

cin > > a > > b;

c=sum(a, b); // Вызов функции

cout < < " \n c = " < < c;

return 0;

}

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

Часто прототипы функций помещают в отдельные файлы– заголовочные файлы (эти файлы имеют расширение.h).

Определение функции

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

Функция должна содержать хотя бы один оператор return – исключением являются функции, у которых тип возвращаемых значений void. Выполнение оператора return завершает работу функции и возвращает управление в вызывающую программу. Синтаксис оператора

return выражение;

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

⇐ Предыдущая 123 4 Следующая ⇒