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

      х = 1 ;

      х = 2.3

      х = "Это - предложение."

      х = Техас

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

Вы должны сообщить С++, сколько памяти вам надо для хранения той или иной переменной, перед тем как приступить к её использованию. Добавлю, что особенности использования переменных разных типов различны. Пока вы встречались только с переменными типа int:

      int х ;

      х = 1 ;

В С++ тип int определяет множество целых чисел. Напомню, что целым называется число, не имеющее дробной части.

Целые числа используют для самых разных видов вычислений. Детально этому учат в младшей школе, приблизительно до шестого класса, и лишь потом начинается путаница с дробями. Та же тенденция характерна и для С++, в котором более 90% всех переменных имеют тип int[ 5 ] .

К сожалению, иногда использование в программах переменных типа int приводит к ошибочным результатам. Когда в вы работали с программой, преобразующей температуру, существовала ( пусть неявно ) проблема: программа могла работать только с целыми значениями температуры. Отмечу, что в этой конкретной программе использование исключительно целых чисел вряд ли приведёт к отрицательным последствиям. Но при проведении серьёзных метеорологических исследований усечение дробной части температурных значений может поставить под вопрос истинность полученных результатов. Указанная проблема осложняется тем, что компилятор, не давая никаких предупреждающих сообщений, просто отбрасывает дробную часть числа. Согласитесь, было бы неприятно приземлиться на самолёте, не долетев полкилометра до взлётно-посадочной полосы просто из-за округления в программе навигации...

________

5Эта величина опять-таки существенно зависит от типа разрабатываемой программы. — Прим. ред.

_________________

42 стр. . Первое знакомство с С++

Ограничения, налагаемые на целые числа в С++...43

Целочисленные переменные в С++ представляются типом int. На переменные этого типа накладываются те же ограничения, что и на их эквиваленты в математике.

Округление до целых значений...43

Рассмотрим проблему вычисления среднего трёх чисел. Введём три целочисленные переменные — nValue1, nValue2, nValue3. Среднее значение вычисляется по формуле

      ( nValue1 + nValue2 + nValue3 ) / 3

Поскольку все три значения являются целыми, их сумма тоже будет целым числом. Например, сумма чисел 1, 2 и 2 равна 5. Но если 5 поделить на 3, получим 12/3 , или 1,666.... В отличие от людей ( обладающих разумом ), компьютеры ( которым он свойственен далеко не всегда ) приводят полученный результат к целому значению, просто отбрасывая его дробную часть. При этом 1,666 утратит свой "дьявольский" остаток и превратится в 1.

Для многих приложений усечение дробной части числа не представляет большой проблемы. Зачастую оно может быть даже полезным ( разумеется, сказанное не касается математических или экономических программ ). Однако такое округление целых значений может весьма пагубно сказаться на работе других программ. Рассмотрим следующую, эквивалентную приведённой выше формулу:

     ( nValue1 / 3 ) + ( nValue2 / 3 ) + ( nValue3 / 3 )

Подставляя в неё те же значения 1, 2 и 2, в результате получим 0. Это случилось потому, что каждое слагаемое оказалось числом, меньшим 1. Компьютер округлил их до 0 , а сумма трёх нулей, как известно, равна 0. Так что такого приведения к целочисленным значениям, вообще говоря, нужно избегать.

Ограничения диапазона...43

Второй проблемой переменной типа int является ограниченный диапазон возможных её значений. Максимальным значением обычной целочисленной переменной является число 2147483647, минимальным — -2147483648, т.е. общий диапазон — около 4 млрд. чисел[ 6 ] .

«Два миллиарда — число весьма большое, чтобы быть достаточным для большинства применений. Тем не менее есть множество задач, где этого недостаточно. Например, ваш компьютер может иметь тактовую частоту, превышающую 2 ГГц ( приставка Г — Гига — как раз и обозначает миллиард ).»

[]

С++ позволяет объявлять целые числа как беззнаковые, что означает, что они не могут быть отрицательны. Целое число типа unsigned int может принимать значения от 0 до 4294967295, что иногда облегчает ситуацию.

«Вы можете объявить переменную просто как unsigned , опустив объявление int , которое подразумевается неявно.»

[]

__________

6Вообще говоря, диапазон значений типа int определяется множеством факторов — в первую очередь компилятором, на выбор типа int которого оказывает огромное влияние тип компьютера, поэтому считать определённым раз и навсегда, что диапазон значений int простирается от -232 до +232-1, нельзя. — Прим. ред.

_________________

43 стр. . Премудрости объявления переменных

Решение проблемы усечения дробной части...44

Рассмотренные особенности переменных типа int делают невозможным их использование в некоторых приложениях. Но, к счастью, С++ умеет работать и с десятичными числами, которые могут иметь ненулевую дробную часть ( математики называют их действительными числами ). Используя действительные числа, можно избежать большинства перечисленных проблем. Заметьте, что десятичные числа могут иметь ненулевую дробную часть, а могут и не иметь, оставаясь действительными. В С++ число 1.0 такое же действительное число, как и 1.5. Эквивалентным им целым числом является 1. Десятичные числа могут также быть отрицательны, например, -2.3.

В С++ действительные числа определены как числа с плавающей точкой, или просто double ( что означает "двойной" точности; в С++ есть действительные числа и одинарной точности, но это экзотика, о которой мы не будем говорить ). Используя выражение "с плавающей точкой", имеют в виду, что десятичную запятую ( или используемую вместо неё в программах точку ) в десятичных числах можно перемещать вперёд и назад настолько, насколько этого требуют вычисления. Действительные переменные объявляются так же, как и переменные типа int:

      double dValue ;

Начиная с этой строки, во всей остальной части программы переменная dValue может принимать значения типа double. Тип уже объявленной переменной изменить нельзя: dValue является действительной переменной и останется ею до конца программы. Рассмотрим, как решается присущая целочисленным переменным проблема отбрасывания дробной части. Для этого в объявлении все переменные определим как действительные ( тип double ):

      double dValue ;

      dValue = 1.0/3.0 + 2.0/3.0 + 2.0/3.0 ;

Это эквивалентно выражению

      dValue = 0.333... + 0.666... + 0.666... ;

которое даёт значение

       dValue = 1.666... ;

«Я записал значение 1.666... как число с бесконечным числом шестёрок, однако на самом деле такая запись по сути невозможна в силу того, что имеется предел количества цифр, которое может быть в переменной типа double .»

[]

«На прилагаемом компакт-диске в папке Cpp_Programs\Chap02 программы IntAverage и FloatAverage демонстрируют разобранные здесь примеры вычисления среднего значения.»  

[]

// 

/*  IntAverage — среднее 3 чисел, используя целочисленную арифметику. */

/*               Сперва сумма трёх отношений */

/*               ( сумма каждого числа разделённого на 3), */

/*               второе разделить сумму трёх чисел на 3. */

#include

#include

#include

using namespace std ;

int main( int nNumberofArgs , char* pszArgs[ ] )

{

    setlocale ( LC_ALL , ".1251" ) ; /* печать русских текстов */

    int nValue1 ;

    int nValue2 ;

    int nValue3 ;

    // введите три числа

    cout << "Эта программа вычисляет среднее трёх чисел типа int\n "

         << "integer ( целочисленной ) арифметики\n\n" ;

    cout << "Введите три целых числа:\n" ;

    cout << "n1 - " ;

    cin  >> nValue1 ;

    cout << "n2 - " ;

    cin  >> nValue2 ;

    cout << "n3 - " ;

    cin  >> nValue3 ;

    /*  Сперва сумма трёх отношений */

    cout << "n1/3 + n2/3 + n3/3 = " ;

    cout << nValue1/3 + nValue2/3 + nValue3/3 ;

    cout << "\n" ;

    /* Сейчас соотношение трёх сумм */

    cout << "( n1 + n2 + n3 ) / 3   = " ;

    cout << ( nValue1 + nValue2 + nValue3) / 3 ;

    cout << "\n" ;

    /* Пауза для того, чтобы посмотреть на результат работы программы */

    system( "PAUSE" ) ;

    return 0 ;

}

/* FloatAverage — среднее 3 чисел, используя арифметику с плавающей точкой.*/

/*                   В противном случае, так же как IntAverage */

#include

#include

#include

using namespace std ;

int main( int nNumberofArgs , char* pszArgs[ ] )

{

setlocale ( LC_ALL , ".1251" ) ; /* печать русских текстов */

    float fValue1 ;

    float fValue2 ;

    float fValue3 ;

    // введите три числа

    cout << "Эта програма вычисляет среднее трёх чисел типа float\n"

         << "floating point( с плавающей точкой ) арифметики\n\n" ;

    cout << "Введите три числа:\n" ;

    cout << "f1 - " ;

    cin  >> fValue1 ;

    cout << "f2 - ";

    cin  >> fValue2 ;

    cout << "f3 - " ;

    cin  >> fValue3 ;

     /* Сперва сумма трёх отношений */

    cout << "n1/3 + n2/3 + n3/3 = " ;

    cout << fValue1/3 + fValue2/3 + fValue3/3 ;

    cout << "\n" ;

     /* Сейчас соотношение трёх сумм */

    cout << "(n1 + n2 + n3)/3   = " ;

    cout << (fValue1 + fValue2 + fValue3) / 3 ;

    cout << "\n" ;

    /* Пауза для того, чтобы посмотреть на результат работы программы */

    system( "PAUSE" ) ;

    return 0 ;

}

Ограничения, налагаемые на числа с плавающей точкой...44

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

Перечисление...44

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

_________________

44 стр. . Первое знакомство с С++

Например, ясно, что 1.0 есть 1. Но что такое 0.9 или 1.1 ? Следует ли их рассматривать как 1 ? Так что С++ избегает многих проблем, требуя использовать при перечислении только целые значения.

Скорость вычислений...45

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

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

Потеря точности...45

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

Чтобы понять эту проблему, представим 1/3 в виде бесконечной последовательности 0.333.... Однако математическое понятие периода в программировании не имеет смысла, так как точность компьютерных вычислений ограничена и где-то наша дробь должна оборваться ( что зависит от использованного для хранения числа типа переменной ). Поэтому, усреднив числа 1, 2, 2, мы получим не точное, а приблизительное значение 1.666667.

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

Ограниченность диапазона...45

Тип данных double также ограничен, хотя его диапазон намного обширнее диапазона целочисленных переменных. Максимальным значением типа int является число чуть больше 2 млрд.; максимальное значение переменной типа double приблизительно равно 10308, т.е. 1 с 308 нулями[ 7 ] .

«Представляя переменные с плавающей точкой в стандартном виде, С++ учитывает после десятичной точки только первые 13 разрядов. Остальные 25 разрядов становятся жертвами ошибочных округлений.»

[]

Вы уже знаете, что все переменные в программе должны быть объявлены и что им должен быть назначен тип. Однако в С++ имеется масса различных типов. В табл. 2.1 представлен список некоторых стандартных типов переменных языка С++ с указанием их достоинств и недостатков.

________

7Это не означает, будто тип double может представить 1038 разных значений; вспомните, что говорилось выше о количестве разрядов в числах этого типа. — Прим. ред.

_________________

45 стр. . Премудрости объявления переменных

Таблица 2.1. Переменные С++

_________________

Переменная — Пример — Характеристика

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

int — 1  — Простые положительные или отрицательные числа,  используемые для перечисления . 

unsigned — 1U  — Неотрицательные числа, предназначенные в первую очередь для перечислений.

long — 10L  — Потенциально расширенная версия типа int. В Dev-C++ и Microsoft Visual С++ .NET разницы между типами long и int нет.

unsigned long —10UL  — Неотрицательная версия типа long.

float  —  1.0F —  Действительные числа единичной точности. Это уменьшенная версия double , требующая меньшего количества памяти, но при этом имеющая меньшую точность и диапазон возможных значений.

double  —  1.0  — Стандартное представление чисел с плавающей точкой.

char — c   — Символьный тип; значением переменных может быть символ алфавита, цифра, знак препинания или знак арифметической операции. Не годится для арифметических операций.

string   —  "this is a  string"  —  Строка символов, составляющая предложение.

bool  — true   —  Тип имеет только два логических значения — true и false ( истина и ложь ).

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

Может показаться странным, что основным типом для действительных чисел является тип двойной точности, а не одинарной. Тому есть исторические причины — уходящие корнями в те времена, когда Большой Билл утверждал, что 640 Кбайт памяти хватит всем и всегда, а экономия памяти и повышение скорости вычислений за счёт точности представлялась разумной мерой. С удешевлением памяти и наращиванием мощности процессоров ( которые теперь работают с типом float с той же скоростью, что и с double ) тип double стал стандартом для чисел с плавающей точкой.

Следующий оператор объявляет переменные lVariable типа long и dVariable типа double и присваивает им начальные значения:

      /* объявление переменной типа long и установка её равной 1 */

      long lVariable ;

      lVariable = 1

      /* объявление переменной типа double и её инициализация */

      double dVariable ;

       dVariable = 1.0 ;

«Объявить и инициализировать переменную можно одним оператором:

      int nVariable = 1 ;

           /* объявление переменной и её инициализация */

»  

[]

Единственное преимущество инициализации переменной в объявлении — уменьшение размеров текстов программ.

Переменная типа char может содержать единственный символ, в то время как строковая переменная — строку символов. Поэтому а можно интерпретировать и как символ а, и как строку, содержащую только букву а . В, вы найдёте детальное описание этого типа данных. В качестве грубой аналогии можно рассматривать символ 'а' как отдельный патрон, а строку "а" — как автомат, в магазине которого имеется только один патрон.

_________________

46 стр. . Первое знакомство с С++

«Символ а и строка а — это далеко не одно и то же. Если вы захотите присвоить символьной переменной строковое значение ( или наоборот ), вы не сможете этого сделать даже в том случае, когда строка содержит единственный символ.»

[]

Константы...47

Константой называют произвольную постоянную величину ( например, 1, 0.5 или 'с' ). Подобно переменным, константы имеют свой тип. В выражении n = 1 ; константа 1 имеет тип int. Чтобы привести 1 к типу long, нужно написать n = 1L ; . Для лучшего понимания можно провести следующую аналогию: если под 1 подразумевать поездку на грузовике, то 1L можно интерпретировать как путешествие на лимузине. Их маршруты могут быть совершенно одинаковыми, но согласитесь, что путешествовать вторым способом гораздо удобнее.

Константу 1 можно также привести к действительному числу 1.0. Однако заметим, что по умолчанию типом действительной константы является double. Поэтому 1.0 будет числом типа double , а не float.

«Величина true представляет собой константу типа bool , но " true " ( обратите внимание на кавычки ) — это уже строка. Кроме того, с учётом чувствительности С++ к регистру, true — это константа типа bool , a TRUE может быть чем угодно ( тем, чем объявит программист ).»

[]

Специальные символы...47

Для работы с любыми печатаемыми символами можно использовать переменные типа char или string. Однако значениями переменных, используемых в качестве символьных констант, могут быть и непечатаемые символы. В табл. 2.2 приведено описание некоторых важных непечатаемых символов.

С символом новой строки вы уже встречались раньше. Он позволяет разделить строку в любом месте на две части. Например, строка "Это первая строка\nЭто вторая строка" при выводе на экран будет выглядеть так:

     Это первая строка

     Это вторая строка

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

_________________

47 стр. . Премудрости объявления переменных

Коллизии между С++ и именами файлов MS DOS...48

В MS DOS для разделения имён файлов в указаниях пути используется символ обратной косой черты. Так, root\folderА\file представляет собой путь к файлу file в папке folderA, которая является подкаталогом каталога root.

К сожалению, функциональное предназначение обратной косой черты в MS DOS и С++ не совпадает. Обратная косая черта в С++ используется для обозначения управляющих символов, а её саму можно вывести с помощью символов \\. Поэтому путь MS DOS root\folderA\file должен быть представлен в С++ строкой "root\\folderA\\file". 

С++ позволяет использовать в одном выражении переменные разных типов. Например, можно складывать целые и действительные переменные. В следующем выражении переменная nValue1 является целой:

      /* в следующем выражении перед выполнением операции сложения значение nValue1 преобразуется к типу double */

      int nValue1 = 1 ;

      double dValue = nValue1 + 1.0 ;

Выражение, в котором два операнда относятся к разным типам, называется выражением смешанного типа. Тип генерируемого в результате значения будет соответствовать более мощному типу операнда. В нашем случае перед началом вычислительного процесса nValue1 конвертируется в тип double. По тому же принципу выражение одного типа может быть присвоено переменной другого типа, например:

      /*в следующем задании целая часть dVariable сохраняется в nVariable */

      double dVariable = 1.0 ;

      int nVariable ;

      nVariable = dVariable ;

«Если переменная в левой стороне равенства относится к типу менее мощному, чем переменная справа, то при таком присвоении можно потерять точность или диапазон значений ( например, если значение переменной dVariable превышает диапазон допустимых значений переменной nVariable ).»  

[]

Преобразование типа большего размера в меньший называется понижающим приведением ( demotion ), а обратное преобразование — повышающим приведением ( promotion ). 

_________________ 

48 стр. Часть 1. Первое знакомство с С++

Соглашения по именованию

Вы могли заметить, что имя каждой переменной начинается с определённого символа, который, как может показаться, совсем ни к чему ( эти специальные символы приведены в таблице ниже ). С помощью соглашений по использованию этих символов можно мгновенно распознать, что dvariable — это переменная типа double. Данные символы помогают программисту распознавать типы переменных, не обращаясь к их объявлениям в другом месте программы. Так, нетрудно определить, что в представленном ниже выражении осуществляется присвоение смешанного типа ( переменная типа long присваивается целочисленной переменной ):

       nVariable = lVariable ;

Для С++ использование этих специальных символов не имеет никакого значения. При желании для обозначения переменной типа int вы можете использовать любую другую букву. Однако "первобуквенное" соглашение упрощает понимание, и многие программисты постоянно используют подобные схемы в своей работе, хотя следующие объявления вполне корректны и допустимы в программе на С++:

      double myVariable ;

      int someIntValue ;

      double nThisDoesntEvenMatch ;

      Символ —Тип

      n — int

      l — long

      f — float

      d — double

      с —character

      sz — string 

«Использование в С++ выражений смешанного типа — идея далеко не самая блестящая; их лучше избегать, не позволяя С++ делать преобразования за вас.»

[] 

_________________ 

49 стр. Глава 2. Премудрости объявления переменных

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

Унарными называются те операторы, которые имеют только один аргумент, например -а. Унарными математическими операторами являются +, -, ++ и --. Рассмотрим некоторые из них:

      int var1 = 10 ;

      int var2 = -var1 ;

Здесь в последнем выражении используется унарный оператор "-".

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

Операторы ++ и -- увеличивают или, соответственно, уменьшают на 1 значение аргумента и поэтому называются операторами инкремента и декремента ( от англ. ( увеличивать ) и ( уменьшать ). — Прим. перев. ). К действительным переменным применение этих операторов недопустимо. После выполнения приведённого ниже фрагмента значение переменной будет равно 11.

      /*  Инициализация переменной  */

      int var = 10 ;

      /*  Её увеличение; значение  переменной равно 11 */

      var++ ;

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

Предположим, что переменная n имеет значение 5. Оба способа применения к n оператора инкремента ( ++n и n++ ) приведут к результату 6. Разница между ними состоит в том, что значение n в выражении ++n равно 6, в то время как в выражении с постфиксной формой записи оно равно 5. Это можно проиллюстрировать следующим примером:

      /* объявляем три целые переменные */

      int n1 , n2 , n3 ;

      n1 = 5 ;

      n2 = ++n1 ; /* обе переменные - n1 и n2 - получают значение 6 */

      n1 = 5 ;

      n3 = n1++ ; /* n1 принимает значение 6, а n3 - 5 */ 

Другими словами, переменной n2 присваивается уже увеличенное префиксным оператором инкремента значение n1, тогда как переменной n3 передаётся ещё не увеличенное постфиксным оператором значение n1.

Почему так важен оператор инкремента...53

Разработчики С++ заметили, что программисты прибавляют 1 чаще, чем любую другую константу. Учитывая это, в язык была добавлена соответствующая конструкция.

Кроме того, большинство процессоров способны выполнять команды инкремента быстрее, чем команды сложения. Учитывая мощность микропроцессоров, которые использовались во время создания С++, подобное нововведение было действительно важным.

_________________

53 стр. . Выполнение математических операций

Простые логические операторы приведены в табл. 4.1. Они могут возвращать два значения: true ( истина ) и false ( ложь ).

_________________

55 стр. . Выполнение логических операций

    Таблица 4.1. Простые операторы из повседневной логики

    _________________

    Оператор — Значение

    ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

    ==  — ( Равенство; истинно, когда значение левого аргумента совпадает со значением правого )

    !=   — ( Неравенство; противоположно равенству )

    > , < — ( Больше, меньше; истинно, когда значение левого выражения больше ( или меньше ) значения правого )

    >= , <=   — ( Больше или равно, меньше или равно; истинно, если истиной является > или == ( соответственно < или == ) )

&& —  ( И; истинно, если аргументы и слева и справа являются истиной )

    || — ( ИЛИ; истинно, если или левый, или правый аргумент являются истиной )

    !   — ( НЕ; истинно, если его аргумент принимает ложное значение )

    ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ 

Первые шесть операторов табл. 4.1 являются операторами сравнения. Оператор равенства используется для проверки равенства двух значений. Например, следующее выражение истинно, если значением n является 0 , и ложно во всех других случаях:

            n == 0 ;

«Не перепутайте оператор равенства ==  ( двойное равно ) с оператором присвоения = ( одинарное равно ). Эта ошибка очень распространена, к тому же компилятор С++ вообще не считает её ошибкой, что делает её вдвойне опасной!»

[]

      n = 0 ; /* Программист хотел написать, что n == 0 */

Широко распространены в повседневной жизни операторы "больше" ( > ) и "меньше" ( < ). Приведём пример логического выражения, возвращающего значение true.

      int n1 = 1 ;

      int n2 = 2 ;

      n1 < n2

«Операторы "больше" и "меньше" внешне очень похожи, и поэтому их легко перепутать. Чтобы этого не случилось, помните, что оператор-стрелочка принимает значение true в том случае, когда из двух сравниваемых значений он указывает на меньшее.»

[]

С помощью операторов > и < можно найти случаи, когда n1 больше или меньше n2, однако при этом игнорируется возможность равенства их значений. Операторы "больше или равно" ( >= ), "меньше или равно" ( <= ), в отличие от только что рассмотренных, учитывают и эту возможность.

Так же широко используются операторы && ( И ) и || ( ИЛИ ). Эти операторы обычно сочетаются с другими логическими операторами:

            /* истинно, если n2 больше n1 и меньше n3 */

            ( n1 < n2 )&&( n2 < n3 ) ;

В качестве ремарки: оператор "больше или равно" можно определить как[ 8 ]

n1 <= n2 эквивалентно ( n1 < n2 ) || ( n1 == n2 )

______________

8В качестве ещё одной ремарки: операторы сравнения вообще достаточно взаимозаменяемы. Так, например, ( a == b ) эквивалентно ( ! ( a>b )&&! ( a

_________________