Лекции.ИНФО


Unsigned int i; //не register-переменная



unsigned int delay;

Int main()

{

 register unsigned int j;

 long start, end;

 start = clock();

 for(delay=0; delay<50; delay++)

  for(i=0; i<64000000; i++);

 end = clock();

 cout << "Количество тиков для не register-цикла: ";

 cout << end-start << ' ';

 start = clock();

 for(delay=0; delay<50; delay++)

  for(j=0; j<64000000; j++);

 end = clock();

 cout << "Количество тиков для register-цикла: ";

 cout << end-start << '';

 return 0;

}

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

На заметку. При написании этой книги была использована среда Visual C++, которая игнорирует ключевое слово register. Visual C++ применяет оптимизацию "как считает нужным". Поэтому вы можете не заметить влияния спецификатора register на выполнение предыдущей программы. Однако ключевое слово register все еще принимается компилятором без сообщения об ошибке. Оно просто не оказывает никакого воздействия.

Перечисления

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

enum type_name { список_перечисления } список_переменных;

Под элементом список_перечисления понимается список разделенных запятыми имен, которые представляют значения перечисления. Элемент список_переменных необязателен, поскольку переменные можно объявить позже, используя имя типа перечисления. В следующем примере определяется перечисление apple и две переменные типа apple с именами red и yellow.

enum apple {Jonathan, Golden_Del, Red_Del, Winesap, Cortland, McIntosh} red, yellow;

Определив перечисление, можно объявить другие переменные этого типа, используя имя перечисления. Например, с помощью следующей инструкции объявляется одна переменная fruit перечисления apple.

apple fruit;

Эту инструкцию можно записать и так.

enum apple fruit;

Ключевое слово enum объявляет перечисление.

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

С учетом предыдущих объявлений следующие типы инструкций совершенно допустимы.

fruit = Winesap;

if(fruit==Red_Del) cout << "Red Delicious";

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

cout << Jonathan << ' ' << Cortland;

на экран будут выведены числа 0 4.

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

fruit =1; // ошибка

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

fruit = (apple) 1; // Теперь все в порядке, но стиль не совершенен.

Теперь переменная fruit будет содержать значение Golden_Del, поскольку эта apple-константа связывается со значением 1. Как отмечено в комментарии, несмотря на то, что эта инструкция стала корректной, ее стиль оставляет желать лучшего, что простительно лишь в особых обстоятельствах.

Используя инициализатор, можно указать значение одной или нескольких перечислимых констант. Это делается так: после соответствующего элемента списка перечисления ставится знак равенства и нужное целое число. При использовании инициализатора следующему (после инициализированного) элементу списка присваивается значение, на единицу превышающее предыдущее значение инициализатора. Например, при выполнении следующей инструкции константе Winesap присваивается значение 10.

enum apple {Jonathan, Golden_Del, Red_Del, Winesap=10, Cortland, McIntosh};

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

// Слово "McIntosh" на экран таким образом не попадет.

fruit = McIntosh;

cout << fruit;

He забывайте, что символ McIntosh — это просто имя для некоторого целочисленного значения, а не строка. Следовательно, при выполнении предыдущего кода на экране отобразится числовое значение константы McIntosh, а не строка "McIntosh". Конечно, можно создать код ввода и вывода символов перечисления в виде строк, но он выходит несколько громоздким. Вот, например, как можно отобразить на экране названия сортов яблок, связанных с переменной fruit.

switch(fruit) {

 case Jonathan: cout << "Jonathan";

  break;

 case Golden_Del: cout << "Golden Delicious";

  break;

 case Red_Del: cout << "Red Delicious";

  break;

 case Winesap: cout << "Winesap";

  break;

 case Cortland: cout << "Cortland";

  break;

 case McIntosh: cout << "McIntosh";

  break;

}

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

#include <iostream>

using namespace std;

enum apple {Jonathan, Golden_Del, Red_Del, Winesap, Cortland, McIntosh};

// Массив строк, связанных с перечислением apple.

char name[][20] = {

 "Jonathan",

 "Golden Delicious",

 "Red Delicious",

 "Winesap",

 "Cortland",

 "McIntosh",

};

Int main()

{

 apple fruit;

 fruit = Jonathan;

 cout << name[fruit] << '';

 fruit = Winesap;

 cout << name[fruit] << '';

 fruit = McIntosh;

 cout << name[fruit] << '';

 return 0;

}

Результаты выполнения этой программы таковы.

Jonathan

Winesap

McIntosh

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

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

Ключевое слово typedef

Ключевое слово typedef позволяет создать новое имя для существующего типа данных.

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

typedef тип новое_имя;

Здесь элемент тип означает любой допустимый тип данных, а элемент новое_имя — новое имя для этого типа. При этом заметьте: новое имя определяется вами в качестве дополнения к существующему имени типа, а не для его замены.

Например, с помощью следующей инструкции можно создать новое имя для типа float,

typedef float balance;

Эта инструкция является предписанием компилятору распознавать идентификатор balance как еще одно имя для типа float. После этой инструкции можно создавать float-переменные с использованием имени balance.

balance over_due;

Здесь объявлена переменная с плавающей точкой over_due типа balance, который представляет собой стандартный тип float, но имеющий другое название.

Еще об операторах

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

Поразрядные операторы

Поразрядные операторы обрабатывают отдельные биты.

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

Поразрядные операторы И, ИЛИ, исключающее ИЛИ и НЕ

Поразрядные операторы И, ИЛИ, исключающее ИЛИ и НЕ (обозначаемые символами &, |, ^ и ~ соответственно) выполняют те же операции, что и их логические эквиваленты (т.е. они действуют согласно той же таблице истинности). Различие состоит лишь в том, что поразрядные операции работают на побитовой основе. В следующей таблице показан результат выполнения каждой поразрядной операции для всех возможных сочетаний операндов (нулей и единиц).

Как видно из таблицы, результат применения оператора XOR (исключающее ИЛИ) будет равен значению ИСТИНА (1) только в том случае, если истинен (равен значению 1) лишь один из операндов; в противном случае результат принимает значение ЛОЖЬ (0).

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

 1101 0011

& 1010 1010

 1000 0010

Следующая программа считывает символы с клавиатуры и преобразует любой строчный символ в его прописной эквивалент путем установки шестого бита равным значению 0. Набор символов ASCII определен так, что строчные буквы имеют почти такой же код, что и прописные, за исключением того, что код первых отличается от кода вторых ровно на 32[только для латинского алфавита]. Следовательно, как показано в этой программе, чтобы из строчной буквы сделать прописную, достаточно обнулить ее шестой бит.

// Получение прописных букв.

#include <iostream>

using namespace std;

Int main()

{

 char ch;

 do {

  cin >> ch;

  // Эта инструкция обнуляет 6-й бит.

  ch = ch & 223; // В переменной ch теперь прописная буква.

  cout << ch;

 }while(ch! = 'Q');

 return 0;

}

Значение 223, используемое в инструкции поразрядного И, является десятичным представлением двоичного числа 1101 1111. Следовательно, эта операция И оставляет все биты в переменной ch нетронутыми, за исключением шестого (он сбрасывается в нуль).

Оператор И также полезно использовать, если нужно определить, установлен ли интересующий вас бит (т.е. равен ли он значению 1) или нет. Например, при выполнении следующей инструкции вы узнаете, установлен ли 4-й бит в переменной status,

if(status & 8) cout << "Бит 4 установлен";

Чтобы понять, почему для тестирования четвертого бита используется число 8, вспомните, что в двоичной системе счисления число 8 представляется как 0000 1000, т.е. в числе 8 установлен только четвертый разряд. Поэтому условное выражение инструкции if даст значение ИСТИНА только в том случае, если четвертый бит переменной status также установлен (равен 1). Интересное использование этого метода показано на примере функции disp_binary(). Она отображает в двоичном формате конфигурацию битов своего аргумента. Мы будем использовать функцию disp_binary() ниже в этой главе для исследования возможностей других поразрядных операций.

// Отображение конфигурации битов в байте.

void disp_binary(unsigned u)

{

 register int t;

 for(t=128; t>0; t=t/2)

  if(u & t) cout << "1";

  else cout << "0 ";

 cout << "";

}

Функция disp_binary(), используя поразрядный оператор И, последовательно тестирует каждый бит младшего байта переменной u, чтобы определить, установлен он или сброшен. Если он установлен, отображается цифра 1, в противном случае — цифра 0. Интереса ради попробуйте расширить эту функцию так, чтобы она отображала все биты переменной u, а не только ее младший байт.

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

 1101 0011

| 1010 1010

 1111 1011

Можно использовать оператор ИЛИ для превращения рассмотренной выше программы (которая преобразует строчные символы в их прописные эквиваленты) в ее "противоположность", т.е. теперь, как показано ниже, она будет преобразовывать прописные буквы в строчные.

// Получение строчных букв.

#include <iostream>

using namespace std;

Int main()

{

 char ch;

 do {

  cin >> ch;

  /* Эта инструкция делает букву строчной, устанавливая ее 6-й бит.*/

  ch = ch | 32;

  cout << ch;

 }while(ch != 'q');

 return 0;

}

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

 0111 1111

^ 1011 1001

 1100 0110

Унарный оператор НЕ (или оператор дополнения до 1) инвертирует состояние всех битов своего операнда. Например, если целочисленное значение (хранимое в переменной А), представляет собой двоичный код 1001 0110, то в результате операции получим двоичный код 0110 1001.

В следующей программе демонстрируется использование оператора НЕ посредством отображения некоторого числа и его дополнения до 1 в двоичном коде с помощью приведенной выше функции disp_binary().

#include <iostream>

using namespace std;

void disp_binary(unsigned u);

Int main()

{

 unsigned u;

 cout << "Введите число между 0 и 255: ";

  cin >> u;

 cout << "Исходное число в двоичном коде: ";

 disp_binary(u);

 cout << "Его дополнение до единицы: ";

 disp_binary(~u);

 return 0;

}

// Отображение битов, составляющих байт.

void disp_binary(unsigned u)

{

 register int t;

 for(t=128; t>0; t=t/2)

  if(u & t) cout << "1";

  else cout << "0";

 cout << "";

}









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

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


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