Лекции.ИНФО


Перегрузка функций и неоднозначность



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

Прежде чем завершить эту главу, мы должны исследовать вид ошибок, уникальный для C++: неоднозначность. Возможны ситуации, в которых компилятор не способен сделать выбор между двумя (или более) корректно перегруженными функциями. Такие ситуации и называют неоднозначными. Инструкции, создающие неоднозначность, являются ошибочными, а программы, которые их содержат, скомпилированы не будут.

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

int myfunc(double d);

.

.

.

cout << myfunc('c'); // Ошибки нет, выполняется преобразование типов.

Как отмечено в комментарии, ошибки здесь нет, поскольку C++ автоматически преобразует символ 'c' в его double-эквивалент. Вообще говоря, в C++ запрещено довольно мало видов преобразований типов. Несмотря на то что автоматическое преобразование типов — это очень удобно, оно, тем не менее, является главной причиной неоднозначности. Рассмотрим следующую программу.

// Неоднозначность вследствие перегрузки функций.

#include <iostream>

using namespace std;

float myfunc(float i);

double myfunc(double i);

Int main()

{

 // Неоднозначности нет, вызывается функция myfunc(double).

 cout << myfunc (10.1) << " ";

 // Неоднозначность.

 cout << myfunc(10);

 return 0;

}

Float myfunc(float i)

{

 return i;

}

Double myfunc(double i)

{

 return -i;

}

Здесь благодаря перегрузке функция myfunc() может принимать аргументы либо типа float, либо типа double. При выполнении строки кода

cout << myfunc (10.1) << " ";

не возникает никакой неоднозначности: компилятор "уверенно" обеспечивает вызов функции myfunc(double), поскольку, если не задано явным образом иное, все литералы с плавающей точкой в C++ автоматически получают тип double. Но при вызове функции myfunc() с аргументом, равным целому числу 10, в программу вносится неоднозначность, поскольку компилятору неизвестно, в какой тип ему следует преобразовать этот аргумент: float или double. Оба преобразования допустимы. В такой неоднозначной ситуации будет выдано сообщение об ошибке, и программа не скомпилируется.

На примере предыдущей программы хотелось бы подчеркнуть, что неоднозначность в ней вызвана не перегрузкой функции myfunc(), объявленной дважды для приема double- и float-аргумента, а использованием при конкретном вызове функции myfunc() аргумента неопределенного для преобразования типа. Другими словами, ошибка состоит не в перегрузке функции myfunc(), а в конкретном ее вызове.

А вот еще один пример неоднозначности, вызванной автоматическим преобразованием типов в C++.

// Еще одна ошибка, вызванная неоднозначностью.

#include <iostream>

using namespace std;

char myfunc(unsigned char ch);

char myfunc(char ch);

Int main()

{

 cout << myfunc('c'); // Здесь вызывается myfunc(char).

 cout << myfunc(88) << " "; // Вносится неоднозначность.

 return 0;

}

Char myfunc(unsigned char ch)

{

 return ch-1;

}

Char myfunc(char ch)

{

 return ch+1;

}

В C++ типы unsigned char и char не являются существенно неоднозначными. (Это — различные типы.) Но при вызове функции myfunc() с целочисленным аргументом 88 компилятор "не знает", какую функцию ему выполнить, т.е. в значение какого типа ему следует преобразовать число 88: типа char или типа unsigned char? Оба преобразования здесь вполне допустимы.

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

// Еще один пример неоднозначности.

#include <iostream>

using namespace std;

int myfunc(int i);

int myfunc(int i, int j=1);

Int main()

{

 cout << myfunc(4, 5) << " "; // неоднозначности нет

 cout << myfunc(10); // неоднозначность

 return 0;

}

Int myfunc(int i)

{

 return i;

}

Int myfunc(int i, int j)

{

 return i*j;

}

Здесь в первом обращении к функции myfunc() задается два аргумента, поэтому у компилятора нет никаких сомнений в выборе нужной функции, а именно myfunc(int i, int j), т.е. никакой неоднозначности в этом случае не привносится. Но при втором обращении к функции myfunc() мы получаем неоднозначность, поскольку компилятор "не знает", то ли ему вызвать версию функции myfunc(), которая принимает один аргумент, то ли использовать возможность передачи аргумента по умолчанию к версии, которая принимает два аргумента.


Программируя на языке C++, вам еще не раз придется столкнуться с ошибками неоднозначности, которые, к сожалению, очень легко "проникают" в программы, и только опыт и практика помогут вам избавиться от них.


Глава 9: Еще о типах данных и операторах

Прежде чем переходить к более сложным средствам C++, имеет смысл подробнее познакомиться с некоторыми типами данных и операторами. Кроме уже рассмотренных нами типов данных, в C++ определены и другие. Одни из них состоят из модификаторов, добавляемых к уже известным вам типам. Другие включают перечисления, а третьи используют ключевое слово typedef. C++ также поддерживает ряд операторов, которые значительно расширяют область действия языка и позволяют решать задачи программирования в весьма широком диапазоне. Речь идет о поразрядных операторах, операторах сдвига, а также операторах "?" и sizeof. Кроме того, в этой главе рассматриваются такие специальные операторы, как new и delete. Они предназначены для поддержки С++-системы динамического распределения памяти.

Спецификаторы типа const и volatile

Спецификаторы типа const и volatile управляют доступом к переменной.

В C++ определено два спецификатора типа, которые оказывают влияние на то, каким образом можно получить доступ к переменным или модифицировать их. Это спецификаторы const и volatile. Официально они именуются cv-спецификаторами и должны предшествовать базовому типу при объявлении переменной.

Спецификатор типа const

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

const double version = 3.2;

создается double-переменная version, которая содержит значение 3.2, и это значение программа изменить уже не может. Но эту переменную можно использовать в других выражениях. Любая const-переменная получает значение либо во время явно задаваемой инициализации, либо при использовании аппаратно-зависимых средств. Применение спецификатора const к объявлению переменной гарантирует, что она не будет модифицирована другими частями вашей программы.

Спецификатор const предотвращает модификацию переменной при выполнении программы.

Спецификатор const имеет ряд важных применений. Возможно, чаще всего его используют для создания const-параметров типа указатель. Такой параметр-указатель защищает объект, на который он ссылается, от модификации со стороны функции. Другими словами, если параметр-указатель предваряется ключевым словом const, никакая инструкция этой функции не может модифицировать переменную, адресуемую этим параметром. Например, функция code() в следующей короткой программе сдвигает каждую букву в сообщении на одну алфавитную позицию (т.е. вместо буквы 'А' ставится буква 'Б' и т.д.), отображая таким образом сообщение в закодированном виде. Использование спецификатора const в объявлении параметра не позволяет коду функции модифицировать объект, на который указывает этот параметр.

#include <iostream>

using namespace std;

void code(const char *str);

Int main()

{

 code("Это тест.");

 return 0;

}

/* Использование спецификатора const гарантирует, что str не может изменить аргумент, на который он указывает.

*/

void code(const char *str)

{

 while(*str) {

  cout << (char) (*str+1);

  str++;

 }

}

Поскольку параметр str объявляется как const-указатель, у функции code() нет никакой возможности внести изменения в строку, адресуемую параметром str. Но если вы попытаетесь написать функцию code() так, как показано в следующем примере, то обязательно получите сообщение об ошибке, и программа не скомпилируется.

// Этот код неверен.

void code(const char *str)

{

 while(*str) {

  *str = *str + 1; // Ошибка, аргумент модифицировать нельзя.

  cout << (char) *str;

  str++;

 }

}

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

Спецификатор const можно также использовать для ссылочных параметров, чтобы не допустить в функции модификацию переменных, на которые ссылаются эти параметры. Например, следующая программа некорректна, поскольку функция f() пытается модифицировать переменную, на которую ссылается параметр i.

// Нельзя модифицировать const-ссылки.

#include <iostream>

using namespace std;

void f(const int &i);

Int main()

{

 int к = 10;

 f(к);

 return 0;

}

// Использование ссылочного const-параметра.

void f (const int &i)

{

 i = 100; // Ошибка, нельзя модифицировать const-ссылку.

 cout << i;

}

Спецификатор const еще можно использовать для подтверждения того, что ваша программа не изменяет значения некоторой переменной. Вспомните, что переменная типа const может быть модифицирована внешними устройствами, т.е. ее значение может быть установлено каким-нибудь аппаратным устройством (например, датчиком). Объявив переменную с помощью спецификатора const, можно доказать, что любые изменения, которым подвергается эта переменная, вызваны исключительно внешними событиями.

Наконец, спецификатор const используется для создания именованных констант. Часто в программах многократно применяется одно и то же значение для различных целей. Например, необходимо объявить несколько различных массивов таким образом, чтобы все они имели одинаковый размер. Когда нужно использовать подобное "магическое число", имеет смысл реализовать его в виде const-переменной. Затем вместо реального значения можно использовать имя этой переменной, а если это значение придется впоследствии изменить, вы измените его только в одном месте программы. Следующая программа позволяет попробовать этот вид применения спецификатора const "на вкус".

#include <iostream>

using namespace std;

const int size = 10;

Int main()

{

 int A1[size], A2[size], A3[size];

 // . . .

}

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

Спецификатор типа volatile

Спецификатор volatile информирует компилятор о том, что данная переменная может быть изменена внешними (по отношению к программе) факторами.

Спецификатор volatile сообщает компилятору о том, что значение соответствующей переменной может быть изменено в программе неявным образом. Например, адрес некоторой глобальной переменной может передаваться управляемой прерываниями подпрограмме тактирования, которая обновляет эту переменную с приходом каждого импульса сигнала времени. В такой ситуации содержимое переменной изменяется без использования явно заданных инструкций программы. Существуют веские основания для того, чтобы сообщить компилятору о внешних факторах изменения переменной. Дело в том, что С++-компилятору разрешается автоматически оптимизировать определенные выражения в предположении, что содержимое той или иной переменной остается неизменным, если оно не находится в левой части инструкции присваивания. Но если некоторые факторы (внешние по отношению к программе) изменят значение этого поля, такое предположение окажется неверным, в результате чего могут возникнуть проблемы.

Например, в следующем фрагменте программы предположим, что переменная clock обновляется каждую миллисекунду часовым механизмом компьютера. Но, поскольку переменная clock не объявлена с использованием спецификатора volatile, этот фрагмент кода может иногда работать недолжным образом. (Обратите особое внимание на строки, обозначенные буквами "А" и "Б".)

int clock, timer;

 // ...

timer = clock; // строка A

// ... Какие-нибудь действия.

cout << "Истекшее время " << clock-timer; // строка Б

В этом фрагменте переменная clock получает свое значение, когда она присваивается переменной timer в строке А. Но, поскольку переменная clock не объявлена с использованием спецификатора volatile, компилятор волен оптимизировать этот код, причем таким способом, при котором значение переменной clock, возможно, не будет опрошено в инструкции cout (строка Б), если между строками А и Б не будет ни одного промежуточного присваивания значения переменной clock. (Другими словами, в строке Б компилятор может просто еще раз использовать значение, которое получила переменная clock в строке А.) Но если между моментами выполнения строк А и Б поступят очередные импульсы сигнала времени, то значение переменной clock обязательно изменится, а строка Б в этом случае не отразит корректный результат.

Для решения этой проблемы необходимо объявить переменную clock с ключевым словом volatile.

volatile int clock;

Теперь значение переменной clock будет опрашиваться при каждом ее использовании.

И хотя на первый взгляд это может показаться странным, спецификаторы const и volatile можно использовать вместе. Например, следующее объявление абсолютно допустимо. Оно создает const-указатель на volatile-объект.

const volatile unsigned char *port = (const volatile char *) 0x2112;

В этом примере для преобразования целочисленного литерала 0x2112 в const-указатель на volatile-символ необходимо применить операцию приведения типов.

Спецификаторы классов памяти

C++ поддерживает пять спецификаторов классов памяти:

Auto

Extern

Register

Static

Mutable

Спецификаторы классов памяти определяют, как должна храниться переменная.









Читайте также:

Последнее изменение этой страницы: 2016-03-17; Просмотров: 176;


lektsia.info 2017 год. Все права принадлежат их авторам! Главная