Операторы c: Операторы в c и c++ — Википедия

C++ - Операторы

Оператор - это символ, который сообщает компилятору выполнить определенные математические или логические манипуляции. C ++ богат встроенными операторами и предоставляет следующие типы операторов:

  • Арифметические операторы
  • Реляционные операторы
  • Логические операторы
  • Побитовые операторы
  • Операторы присваивания
  • Другие операторы

Арифметические операторы

Существуют следующие арифметические операторы, поддерживаемые языком C ++:

Оператор Описание Пример
+ Добавляет два операнда A + B даст 30
- Вычитает второй операнд с первого A - B даст -10
* Умножает оба операнда A * B даст 200
/ Делит числитель на де-числитель B / A даст 2
% Оператор модуля и остаток после целочисленного деления
B% A даст 0
++ Оператор приращения увеличивает целочисленное значение на единицу A ++ даст 11
- Уменьшает целочисленное значение на единицу A-- даст 9

Реляционные операторы

Существуют следующие реляционные операторы, поддерживаемые языком C ++:

Оператор Описание Пример
== Проверяет, равны ли значения двух операндов или нет, если да, то условие становится истинным. (A == B) не соответствует действительности.
знак равно Проверяет, равны ли значения двух операндов или нет, если значения не равны, условие становится истинным. (A! = B) истинно.
> Проверяет, превышает ли значение левого операнда значение правого операнда, если да, тогда условие становится истинным. (A> B) неверно.
< Проверяет, является ли значение левого операнда меньше значения правильного операнда, если да, тогда условие становится истинным. (A <B) истинно.
> = Проверяет, превышает ли значение левого операнда значение правого операнда, если да, тогда условие становится истинным. (A> = B) неверно.
<= Проверяет, является ли значение левого операнда меньше или равно значению правильного операнда, если да, тогда условие становится истинным. (A <= B) истинно.

Логические операторы

Существуют следующие логические операторы, поддерживаемые языком C ++:

Оператор Описание Пример
&& Вызывается логическим оператором AND. Если оба операнда отличны от нуля, условие становится истинным. (A && B) является ложным.
|| Вызывается логическим оператором ИЛИ. Если любой из двух операндов отличен от нуля, тогда условие становится истинным. (A || B) истинно.
!
Вызывается логическим оператором NOT. Используется для изменения логического состояния операнда. Если условие истинно, то логический оператор NOT сделает ложным. ! (A && B) истинно.

Побитовые операторы

Побитовый оператор работает с битами и выполняет побитовую операцию. q 0 0 0 0 0 0 1 0 1 1 1 1 1 1 0 1 0 0 1 1

Побитовые операторы, поддерживаемые языком C ++, перечислены в следующей таблице:

Оператор Описание Пример
& Двоичный оператор AND копирует бит в результат, если он существует в обоих операндах. (A & B) даст 12, что составляет 0000 1100
|
Двоичный оператор OR копирует бит, если он существует в любом из операндов. (A | B) даст 61, который равен 0011 1101
^ Оператор двоичного XOR копирует бит, если он установлен в один операнд, но не тот и другой. B) даст 49, который равен 0011 0001
~ Binary Ones Оператор дополнения является унарным и имеет эффект «flipping» бит. (~ A) даст -61, что составляет 1100 0011 в форме дополнения 2 из-за подписанного двоичного числа.
<< Двойной левый оператор сдвига.Значение левых операндов перемещается влево на количество бит, заданных правым операндом. A << 2 даст 240, что составляет 1111 0000
>> Двоичный оператор правого сдвига. Значение левых операндов перемещается вправо на количество бит, заданных правым операндом. A >> 2 даст 15, что составляет 0000 1111

Операторы присваивания

Существуют следующие операторы присваивания, поддерживаемые языком C ++:

Оператор Описание Пример
знак равно Простой оператор присваивания, присваивает значения из правых операндов в левый операнд. C = A + B присваивает значение A + B в C
+ = Оператор Add AND присваивания, Он добавляет правый операнд в левый операнд и присваивает результат левому операнду. C + = A эквивалентно C = C + A
знак равно Subtract AND assign operator, вычитает правый операнд из левого операнда и присваивает результат левому операнду. C - = A эквивалентно C = C - A
знак равно Оператор умножения и присваивания, Он умножает правый операнд на левый операнд и присваивает результат левому операнду. C * = A эквивалентно C = C * A
знак равно Оператор Divide AND assign. Он делит левый операнд на правый операнд и присваивает результат левому операнду. C / = A эквивалентно C = C / A
знак равно Модуль и оператор присваивания, он принимает модуль с использованием двух операндов и присваивает результат левому операнду. 2
| = Побитовое включение оператора OR и присваивания. C | = 2 совпадает с C = C |2

Другие операторы

В следующей таблице перечислены некоторые другие операторы, поддерживаемые C ++:

Оператор Описание
sizeof

Возвращает размер переменной. Например, sizeof (a), где 'a' является целым числом и будет возвращать 4.

Condition ? X : Y

Если Условие истинно, то оно возвращает значение X, иначе возвращает значение Y.

,

Вызывает последовательность операций. Значение всего выражения запятой - это значение последнего выражения списка, разделенного запятыми.

. (dot) and -> (arrow)

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

Cast

Преобразуют один тип данных в другой. Например, int (2.2000) вернет 2.

&

Возвращает адрес переменной. Например, & a; даст фактический адрес переменной.

*

Является указателем на переменную. Например * var; будет указывать на переменную var.

Приоритеты операторов в C ++

Приоритет оператора определяет группировку терминов в выражении. Это влияет на оценку выражения. Некоторые операторы имеют более высокий приоритет, чем другие; например, оператор умножения имеет более высокий приоритет, чем оператор сложения -

Например, x = 7 + 3 * 2; здесь x назначается 13, а не 20, потому что оператор * имеет более высокий приоритет, чем +, поэтому он сначала умножается на 3 * 2, а затем добавляется в 7.

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

Категория  Оператор  Ассоциативность 
постфикс  () [] ->. ++ - -   Слева направо 
Одинарный  + -! ~ ++ - - (тип) * & sizeof  Справа налево 
Multiplicative   * /%  Слева направо 
присадка   + -  Слева направо 
сдвиг   << >>  Слева направо 
реляционный   <<=>> =  Слева направо 
равенство   ==! =  Слева направо 
Побитовое AND  Слева направо 
Побитовое XOR  Слева направо 
Побитовое OR  Слева направо 
Логические AND  &&  Слева направо 
Логический OR  ||  Слева направо 
условный  ?:  Справа налево 
присваивание  = + = - = * = / =% = >> = << = & = ^ = | =  Справа налево 
запятая  Слева направо

 

Операторы в C++: унарные, бинарные и тернарные | Уроки С++

  Обновл. 2 Сен 2020  | 

Как мы уже знаем из предыдущих уроков, выражение — это математический объект, который имеет определенное значение. Однако, термин «математический объект» несколько расплывчатый. Точнее будет так: выражение — это комбинация литералов, переменных, функций и операторов, которая генерирует (создает) определенное значение.

Литералы

Литерал — это фиксированное значение, которое записывается непосредственно в исходном коде (например, 7 или 3.14159). Вот пример программы, которая использует литералы:

#include <iostream> int main() { int a = 3; // a – это переменная, 3 – это литерал std::cout << 5 + 2; // 5 + 2 – это выражение, 5 и 2 – это литералы std::cout << "Hello, world!"; // "Hello, world" – это тоже литерал }

#include <iostream>

 

int main()

{

   int a = 3; // a – это переменная, 3 – это литерал

   std::cout << 5 + 2; // 5 + 2 – это выражение, 5 и 2 – это литералы

   std::cout << "Hello, world!"; // "Hello, world" – это тоже литерал

}

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

Операторы

Последним пазлом в выражениях являются операторы. С их помощью мы можем объединить операнды для получения нового значения. Например, в выражении 5 + 2, + является оператором. С помощью + мы объединили операнды 5 и 2 для получения нового значения (7).

Вы, вероятно, уже хорошо знакомы со стандартными арифметическими операторами из школьной математики: сложение (+), вычитание (-), умножение (*) и деление (/). Знак равенства = является оператором присваивания. Некоторые операторы состоят более чем из одного символа, например, оператор равенства ==, который позволяет сравнивать между собой два определенных значения.

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

Операторы бывают трёх типов:

   Унарные. Работают с одним операндом. Например, оператор (минус). В выражении −7, оператор применяется только к одному операнду (7), чтобы создать новое значение (−7).

   Бинарные. Работают с двумя операндами (левым и правым). Например, оператор +. В выражении 5 + 2, оператор + работает с левым операндом (5) и правым (2), чтобы создать новое значение (7).

   Тернарные. Работают с тремя операндами (в языке C++ есть только один тернарный оператор).

Обратите внимание, некоторые операторы могут иметь несколько значений. Например, оператор (минус) может использоваться в двух контекстах: как унарный для изменения знака числа (например, конвертировать 7 в −7 и наоборот), и как бинарный для выполнения арифметической операции вычитания (например, 4 - 3).

Заключение

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


Оценить статью:

Загрузка...

Поделиться в социальных сетях:

выражения (Expressions) и операторы (Operators)

Выражение по сути является значением (выражает значение). Самый простой пример выражения — константа (например, 123) или переменная (например, x).Выражения можно объединять и изменять с помощью операторов. Операторы принимают один или более входящих операндов и возвращают новое выражение.

12 * 30 // * - оператор; 12 и 30 - операнды

12 * 30 // * - оператор; 12 и 30 - операнды

Операнды в свою очередь также могут быть выражениями (с оператором), таким образом можно создавать сложные составные (комплексные) выражения:

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

Операторы встроенные в базовую часть языка называются основными (primary), например оператор вызова метода — ().

Выражения, которые не возвращают никакого значения, называются пустыми выражениями (void expression), например, Console.WriteLine (1). Пустые выражения не могут быть использованы в качестве операнда в других (комплексных) выражениях.

Выражения присваивания (Assignment Expressions)

В выражениях присваивания используется

оператор = позволяющий присвоить переменной значение другого выражения.

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

y = 5 * (x = 2) // y равен 10

y = 5 * (x = 2) // y равен 10

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

Составные операторы присваивания (compound assignment operators) — сокращение, объединяющее присваивание с каким-либо другим оператором:

x *= 2 // аналог x = x * 2 x <<= 1 // аналог x = x << 1

x *= 2 // аналог x = x * 2

x <<= 1 // аналог x = x << 1

Приоритет и ассоциативность операторов

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

Бинарные операторы (за исключением оператора присваивания =, лямбды => и оператора объединения со значением  Null ??) — лево-ассоциативные, т.е. выполняются слева направо (например, 8/4/2 выполняется как (8/4)/2). Порядок исполнения можно изменить с помощью скобок.

Оператор присваивания, лямбда, оператор объединения со значение Null и тернарный условный оператор — право-ассоциативные, т.е. исполняются справа налево.

Сводная таблица операторов C#

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

ОператорНазваниепримерперегружаемость 
Основные (Primary)    
.Доступ к членамx.yнет
-> Указатель на структуруx->yнет 
() Вызов функцииx()нет 
[] Массив/индексa[x]через индексатор
++ Пост-инкрементx++да
— Пост-декрементx— да 
new Новый экземплярnew Foo()нет
stackallocНебезопасное выделение стекаstackalloc(10) нет
typeofПолучить тип из идентификатораtypeof(int)нет
checkedВключить проверку переполнения целочисленных типовchecked(x)нет
unchecked Выключить проверку переполнения целочисленных типов unchecked(x)нет
defaultЗначение по умолчаниюdefault(char)нет 
awaitОжиданиеawait mytaskнет 
Унарные (Unary)    
sizeofПолучить размер структуры (struct)sizeof(int) нет
+Положительное значение+x да 
— Отрицательное значение-x да 
Отрицание (не)!xда 
~Поразрядное дополнение~xда
++ Пре-инкремент++xда 
— Пре-декремент —x да 
() Приведение к типу(int)xнет 
Значение по адресу*xнет 
Адрес значения &x нет 
Мультипликативные (Multiplicative)    
*Умножениеx * yда
Делениеx / y да 
Остаток от деления x % y да 
Аддитивные (Additive)    
Сложениеx + yда
— Вычитание x — y да 
Операторы сдвига (Shift)
<<Сдвиг влевоx << 1да
>>Сдвиг вправо x >> 1да 
ОПЕРАТОРЫ ОТНОШЕНИЙ (Relational)
Меньше чем
x < yда
Больше чем x > y да 
<= Меньше или равноx <= yда 
>= Больше или равно x >= yда 
is Принадлежность экземпляра к типу x is yнет 
as Преобразование типаx as yнет 
Операторы равенства (Equality)
==Равноx == yда
!=Не равно x != yда 
Логическое И (Logical And)
Иx & yда
Логическое исключающее ИЛИ (Logical Xor)
^Исключающее ИЛИ x ^ yда 
Логическое ИЛИ (Logical Or)
|ИЛИ x | y да
Условное И (Conditional And)   
&&Условное И x && yчерез &
Условное ИЛИ (Conditional Or)    
||Условное ИЛИ x || y через | 
Тернарный Условный оператор (Conditional (Ternary))    
? :Условие isTrue ? then
This : elseThis
нет
Присваивание и лямбда (Assignment and lambda)    
=Присвоитьx = yнет
*= Умножить себя наx *= 2 через * 
/= Разделить себя наx /= 2 через / 
+= Прибавить к себеx += 2 через + 
-= Вычесть из себяx -= 2 через — 
<<= Сдвинуть себя влево на x <<= 2 через << 
>>= Сдвинуть себя вправо на x >>= 2 через >> 
&=Назначение Иx &= 2 через &
^=Назначение исключающего ИЛИx ^= 2через ^
|=Назначение ИЛИx |= 2через |
=>Лямбдаx => x + 1нет

перегрузка оператора - cppreference.com

Настраивает операторы C ++ для операндов определяемых пользователем типов.

[править] Синтаксис

Перегруженные операторы - это функции со специальными именами:

оператор op (1)
оператор тип (2)
оператор новый
оператор новый []
(3)
оператор удалить
оператор удалить []
(4)
оператор "" суффикс-идентификатор (5) (начиная с C ++ 11)
оператор co_await (6) (начиная с C ++ 20)
оп. = & = | = << >> >> = << = ==! = <=> = <=> (начиная с C ++ 20) && || ++ -, -> * -> () []

1) перегруженный оператор;

[править] Перегруженные операторы

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

Выражение Как функция-член Как функция, не являющаяся членом Пример
@a (а).оператор @ () оператор @ (а) ! Std :: cin вызывает std :: cin.operator! ()
а @ б (а) .оператор @ (б) оператор @ (a, b) std :: cout << 42 вызова std :: cout.operator << (42)
а = б (а) .оператор = (б) не может быть не членом Дано std :: string s ;, s = "abc"; вызывает s.operator = ("abc")
а (б ...) (а).оператор () (б ...) не может быть не членом Для данного std :: random_device r ;, auto n = r (); вызывает r.operator () ()
a [b] (a) .operator [] (b) не может быть не членом Дано std :: map m ;, m [1] = 2; вызывает m.operator [] (1)
а-> (а) .оператор-> () не может быть не членом Учитывая, что std :: unique_ptr p ;, p-> bar () вызывает p.оператор -> ()
а @ (а) .оператор @ (0) оператор @ (a, 0) Для данного std :: vector :: iterator i ;, i ++ вызывает i.operator ++ (0)

в этой таблице, @ - это заполнитель, представляющий все соответствующие операторы: все префиксные операторы в @a, все постфиксные операторы, кроме -> в @, все инфиксные операторы, кроме = в a @ b

Кроме того, для операторов сравнения ==,! =, <,>, <=,> =, <=> разрешение перегрузки также учитывает переписанных кандидатов , сгенерированных из оператора == или оператора <=>.

(начиная с C ++ 20)

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

Перегруженные операторы (но не встроенные операторы) могут быть вызваны с использованием обозначения функций:

 std :: string str = "Привет,";
str.operator + = ("мир"); // то же, что и str + = "world";
оператор << (оператор << (std :: cout, str), '\ n'); // то же, что и std :: cout << str << '\ n';
                                               // (начиная с C ++ 17) кроме последовательности 

[править] Ограничения

  • Операторы :: (разрешение прицела), . (доступ к члену), . * (доступ к члену через указатель на член) и ?: (троичное условное) не могут быть перегружены.
  • Новые операторы, такие как ** , <> или & | не может быть создано.
  • Перегрузки операторов && и || потеряна оценка короткого замыкания.
  • Перегрузка оператора -> должна либо возвращать необработанный указатель, либо возвращать объект (по ссылке или по значению), для которого оператор -> , в свою очередь, перегружен.
  • Невозможно изменить приоритет, группировку или количество операндов операторов.
  • && , || и , (запятая) теряют свои особые свойства упорядочивания при перегрузке и ведут себя как обычные вызовы функций, даже если они используются без нотации вызовов функций.
(до C ++ 17)

[править] Канонические реализации

Помимо указанных выше ограничений, язык не накладывает никаких других ограничений на то, что делают перегруженные операторы, или на тип возвращаемого значения (он не участвует в разрешении перегрузки), но в целом ожидается, что перегруженные операторы будут вести себя как можно более похоже на встроенные операторы: ожидается, что оператор + будет складывать, а не умножать свои аргументы, оператор = должен назначать и т. д.Ожидается, что связанные операторы будут вести себя аналогичным образом (operator + и operator + = выполняют одну и ту же операцию, подобную сложению). Типы возвращаемых значений ограничены выражениями, в которых ожидается использование оператора: например, операторы присваивания возвращаются по ссылке, чтобы можно было записать a = b = c = d, поскольку встроенные операторы позволяют это.

Обычно перегруженные операторы имеют следующие типичные канонические формы: [1]

[править] Оператор присваивания

Оператор присваивания (operator =) имеет особые свойства: подробности см. В разделе «Копировать присваивание» и «Переместить».

Ожидается, что канонический оператор копирования-присваивания не будет выполнять никаких действий с самоприсваиванием и будет возвращать lhs по ссылке:

 // предполагаем, что объект содержит многоразовое хранилище, такое как выделенный в куче буфер mArray
T & operator = (const T & other) // копируем присвоение
{
    if (this! = & other) {// ожидается проверка самоназначения
        if (other.size! = size) {// хранилище нельзя использовать повторно
            удалить [] mArray; // уничтожаем хранилище в этом
            size = 0;
            mArray = nullptr; // сохраняем инварианты на случай, если следующая строка выдает
            mArray = новый int [другой.размер]; // создаем хранилище в этом
            size = other.size;
        }
        std :: copy (other.mArray, other.mArray + other.size, mArray);
    }
    вернуть * это;
} 

Ожидается, что каноническое присвоение перемещения оставит перемещенный объект в допустимом состоянии (то есть состояние с неизменными инвариантами класса) и либо ничего не сделает, либо, по крайней мере, оставит объект в допустимом состоянии при самоназначении и вернет lhs по ссылке на неконстантный и не должно быть исключено:

 T & operator = (T && other) noexcept // перемещаем присвоение
{
    if (this! = & other) {// запрет на самостоятельное присвоение (delete [] / size = 0 тоже нормально)
        удалить [] mArray; // удаляем это хранилище
        mArray = std :: exchange 

Приоритет оператора C ++ - cppreference.com

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

  1. ↑ Операнд sizeof не может быть приведением типа в стиле C: выражение sizeof (int) * p однозначно интерпретируется как (sizeof (int)) * p , но не sizeof ( (int) * p) .
  2. ↑ Выражение в середине условного оператора (между ? и : ) анализируется так, как если бы оно заключено в круглые скобки: его приоритет относительно ?: игнорируется.

При синтаксическом анализе выражения оператор, который указан в некоторой строке приведенной выше таблицы с приоритетом, будет более жестко привязан (как если бы в круглые скобки) к своим аргументам, чем любой оператор, указанный в строке ниже, с меньшим приоритет. Например, выражения std :: cout << a & b и * p ++ анализируются как (std :: cout << a) & b и * (p ++), а не как std :: cout << (a & b ) или (* p) ++.

Операторы с одинаковым приоритетом привязываются к своим аргументам в направлении их ассоциативности.Например, выражение a = b = c анализируется как a = (b = c), а не как (a = b) = c из-за ассоциативности присваивания справа налево, а a + b - c анализируется (a + b) - c, а не a + (b - c) из-за ассоциативности слева направо сложения и вычитания.

Спецификация ассоциативности является избыточной для унарных операторов и показана только для полноты: унарные префиксные операторы всегда связываются справа налево (delete ++ * p - это delete (++ (* p))), а унарные постфиксные операторы всегда связывают левый -право (a [1] [2] ++ равно ((a [1]) [2]) ++).Обратите внимание, что ассоциативность имеет значение для операторов доступа к членам, даже если они сгруппированы с унарными постфиксными операторами: a.b ++ анализируется (a.b) ++, а не a. (B ++).

Приоритет оператора не зависит от перегрузки оператора. Например, std :: cout << a? до н.э; анализирует как (std :: cout << a)? до н.э; потому что приоритет арифметического сдвига влево выше, чем у условного оператора.

[править] Примечания

Приоритет и ассоциативность являются концепциями времени компиляции и не зависят от порядка оценки, который является концепцией времени выполнения.

Сам стандарт не определяет уровни приоритета. Они происходят из грамматики.

const_cast, static_cast, dynamic_cast, reinterpret_cast, typeid, sizeof ..., noexcept и alignof не включаются, поскольку они никогда не бывают неоднозначными.

Некоторые операторы имеют альтернативное написание (например, и для && , или для || , а не для ! и т. Д.).

В языке C тернарный условный оператор имеет более высокий приоритет, чем операторы присваивания.Следовательно, выражение e = a а << б
а >> б

! A
a && b
a || б

a == b
a! = B
a a> b
a <= b
a> = b
a <=> b

a [b]
* a
и a
a-> b
a.б
а -> * б
а. * б

а (...)
а, б
? :

Специальные операторы

static_cast преобразует один тип в другой связанный тип
dynamic_cast преобразует в иерархиях наследования
const_cast добавляет или удаляет квалификаторы cv
reinterpret_cast преобразует тип в несвязанный тип
C-style cast преобразует один тип в другой посредством комбинации static_cast , const_cast , и reinterpret_cast
new создает объекты с динамической продолжительностью хранения.
delete уничтожает объекты, ранее созданные новым выражением, и освобождает полученную область памяти
sizeof, запрашивая размер типа
sizeof... запрашивает размер пакета параметров (начиная с C ++ 11)
typeid запрашивает информацию о типе типа
noexcept проверяет, может ли выражение вызывать исключение (начиная с C ++ 11)
alignof запросы выравнивания требований типа (начиная с C ++ 11)

Операторы C - Учебное пособие для начинающих

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

Операторы - это символы, используемые для выполнения определенной операции.

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

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

Аналогично для выполнения вычитания используется символ -. Эти символы известны как операторы, и у нас есть разные типы операторов в java.

Различные типы операций C с примерами

Арифметические операторы:

  • + на сумму после сложения
  • - для разницы после вычитания
  • * для произведения после умножения
  • / для частного после деления
  • % для остатка после подразделения

Арифметика - это основная часть математики, а сложение (+), вычитание (-), умножение (*) и деление (/) - это основные математические операции.

Операторы, относящиеся к этим операциям, известны как арифметические операторы.

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

Во многих случаях мы используем остаток после деления. Поэтому для нахождения остатка используется отдельный символ (%). Обычная косая черта (/) используется для нахождения частного.

Примечание: в языке C символ% не может применяться к данным типа float и double.

Примеры:

  • 13 + 10 это 23
  • 13–10 это 3
  • 13 * 10 это 130
  • 13/10 это 1
  • 13% 10 это 3
  • 13/10.0 равно 1,3
  • 13% 10.0 НЕ ДЕЙСТВИТЕЛЬНО
  • 123/5 это 24
  • 123% 5 это 3
  • 123,0 / 5 равно 12,3

Операторы отношения -

  • < менее
  • <= меньше или равно
  • > больше
  • > = больше или равно
  • == проверка равенства
  • ! = проверка неравенства

Эти операторы сравнивают два значения и выдают в качестве результата истину или ложь. В языке C истина представлена ​​1, а ложь - 0. Таким образом, результат реляционной операции также является целым числом (но либо 1, либо 0).

Примеры операторов отношения:

  • 13> 10 равно 1
  • 13 <10 равно 0
  • 13 <= 10 равно 0
  • 13> = 10 равно 0
  • 13 == 10 равно 0
  • 13! = 10 равно 1
  • 13 <13 это 0
  • 13> 13 равно 0
  • 13 == 13 равно 1
  • 13 <= 13 равно 1
  • 13> = 13 равно 1
  • 13! = 13 равно 0
  • ‘A’ == 65 равно 1
  • ‘0’ == 48 равно 1
  • ‘2’ == 2 равно 0

Логические операторы -

  • && логическое И
  • || логическое ИЛИ
  • ! логическое НЕ

Логические операторы также приводят к значениям истина (1) или ложь (0).Эти операторы используются для проверки нескольких условий как одного объекта.

  • Если мы хотим, чтобы значение единицы было истинным только тогда, когда оба условия истинны, тогда мы должны объединить условия, используя &&
  • Если мы хотим, чтобы значение единицы было истинным при выполнении любого из условий, мы должны объединить условия, используя ||

Чтобы инвертировать истинное значение условия, мы должны использовать!

  • 10 <20 && 10 <30 составляет 1
  • 10 <20 && 10 <5 равно 0
  • 10 <2 && 2> 5 равно 0
  • 10 <20 || 10 <30 - 1
  • 10 <20 || 10 <5 - 1
  • 10 <2 || 2> 5 равно 0
  • ! (10 <20) равно 0
  • 10 && 20 равно 1
  • ‘A’ && -4 равно 1
  • 10 && 0 это 0
  • 10 <20 && 20 <30 && 30 <40 - 1

Таблица истинности логических операторов

A B A && B A || Б! А

1 1 1 1 0

1 0 0 1 0

0 1 0 1 1

0 0 0 0 1

Условный оператор (тернарный оператор):

?:

Оператор, работающий с 3 операндами, известен как тернарный оператор.Условный оператор - единственный тернарный оператор в языке C.

Поскольку этот оператор работает с истинным значением условия (первым операндом), этот оператор известен как условный оператор. При a = 10 + 20 результат 10 + 20 присваивается a. аналогично в a = 10 == 20? 30: 40 результат 10 == 20? 30: 40 будет присвоен элементу a. в этом выражении 10 == 20 - первый операнд, 30 - второй операнд и 40 - третий операнд.

Вопросительный знак (?) Ставится между первым и вторым операндами, а двоеточие (:) ставится между вторым и третьим операндами.Фактическим результатом выражения является либо второй, либо третий операнд.

Это решение принимается на основе первого операнда, который дает в качестве результата истину (1) или ложь (0). Если это приводит к истине, второй операнд будет результатом, а если он приводит к ложному результату, третий операнд является результатом.

  • В нашем примере 10 == 20 ложно, поэтому третий операнд (40) будет результатом. Таким образом, значение 40 присваивается a.

аналогично, если мы возьмем выражение a = 25 <40? 123: 456, тогда второй операнд (123) будет назначен на «a», поскольку результат условия (первый операнд) истинно.

Например:

  • 16 == 16? 13:10 результат будет 13
  • 16! = 16? 13:10 результат будет 10
  • 10 <13? 10:13 результат будет 10
  • В этой операции второй и третий операнды должны быть одного типа.

Операторы группировки -

  • () оператор блока
  • [] оператор массива
  • .ссылающийся оператор

() может использоваться для группировки набора элементов как одного блока. Когда у нас есть выражение типа 2 + 3 * 4, в соответствии с обычными приоритетами сначала выполняется 3 * 4, а результат (12) добавляется к 2. Если мы сгруппируем 2 + 3 как одну единицу и напишем такое же выражение, как ( 2 + 3) * 4, тогда эта единичная единица (результат 5) умножается на 4 и дает 20.

Например:

((c - d) * (e + f)) * g (3 + 4.0) / (5,0 + 6)

[] используются для работы с массивами. При создании массива или для доступа к элементу массива используется этот набор квадратных скобок.

Например:

int a [10]; создание массива

х = а [2]; доступ к элементу массива

  • .Оператор (точка) используется для доступа к элементам / членам структуры.

Например:

struct rect {int l, b; };

struct rect rect1;

struct rect rect2;

rect1.length = 34; // здесь мы получаем доступ к длине элемента rect1rect2.length = 44;

// здесь мы получаем доступ к длине элемента rect2

Побитовые операторы -

  • и побитовое И
  • | побитовое ИЛИ
  • ^ побитовое исключающее ИЛИ
  • ~ побитовое НЕ (отрицание)
  • << сдвиг влево
  • >> сдвиг вправо

Таблица истинности для побитовых операторов

A B A & B A | Б А ^ В ~ А

1 1 1 1 0 0

1 0 0 1 1 1

0 1 0 1

.
Оставить комментарий

Добавить комментарий

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

© 2019 Штирлиц Сеть печатных салонов в Перми

Цифровая печать, цветное и черно-белое копирование документов, сканирование документов, ризография в Перми.