Ошибка выражение должно быть допустимым для изменения левосторонним значением

• Подписаться на тему
• Сообщить другу
• Скачать/распечатать тему

• Предыдущая тема
• C/C++: Системное программирование и WinAPI
• Следующая тема

Глава 3. Указатели и ссылки

3.6.Константные указатели и ссылки

При инициализации указателя задействуются два объекта: сам указатель и тот объект, на который он указывает. Поэтому модификатор const может стоять в двух позициях:

const тип *имя – обозначая то, что константой является объект, лежащий по адресу, хранимому в указателе имя (при этом адрес можно изменить);

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

Листинг 48

Префиксное объявление модификатора const делает константным объект на который он указывает, а не сам указатель. На примере выше (Листинг 48) можно видеть этот вариант. Не вызывает ошибки у компилятора тот факт, что указатель на константу p проинициирован адресом переменной m (а не константы).

Описание переменной const int *p = &m можно интерпретировать так: «переменная p имеет тип const int* – она является указателем на константу» или так: «содержимое *p указателя p имеет тип const int – оно является константой».

Понимая обозначение таким образом, можно видеть, почему не вызовет ошибки присваивание указателю p другого адреса (сам указатель не является константой). Корректным будет также явное изменение переменной m через её имя, (ведь никаких ограничений на переменную m не наложено). Но попытка косвенного (через указатель) изменения данных, хранимых в ячейке, на которую указывает p, вызовет ошибку, так как это – указатель на константу. Константное выражение недопустимо для изменения левосторонним значением.

Следующий пример (Листинг 49) иллюстрирует использование константного указателя – константой является сам адрес, хранимый в переменной-указателе, а не содержимое, которое по этому адресу хранится – оно может быть изменено.

Листинг 49

int n, m = 10;

int const p = &m; // константный указатель

p = &n; // ошибка: попытка изменения указателя (константного адреса)

*p = 12; // допустимо изменение значения на которое указывает int*const

Приведенное здесь (Листинг 49) описание переменной int* const p = &m можно интерпретировать так: «переменная p имеет тип int* const – она является константным указателем» или так: «константа const p имеет тип int* – она является указателем».

Теперь понятно, что ошибкой будет присваивание указателю p другого адреса (поскольку сам указатель является константой). Константное выражение недопустимо для изменения левосторонним значением.

Корректным будет явное (по имени) или косвенное (через указатель) изменение переменной m или содержимого *p, лежащего по этому константному адресу p.

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

int m = 10;

const int const X = &m; // константный указатель на константу

Информационные технологии

Логично, что объект, являющийся константой при доступе через один указатель, может изменяться при доступе иным способом. Это свойство широко применяется при описании аргументов подпрограмм. Объявив параметр функции как указатель на константу, можно быть уверенным, что функция не изменят объект, на который указывает параметр. Данная тема будет детально разобрана в следующей главе.

Константные ссылки

Аналогично указателям, ссылочные переменные также могут ссылаться на константы, а могут быть константами сами, а ссылаться на изменяемые переменные:

const тип& имя – константой является объект на который делается ссылка; тип& const имя – константой является ссылка, сам объект при этом может

изменяться.

Листинг 50

double a = 12.12; const double& d1 = a; double& const d2 = a;

d1 = 13; // ошибка: значение по ссылке q — константа, оно не меняется d2 = 13; // ок: константная ссылка на изменяемую переменную

Во втором случае не понятно, в чем смысл создания именно константной ссылки, ведь ссылка (в отличие от указателя) и так не имеет смысла сама по себе, её саму (а не тот объект, на который она ссылается) и так не изменить. В случае описания переменной d2 модификатор const не несет никаких дополнительных ограничений и не накладывает никаких дополнительных проверок.

Листинг 51

double x;

const double& q = x; // ссылка на константу

double y = q + 5; // использование константы в правой части выражения x = 56; // double х — не константа

q = 12; // ошибка: значение по ссылке q — константа, оно не меняется

Рассмотрим нюансы (Листинг 51). Здесь создается ссылка на константу, её можно использовать в правой части выражения, но присвоить ей новое значение нельзя, ведь она ссылается на константу. Для присваивания выражение должно быть допустимым для изменения левосторонним значением, а это не так. При этом, сама переменная х может быть изменена.

Листинг 52

const double a = 5;

double& r = a; // ошибка: попытка сослаться на константу изменяемой ссылкой const double& r = a; // константная ссылка инициирована константой

double const& r = a; // константная ссылка инициирована константой r = 21; // ошибка: попытка изменить константу

Пример (Листинг 52) иллюстрирует тот факт, что изменить константу при помощи неконстантной ссылки на нее не удастся: попытка сослаться на константу изменяемой ссылкой будет остановлена компилятором. Константой можно инициировать только константную ссылку. Ну и, следовательно, изменить константную переменную, на которую ссылается константная ссылка невозможно по двум очевидным причинам. Назовите их.

Обычные ссылки в англоязычной литературе по программированию принято называть modifiable lvalues, а константные ссылки non-modifiable lvalues (изменяемые и неизменяемые левосторонние выражения).

Глава 3. Указатели и ссылки

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

Контрольные вопросы:

1.Что такое указатель и для чего он используется?

2.Как узнать значение переменной, если известен только ее адрес?

3.Какие действия выполняет оператор new?

4.Имеет ли статическая переменная адрес?

5.В чем разница между динамической переменной и указателем на нее?

6.Какое значение возвращают функции malloc и calloc при выделении памяти?

7.Как получить адрес переменной?

8.Какое имя можно задать динамической переменной?

9.Что такое адрес переменной?

10.Какие пять действий происходят при выделении памяти функциями malloc, calloc?

11.Какой размер занимает переменная-указатель?

12.Что такое динамическая переменная, чем она отличается от статической?

13.В каком случае нужно пользоваться оператором delete, а в каком – функцией free( ) для освобождения памяти?

Информационные технологии

4.Подпрограммы

Подпрограмма (процедура, функция) – это именованная часть (блок) программы, к которой можно обращаться из других частей программы столько раз, сколько потребуется. Для того чтобы вызывать (запускать) подпрограмму в разных частях головной программы ее необходимо описать и задать. [1 — 14]

Описать функцию (описать заголовок, прототип функции) – означает определить ее имя, тип_возвращаемого_значения и список_формальных_параметров, записываемых через запятую как на рисунке (Рис. 33).

Листинг 53

// прототип (описание) функции, её заголовок тип_возвращаемого_значения имя(список_формальных_параметров);

//——————————————————————————

// головная программа, вызывающая подпрограмму имя() int _tmain(int argc, char* argv[])

{

…

x = имя(список_фактических_параметров); // вызов функции

…

}

Задать подпрограмму – значит, помимо описания заголовка, задать (определить, прописать) и все её команды, составляющие тело подпрограммы (Рис. 33).

return z;

}

внутренняя (локальная) переменная команда выхода из подпрограммы, возвращающая результат

Рис. 33. Структура задания функции (подпрограммы) в языке С++

Если подпрограмма не должна возвращать никакого значения, то тип_возвращаемого_значения нужно задать как void, такая подпрограмма называется процедурой. Если подпрограмма возвращает какое-то значение, то в теле функции должен присутствовать оператор return, возвращающий значение соответствующего типа. Подпрограммы, возвращающие значение, называются функциями.

Листинг 54

//——————————————————————————

// задание (реализация) функции тип_возвращаемого_значения имя(список_формальных_параметров)

{

// тело функции

…

return возвращаемое_значение;

}

Глава 4. Подпрограммы

Тип_возвращаемого_значения определяет, какого типа должен быть результат вычислений, возвращаемый в программу, вызвавшую нашу функцию. Для возврата из функции используется оператор return и стоящее после него выражение (оно должно быть требуемого типа). Первый встретившийся в любом месте функции оператор return немедленно прекращает выполнение подпрограммы, возвращая в вышестоящую подпрограмму значение расположенного после него выражения (Рис. 34).

#include <iostream> using namespace std;

{

Рис. 34. Логика передачи управления в подпрограмму и возврата из неё.

После того, как функция описана и задана, она может быть вызвана (запущена) из тела главной функции main() или других функций программы. Вызывающая программа по отношению к вызываемой подпрограмме, называется головной. Та точка головной программы, в которой была вызвана функция, называется точка вызова (или точка возврата) – выполнение основной программы в этой точке приостанавливается (прерывается) и выполняется тело_функции, по завершению работы функции возвращаемое_значение передается в точку возврата, после чего выполнение основной программы будет продолжено. В нашем примере (Рис. 34) точка возврата находится в строке после строки символов cout <<.

}команда выхода из программы main(), возвращающая 0

Рис. 35. Структура вызова (использования) функции в главной программе

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

Рассмотрим пример (Листинг 55) в котором описывается, задается и вызывается подпрограмма int min(int, int) для вычисления минимума из двух чисел. Во второй

Информационные технологии

строке листинга описывается прототип (заголовок) функции. Реализация подпрограммы размещена в 18-23 строках, здесь задается тело функции. В теле программы main() эта функция трижды вызывается для различных фактических параметров: в строке 11 вызывается подпрограмма min() для сравнения чисел 12 и 54, в строке 12 она вызывается с параметрами 12 и 5, и в строке 13 функция min() в качестве фактических значений принимает значения 54 и -7.

Листинг 55

#include <iostream> //—————————————————————————

int min(int, int); // прототип подпрограммы

//—————————————————————————

void main()

{

system(«chcp 1251»); system(«cls»);

int X, Y; X = 12;

Y = 54;

std::cout << «X= » << X << » Y= » << Y << «n»; std::cout << «min(X,Y)= » << min(X, Y) << «n»; std::cout << «min(X,5)= » << min(X, 5) << «n»; int Z = min(Y, -7);

std::cout << «min(Y,-7)= » << Z << «n»; std::cout << «nn»;

system(«PAUSE»);

}

//—————————————————————————

int min(int A, int B) // реализация подпрограммы

{

if (A <= B) return A;

return B;

}

//—————————————————————————

Обратите внимание на то, в каком месте программы main() вызывается функция min(). В первых двух случаях возвращаемое подпрограммой значение передается оператору std::cout << в качестве аргумента, а в третьем варианте результат вычислений функции min() присваивается переменной Z. Разумеется, в этом случае тип переменной Z и тип возвращаемого функцией int min(int, int) значения должны совпадать.

Результат выполнения программы (Листинг 55) приведен ниже (Рис. 36).

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

Заголовочные файлы подключаемых библиотек – файлы с расширением *.h: «stdafx.h», <iostream.h>, <conio.h> и др. содержат прототипы используемых нами подпрограмм system(), std::cout <<, std::cin >>, srand(), time(), rand(), strcpy(), printf(), scanf(), calloc(), malloc() и др. Вызвать описание всех доступных подпрограмм можно по комбинации клавиш F12, <ALT>-<F12> и <CTRL>-<F12> или вызвав контекстную помощь. Реализация этих подпрограмм размещена в файлах *.lib или *.dll (библиотеках) в откомпилированном виде.

Глава 4. Подпрограммы

Рассмотрим программу, печатающую степени числа 2:

Листинг 56

float pow(float, int); // прототип функции, которая будет прописана ниже void _tmain(int argc, char* argv[]) // главная функция main()

{

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

cout << pow(2, i) << «n»; // вызов функции pow(float, int)

}

Первая строка листинга, прототип функции указывает на то, что float pow(float, int) – это функция, получающая параметры типа float и int и возвращающая float. Прототип функции используется для того, чтобы сделать определенными обращения к функции в других местах.

При вызове функции тип каждого параметра сопоставляется с ожидаемым типом. Это гарантирует надлежащую проверку и преобразование типов. Например, обращение pow(12.3,»abcd») вызовет недовольство компилятора, поскольку «abcd» является строкой, а не int. При вызове pow(2,i) компилятор производит неявное преобразование 2 к типу float, и запустит на выполнение функцию pow(2.0, i).

Функция pow() может быть определена рекурсивно:

Листинг 57

float pow(float x, int n) // задание функции pow()

{

if (n < 0) // если отрицательный показатель для pow() return 1/pow(x, —n);

switch (n)

{

case 0: return 1; // выход из рекурсии case 1: return x;

default: return x * pow(x, n — 1); // рекурсия

}

}

4.1.Передача параметров в тело функции

Вязыке С++ существует три способа передачи параметров в тело функции: «по значению», «по ссылке» и «по указателю».

void F1(int p, int q); // передача параметров по значению void F2(int& p, int& q) // передача параметров по ссылке void F3(int* p, int* q) // передача параметров по указателю

Передача параметров по значению

Для того чтобы понять их специфику, рассмотрим процесс передачи данных в функцию более подробно на следующем примере (Рис. 37). Вызывающая функция main() имеет 3 переменных целого типа: x, y и z. Под каждую из них выделено по одной ячейке памяти размером sizeof(int). В точке вызова функции F() приостанавливается выполнение функции main(), в памяти компьютера выделяется еще 3 ячейки под локальные (видимые и используемые только внутри подпрограммы) переменные p, q и r.

Область видимости этих переменных p, q и r (та зона программного кода, где они могут быть использованы) ограничена телом функции F(). Такие переменные называются локальными. В ячейки p и q копируются значения глобальных переменных x и y соответственно, после чего производится вычисление переменной r и оператор return возвращает значение r в точку вызова. После этого возобновляется выполнение функции main() – переменной z присваивается возвращаемое значение.

Рис. 37. Передача параметров по значению

В рассмотренном выше примере данные в подпрограмму F() передаются «по значению», это значит, что в программе F() создаются локальные переменные p и q и в них копируются значения фактических параметров – переменных x и y. Локальные переменные p и q в теле основной программы не видны, и не могут использоваться. И, естественно, если в теле функции F() переменные p и q меняют свои значения, это никак не скажется на переменных x и y – они не изменятся.

Рассмотрим пример, приведенный ниже (Листинг 58). В нем приводится подпрограмма int sum2ab(int a, int b), в которую передаются «по значению» два целых числа – a и b, в теле подпрограммы значения их удваиваются, затем производится вывод на экран значений этих переменных и их адресов. После чего они суммируются,

ив вызывающую программу оператором return возвращается сумма этих значений.

Восновной программе создаются две глобальные переменные с такими же

именами – a и b, задаются случайными числами, выводятся на экран вместе со своими адресами, потом производится вызов подпрограммы sum2ab(a, b) и вновь значения a и b выводятся на экран. Результаты работы программы (Листинг 58) приведены ниже на рисунке (Рис. 38).

Листинг 58

#include «stdafx.h» #include <iostream> #include <time.h> using namespace std;

//——————————————————————————

int sum2ab(int a, int b) // Передача параметров в функцию «по значению»

{

a = 2 * a; // удваиваем значения переменных b = 2 * b;

printf(«nвывод из подпрограммы sum2ab:n»);

printf(«a= %2d (address a= %p) b= %2d (address b= %p)n», a, &a, b, &b); return a + b; // возвращаем 2a+2b

}

//——————————————————————————

void _tmain(int argc, char* argv[])

{

system(«chcp 1251»); // подпрограмма русского шрифта srand(time(NULL)); // инициализация генератора случайных чисел int a = rand() % 10;

int b = rand() % 10;

printf(«nвывод из главной подпрограммы main():n»);

printf(«a= %2d (address a= %p) b= %2d (address b= %p)n», a, &a, b, &b); printf(«n2a+2b= %dn», sum2ab(a, b));

// значения глобальных переменных a и b не изменились printf(«nповторный вывод из главной подпрограммы main():n»);

Глава 4. Подпрограммы

printf(«a= %2d (address a= %p) b= %2d (address b= %p)n», a, &a, b, &b); system(«pause»); // ожидание нажатия клавиши

}

Рис. 38. Результаты выполнения программы

Проанализируем результаты. Можно видеть, что сначала выводятся данные из основной программы, глобальные переменные a и b принимают значения 3 и 1 соответственно. В круглых скобках выведены адреса 0032FB80 и 0032FB74 глобальных переменных a и b.

Затем производится вывод локальных переменных a и b из подпрограммы sum2ab(). Можно видеть, что их адреса 0032FA9C и 0032FAA0 не совпадают с адресами глобальных переменных a и b, следовательно, это другие ячейки памяти. Значения этих переменных удвоены. После этого выводится сумма удвоенных значений – подпрограмма sum2ab() корректно вычисляет и передает в главную программу результат сложения.

Однако заметьте, что повторный вывод глобальных переменных a и b (а это именно те исходные переменные – можно видеть по адресам) показывает, что их значения не изменились!

Можно сделать вывод о том, что изменение локальных переменных внутри подпрограммы не влияет на глобальные переменные в головной программе. Потому что передаваемые «по значению» переменные в подпрограмме – это копии глобальных переменных. Изменение «копий» не изменяет «оригиналы».

Передача параметров по ссылке

Передачу параметров «по ссылке» удобно рассмотреть на примере функции S() меняющей местами свои аргументы p и q (Рис. 39). Если бы p и q передавались в функцию S() по значению, как в предыдущем примере, то обмен местами значений локальных переменных p и q в теле функции S() никак не повлиял бы на значения глобальных переменных x и у.

При передаче данных в функцию S() по ссылке ячейки памяти для ссылочных переменных p и q не создаются, а для работы используются ячейки памяти головной программы – чьи имена передаются в функцию S(). Символ «&» перед переменным в списке формальных параметров в данном случае обозначает обращение «по ссылке».

В примере (Рис. 39) переменные p и q в теле функции S() не существуют как самостоятельные отдельные ячейки памяти, а служат лишь для обозначения ячеек x и y. В момент вызова подпрограммы, заданные в списке фактических параметров ссылки &p и &q инициируются какими-то глобальными переменными (в нашем примере – переменными x и y). Дальше в теле подпрограммы со ссылочными переменными p и q производятся операции так же, как и над обычными ссылками (см. п.3.5).

Рис. 39. Передача параметров по ссылке

Изменим пример, приведенный выше (Листинг 58), так, чтобы параметры передавались в функцию по ссылке. (Листинг 59). Для этого в заголовке функции int sum2ab(int& a, int& b), изменим строку описания формальных параметров, добавив символы «&». Больше ничего изменять не станем – как и в предыдущем примере в теле подпрограммы значения a и b удваиваются, затем производится вывод на экран значений этих переменных с адресами, после чего они суммируются, и в вызывающую программу возвращается сумма этих значений.

Листинг 59

int sum2ab(int& a, int& b) // Передача параметров в функцию «по ссылке»

{

a = 2 * a; // удваиваем значения переменных b = 2 * b;

printf(«nвывод из подпрограммы sum2ab:n»);

printf(«a= %2d (address a= %p) b= %2d (address b= %p)n», a, &a, b, &b); return a + b; // возвращаем 2a+2b

}

Основную программу также оставим без изменений. Посмотрим, как изменился результат (Рис. 40). Во-первых, можно видеть, что адреса переменных a и b, выводимые из основной программы и из подпрограммы sum2ab() одни и те же. Это можно понять по адресам этих переменных – 001EFA8C и 001EFA80. В головной программе и в вызываемой подпрограммы мы работаем с одними и теми же ячейками памяти. Естественно, что значения переменных как удвоились в подпрограмме, так и остались удвоенными при повторном выводе из программы main().

Рис. 40. Результаты выполнения программы

Передача параметров по указателю

Передача параметров по указателю (Рис. 41) практически ничем не отличается от передачи данных по значению – разница лишь в том, что аргументом функции выступают не статические переменные S(int p, int q), а переменные-указатели S(int* p, int* q). Напомню, что указатели хранят в себе адреса.